= ny\n# nzv = third dimension of scalar field array, >= nz\n nyv = kyp*kyb; nzv = kzp*kzb\n\n# allocate vector array\n if (\"vfield\" not in globals()):\n vfield = numpy.empty((in3.ndim,nx,nyv,nzv),float_type,'F')\n dt = in3.dt*float(nts[0])\n\n# open stream file for vector field\n cmfield3.fsopen3(iuv,fname)\n\n# nrec = number of complete records\n nrec = int(nrec/(kyb*kzb))\n print (\"records found: nrec = \", nrec)\n\n# read and transpose vector data\n for ii in range(0,nrec):\n# read real vector field\n cmfield3.freadv3(iuv,vfield,in3.ndim,nx,kyp,kyb,kzp,kzb)\n it = nts[0]*ii\n time = dt*float(ii)\n# show time\n print (\"it,time=\",it,time)\n cmfield3.closeff3(iuv)\n print()","def test_ne():\n # Define some universal gsps\n gsp = galsim.GSParams(maxk_threshold=1.1e-3, folding_threshold=5.1e-3)\n\n # Pixel. Params include scale, flux, gsparams.\n # gsparams.\n # The following should all test unequal:\n gals = [galsim.Pixel(scale=1.0),\n galsim.Pixel(scale=1.1),\n galsim.Pixel(scale=1.0, flux=1.1),\n galsim.Pixel(scale=1.0, gsparams=gsp)]\n all_obj_diff(gals)\n\n # Box. Params include width, height, flux, gsparams.\n # gsparams.\n # The following should all test unequal:\n gals = [galsim.Box(width=1.0, height=1.0),\n galsim.Box(width=1.1, height=1.0),\n galsim.Box(width=1.0, height=1.1),\n galsim.Box(width=1.0, height=1.0, flux=1.1),\n galsim.Box(width=1.0, height=1.0, gsparams=gsp)]\n all_obj_diff(gals)\n\n # TopHat. Params include radius, flux, gsparams.\n # gsparams.\n # The following should all test unequal:\n gals = [galsim.TopHat(radius=1.0),\n galsim.TopHat(radius=1.1),\n galsim.TopHat(radius=1.0, flux=1.1),\n galsim.TopHat(radius=1.0, gsparams=gsp)]\n all_obj_diff(gals)","def main():\n regexham = r'\\s+\\((\\d+,\\s*\\d+)\\)\\s+([\\-+]?\\d+\\.\\d+[eEdD]?[\\-+]?\\d+)' #to extract the Hamiltonian.\n root = '.'\n #fname = 'output_files/'\n ciffci = CIFlow_Reader('testfci.dat', regexp = regexham , read_ham= True)\n ciffcipar = CIFlow_Reader( 'psi0_output10outputfci.dat', regexp = regexham , read_ham = True)\n #print ciffci.calc_overlap(cifdoci)\n #print e.get_groundstate('00000000000011|00000000000011') \n\n psir = rp.PsiReader('psi0_output10.dat', isbig = False, numorbs = -1 , read_ints = False)\n\n detlist = dw.cimain(psir.values['nalpha'],psir.values['nbeta'], psir.values['norb'], [range(1,psir.values['nalpha']+psir.values['nbeta']), []], [] , fname = 'determinants.dat' ,ref = [lambda x , y , z : psir.get_hf_orbs()] , add_frozen = 0, write = False) #CISDDOCI\n count = 0\n for det in detlist:\n for det2 in detlist:\n #+ because the eigenvectors have already a different phasefactor of 1.\n if abs(ciffci.get_mat_element(det[0]+'|'+det[1], det2[0]+'|'+det2[1]) - ciffcipar.get_mat_element(det[0]+'|'+det[1], det2[0]+'|'+det2[1]) ) > 1e-10 :\n print 'difference in hamiltonian row: ' , det[0]+'|'+det[1] , \" col: \" , det2[0]+'|'+det2[1] , 'fci: ', ciffci.get_mat_element(det[0]+'|'+det[1], det2[0]+'|'+det2[1]) , 'fciaddres: ' , ciffcipar.get_mat_element(det[0]+'|'+det[1],det2[0]+'|'+det2[1]) \n count += 1\n print 'There were ' , count , ' different elements'","def compare_present_day_river_directions_with_catchments_virna_data_with_vs_without_tarasov_style_orog_corrs(self):\n ref_filename=os.path.join(self.plots_data_dir,\n \"flowmap_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans\"\n \"_lsmask_plus_upscale_rdirs_tarasov_orog_corrs_20170422_195301_upscaled_updated.nc\")\n data_filename=os.path.join(self.plots_data_dir,\n \"flowmap_ten_minute_data_from_virna_0k_ALG4_sinkless\"\n \"_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_20170123\"\n \"_165707_upscaled_updated.nc\")\n lsmask_filename=os.path.join(self.plots_data_dir,\n \"ls_mask_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask\"\n \"_plus_upscale_rdirs_tarasov_orog_corrs_20170422_195301_HD_transf.nc\")\n ref_catchment_filename=(\"catchmentmap_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask\"\n \"_plus_upscale_rdirs_tarasov_orog_corrs_20170422_195301_upscaled_updated.nc\")\n data_catchment_filename=(\"catchmentmap_ten_minute_data_from_virna_0k_ALG4_sinkless\"\n \"_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_20170123_165707_upscaled_updated.nc\")\n ref_rdirs_filename=(\"upscaled_rdirs_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_\"\n \"sinks_oceans_lsmask_plus_upscale_rdirs_tarasov_orog_corrs_20170422_195301_upscaled_\"\n \"updated_transf.dat\")\n reference_rmouth_outflows_filename=(self.plots_data_dir + \"/rmouthmap_ten_minute_\"\n \"data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale\"\n \"_rdirs_tarasov_orog_corrs_20170422_195301_upscaled_updated.nc\")\n data_rmouth_outflows_filename=(self.plots_data_dir + \"/rmouths/rmouthmap_ten_\"\n \"minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus\"\n \"_upscale_rdirs_20170123_165707_upscaled_updated.nc\")\n glacier_mask_filename=os.path.join(self.orog_data_directory,\"ice5g_v1_2_21_0k_10min.nc\")\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\n data_flowmap_filename=data_filename,\n ref_catchment_filename=\\\n ref_catchment_filename,\n data_catchment_filename=\\\n data_catchment_filename,\n ref_rdirs_filename=\\\n ref_rdirs_filename,\n data_rdirs_filename=None,\n reference_rmouth_outflows_filename=\\\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename=\\\n data_rmouth_outflows_filename,\n lsmask_filename=lsmask_filename,\n minflowcutoff=100,\n flip_data=False,\n rotate_data=True,\n flip_ref=False,\n rotate_ref=True,\n lsmask_has_same_orientation_as_ref=False,\n invert_ls_mask=True,\n first_datasource_name=\"Present day\",\n second_datasource_name=\"LGM\",\n matching_parameter_set='extensive',\n catchment_and_outflows_mods_list_filename=\\\n \"catch_and_outflow_mods_lgm_vs_present_day.txt\",\n additional_matches_list_filename=\\\n \"additional_matches_10min_upscaled_lgm_vs_present.txt\",\n use_single_color_for_discrepancies=True,\n use_only_one_color_for_flowmap=False,\n use_title=False,remove_antartica=True,\n difference_in_catchment_label=\"Difference\",\n glacier_mask_filename=glacier_mask_filename,\n glacier_mask_grid_type='LatLong10min',\n flip_glacier_mask=True,\n rotate_glacier_mask=True,\n grid_type='HD')","def compare_predictions():\n validation_labels = np.array(pd.read_csv(val_true_labels_dir + dataset_version + 'validation_labels.csv', index_col=0))\n validation_labels = np.reshape(validation_labels, (-1))\n\n diff_between_files = []\n also1s = []\n also2s = []\n for filename1 in os.listdir(val_predictions_dir):\n if filename1.endswith(\".csv\"):\n for filename2 in os.listdir(val_predictions_dir):\n if filename2.endswith(\".csv\"):\n if filename1 < filename2:\n wrong1 = 0\n wrong2 = 0\n diff_between = 0\n also1 = 0\n also2 = 0\n diff_corr1 = 0\n diff_corr2 = 0\n f1 = np.array(pd.read_csv(val_predictions_dir + filename1, index_col=0))\n f1 = np.reshape(f1, (-1))\n f2 = np.array(pd.read_csv(val_predictions_dir + filename2, index_col=0))\n f2 = np.reshape(f2, (-1))\n for line in range(f1.shape[0]):\n if f1[line] != validation_labels[line]:\n wrong1 += 1\n if f2[line] != validation_labels[line]:\n wrong2 += 1\n if f1[line] != f2[line]:\n diff_between += 1\n if f1[line] == validation_labels[line]:\n diff_corr1 += 1\n if f2[line] == validation_labels[line]:\n diff_corr2 += 1\n if f1[line] != validation_labels[line]:\n if f2[line] != validation_labels[line]:\n also2 += 1\n if f2[line] != validation_labels[line]:\n if f1[line] != validation_labels[line]:\n also1 += 1\n\n diff_between_files.append(diff_between)\n print(filename1)\n print('Wrongly predicted by 1: ' + str(100 * wrong1 / f1.shape[0]) + '%')\n print(filename2)\n print('Wrongly predicted by 2: ' + str(100 * wrong2 / f1.shape[0]) + '%')\n print()\n print('Differences between files: ' + str(100 * diff_between / f1.shape[0]) + '%')\n print(f'\\t of which correct by 1 {100 * diff_corr1 / diff_between}%, by 2 {100 * diff_corr2 / diff_between}%')\n also1s.append(also1 / wrong2)\n also2s.append(also2 / wrong1)\n print('Wrongly predicted by other among wrong ones: ' + str(100 * also2 / wrong1) + '%, ' + str(\n 100 * also1 / wrong2) + '%\\n\\n\\n')\n\n print('Max, min and avg differences between files:')\n print(str(100 * max(diff_between_files) / validation_labels.shape[0]) + '%')\n print(str(100 * min(diff_between_files) / validation_labels.shape[0]) + '%')\n print(str(100 * np.mean(diff_between_files) / validation_labels.shape[0]) + '%')\n\n print('\\nWrongly predicted by first that were also wrongly predicted by second:')\n print('Max: ' + str(100 * max(also2s)) + '%')\n print('Min: ' + str(100 * min(also2s)) + '%')\n print('Avg: ' + str(100 * np.mean(also2s)) + '%')\n\n print('\\nWrongly predicted by second that were also wrongly predicted by first:')\n print('Max: ' + str(100 * max(also1s)) + '%')\n print('Min: ' + str(100 * min(also1s)) + '%')\n print('Avg: ' + str(100 * np.mean(also1s)) + '%')","def compare_present_day_and_lgm_river_directions_with_catchments_virna_data_plus_tarasov_style_orog_corrs_for_both(self):\n ref_filename=os.path.join(self.plots_data_dir,\n \"flowmap_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans\"\n \"_lsmask_plus_upscale_rdirs_tarasov_orog_corrs_20170422_195301_upscaled_updated.nc\")\n data_filename=os.path.join(self.plots_data_dir,\n \"flowmap_ten_minute_data_from_virna_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask\"\n \"_plus_upscale_rdirs_tarasov_orog_corrs_20170422_195436_upscaled_updated.nc\")\n lsmask_filename=os.path.join(self.plots_data_dir,\n \"ls_mask_ten_minute_data_from_virna_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask\"\n \"_plus_upscale_rdirs_tarasov_orog_corrs_20170422_195436_HD_transf.dat\")\n ref_catchment_filename=(\"catchmentmap_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask\"\n \"_plus_upscale_rdirs_tarasov_orog_corrs_20170422_195301_upscaled_updated.nc\")\n data_catchment_filename=(\"catchmentmap_ten_minute_data_from_virna_lgm_ALG4_sinkless_no_true_sinks_oceans_\"\n \"lsmask_plus_upscale_rdirs_tarasov_orog_corrs_20170422_195436_upscaled_updated.nc\")\n ref_rdirs_filename=(\"upscaled_rdirs_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_\"\n \"sinks_oceans_lsmask_plus_upscale_rdirs_tarasov_orog_corrs_20170422_195301_upscaled_\"\n \"updated_transf.dat\")\n reference_rmouth_outflows_filename=(self.plots_data_dir + \"/rmouthmap_ten_minute_\"\n \"data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale\"\n \"_rdirs_tarasov_orog_corrs_20170422_195301_upscaled_updated.nc\")\n data_rmouth_outflows_filename=(self.plots_data_dir + \"/rmouthmap_ten_minute_\"\n \"data_from_virna_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale\"\n \"_rdirs_tarasov_orog_corrs_20170422_195436_upscaled_updated.nc\")\n glacier_mask_filename=os.path.join(self.orog_data_directory,\"ice5g_v1_2_21_0k_10min.nc\")\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\n data_flowmap_filename=data_filename,\n ref_catchment_filename=\\\n ref_catchment_filename,\n data_catchment_filename=\\\n data_catchment_filename,\n ref_rdirs_filename=\\\n ref_rdirs_filename,\n data_rdirs_filename=None,\n reference_rmouth_outflows_filename=\\\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename=\\\n data_rmouth_outflows_filename,\n lsmask_filename=lsmask_filename,\n minflowcutoff=100,\n flip_data=False,\n rotate_data=True,\n flip_ref=False,\n rotate_ref=True,\n lsmask_has_same_orientation_as_ref=False,\n invert_ls_mask=True,\n first_datasource_name=\"Present day\",\n second_datasource_name=\"LGM\",\n matching_parameter_set='extensive',\n catchment_and_outflows_mods_list_filename=\\\n \"catch_and_outflow_mods_lgm_vs_present_day.txt\",\n additional_matches_list_filename=\\\n \"additional_matches_10min_upscaled_lgm_vs_present.txt\",\n use_single_color_for_discrepancies=True,\n use_only_one_color_for_flowmap=False,\n use_title=False,remove_antartica=True,\n difference_in_catchment_label=\"Difference\",\n glacier_mask_filename=glacier_mask_filename,\n glacier_mask_grid_type='LatLong10min',\n flip_glacier_mask=True,\n rotate_glacier_mask=True,\n grid_type='HD')","def AdvancedOutFlowComparisonPlotHelpers(self,\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename,\n ref_flowmaps_filename,\n data_flowmaps_filename,\n ref_rdirs_filename,\n data_rdirs_filename,\n ref_catchment_filename,\n data_catchment_filename,\n ref_orog_filename,\n data_orog_filename,\n super_fine_orog_filename=None,\n super_fine_data_flowmap_filename=None,\n external_ls_mask_filename=None,\n additional_matches_list_filename=None,\n catchment_and_outflows_mods_list_filename=None,\n rivers_to_plot=None,\n matching_parameter_set='default',\n select_only_rivers_in=None,\n allow_new_true_sinks=False,\n alternative_catchment_bounds=None,\n use_simplified_catchment_colorscheme=False,\n use_simplified_flowmap_colorscheme=False,\n use_upscaling_labels=False,\n swap_ref_and_data_when_finding_labels=False,\n super_fine_orog_grid_type='LatLong1min',\n grid_type='HD',\n super_fine_orog_grid_kwargs={},\n **grid_kwargs):\n ref_catchment_field = advanced_field_loader(ref_catchment_filename,\n time_slice=None,\n fieldname=\"catch\",\n adjust_orientation=True)\n data_catchment_field = advanced_field_loader(data_catchment_filename,\n time_slice=None,\n fieldname=\"catch\",\n adjust_orientation=True)\n ref_flowtocellfield = advanced_field_loader(ref_flowmaps_filename,\n time_slice=None,\n fieldname=\"acc\",\n adjust_orientation=True)\n data_flowtocellfield = advanced_field_loader(data_flowmaps_filename,\n time_slice=None,\n fieldname=\"acc\",\n adjust_orientation=True)\n ref_rdirs_field = advanced_field_loader(ref_rdirs_filename,\n time_slice=None,\n fieldname=\"rdir\",\n adjust_orientation=True)\n data_rdirs_field = advanced_field_loader(data_rdirs_filename,\n time_slice=None,\n fieldname=\"rdir\",\n adjust_orientation=True)\n ref_orog_field = advanced_field_loader(ref_orog_filename,\n time_slice=None,\n fieldname=\"z\",\n adjust_orientation=True)\n data_orog_field = advanced_field_loader(data_orog_filename,\n time_slice=None,\n fieldname=\"z\",\n adjust_orientation=True)\n super_fine_orog_field = advanced_field_loader(super_fine_orog_filename,\n time_slice=None,\n fieldname=\"z\",\n adjust_orientation=True)\n\n super_fine_flowtocellfield = None\n if external_ls_mask_filename is not None:\n external_ls_mask = advanced_field_loader(external_ls_mask_filename,\n time_slice=None,\n fieldname=\"lsmask\",\n adjust_orientation=True)\n else:\n external_ls_mask = None\n scale_factor = 1.0\n catchment_grid_changed = False\n temp_file_list = []\n if catchment_and_outflows_mods_list_filename:\n ref_outflow_field = advanced_field_loader(reference_rmouth_outflows_filename,\n time_slice=None,\n fieldname=\"acc\",\n adjust_orientation=True)\n data_outflow_field = advanced_field_loader(data_rmouth_outflows_filename,\n time_slice=None,\n fieldname=\"acc\",\n adjust_orientation=True)\n ref_catchment_field, ref_outflow_field, data_catchment_field, data_outflow_field =\\\n rc_pts.modify_catchments_and_outflows(ref_catchments=ref_catchment_field,\n ref_outflows=ref_outflow_field,\n ref_flowmap=ref_flowtocellfield,\n ref_rdirs = ref_rdirs_field,\n data_catchments=data_catchment_field,\n data_outflows=data_outflow_field,\n catchment_and_outflows_modifications_list_filename=\\\n catchment_and_outflows_mods_list_filename,\n original_scale_catchment=\\\n None,\n original_scale_flowmap=\\\n None,\n catchment_grid_changed=False,\n swap_ref_and_data_when_finding_labels=\\\n swap_ref_and_data_when_finding_labels,\n original_scale_grid_type=\\\n None,\n original_scale_grid_kwargs=\\\n None,\n grid_type=grid_type,**grid_kwargs)\n reference_rmouth_outflows_filename=os.path.join(self.scratch_dir,\n self.temp_label + os.path.\\\n basename(reference_rmouth_outflows_filename))\n data_rmouth_outflows_filename=os.path.join(self.scratch_dir,\n self.temp_label + os.path.\\\n basename(reference_rmouth_outflows_filename))\n temp_file_list.append(reference_rmouth_outflows_filename)\n temp_file_list.append(data_rmouth_outflows_filename)\n iodriver.advanced_field_writer(reference_rmouth_outflows_filename,\n ref_outflow_field,\n fieldname=\"acc\")\n iodriver.advanced_field_writer(data_rmouth_outflows_filename,\n data_outflow_field,\n fieldname=\"acc\")\n matchedpairs, unresolved_conflicts = mtch_rm.advanced_main(reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename,\n 'acc',\"acc\",\n param_set=matching_parameter_set)\n if additional_matches_list_filename:\n additional_matches = mtch_rm.load_additional_manual_matches(additional_matches_list_filename,\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename,\n grid_type=grid_type,\n **grid_kwargs)\n matchedpairs.extend(additional_matches)\n interactive_plots = Interactive_Plots()\n super_fine_grid = grid.makeGrid(super_fine_orog_grid_type,\n **super_fine_orog_grid_kwargs)\n ref_grid = grid.makeGrid(grid_type,**grid_kwargs)\n fine_grid = grid.makeGrid(grid_type,**grid_kwargs)\n river_names = []\n for pair in matchedpairs:\n if pair[0].get_lat() > 310*3:\n continue\n if select_only_rivers_in == \"North America\":\n if(pair[0].get_lat() > 156*3 or pair[0].get_lon() > 260*3):\n continue\n print(\"Ref Point: \" + str(pair[0]) + \"Matches: \" + str(pair[1]))\n if rivers_to_plot is not None:\n if not (pair[0].get_lat(),pair[0].get_lon()) in rivers_to_plot:\n continue\n formatted_river_name = pts.generate_label_for_river(pair,scale_factor=6,\n river_names=river_names)\n fig = plt.figure(formatted_river_name + \" - Overview\",figsize=(25,12.5))\n fig.suptitle(formatted_river_name)\n ax = plt.subplot(222)\n rc_pts.plot_river_rmouth_flowmap(ax=ax,\n ref_flowtocellfield=ref_flowtocellfield.get_data(),\n data_flowtocellfield=data_flowtocellfield.get_data(),\n rdirs_field=ref_rdirs_field.get_data(),\n pair=pair,colors=self.colors,\n point_label_coords_scaling=3)\n ax_hist = plt.subplot(221)\n ax_catch = plt.subplot(223)\n catchment_section,catchment_bounds,scale_factor = \\\n rc_pts.plot_catchment_and_histogram_for_river(ax_hist=ax_hist,ax_catch=ax_catch,\n ref_catchment_field=ref_catchment_field.get_data(),\n data_catchment_field=data_catchment_field.get_data(),\n data_catchment_field_original_scale=\\\n data_catchment_field.get_data(),\n data_original_scale_flowtocellfield=\\\n data_flowtocellfield.get_data(),\n rdirs_field=ref_rdirs_field.get_data(),\n data_rdirs_field=data_rdirs_field.get_data(),\n pair=pair,\n catchment_grid_changed=catchment_grid_changed,\n swap_ref_and_data_when_finding_labels=\\\n swap_ref_and_data_when_finding_labels,\n colors=self.colors,\n ref_grid=ref_grid,\n grid_type=grid_type,\n alternative_catchment_bounds=\\\n alternative_catchment_bounds,\n use_simplified_catchment_colorscheme=\\\n use_simplified_catchment_colorscheme,\n use_upscaling_labels=\\\n use_upscaling_labels,\n allow_new_sink_points=\\\n allow_new_true_sinks,\n external_landsea_mask=\\\n external_ls_mask,\n ref_original_scale_flowtocellfield=\\\n ref_flowtocellfield,\n ref_catchment_field_original_scale=\\\n ref_catchment_field,\n use_original_scale_field_for_determining_data_and_ref_labels=\\\n False,\n return_catchment_plotter=\\\n False,\n data_original_scale_grid_type=\\\n grid_type,\n ref_original_scale_grid_type=\\\n grid_type,\n data_original_scale_grid_kwargs=\\\n grid_kwargs,\n ref_original_scale_grid_kwargs=\\\n grid_kwargs,\n **grid_kwargs)\n ax = plt.subplot(224)\n rc_pts.plot_whole_river_flowmap(ax=ax,pair=pair,\n ref_flowtocellfield=ref_flowtocellfield.get_data(),\n data_flowtocellfield=data_flowtocellfield.get_data(),\n rdirs_field=ref_rdirs_field.get_data(),\n data_rdirs_field=data_rdirs_field.get_data(),\n catchment_bounds=catchment_bounds,colors=self.colors,\n simplified_flowmap_plot=use_simplified_flowmap_colorscheme,\n allow_new_sink_points=allow_new_true_sinks)\n if super_fine_orog_filename:\n ref_to_super_fine_scale_factor = \\\n pts.calculate_scale_factor(coarse_grid_type=grid_type,\n coarse_grid_kwargs=grid_kwargs,\n fine_grid_type=super_fine_orog_grid_type,\n fine_grid_kwargs=super_fine_orog_grid_kwargs)\n else:\n ref_to_super_fine_scale_factor=None\n interactive_plots.setup_plots(catchment_section,\n ref_orog_field.get_data(),\n data_orog_field.get_data(),\n ref_flowtocellfield.get_data(),\n data_flowtocellfield.get_data(),\n ref_rdirs_field.get_data(),\n super_fine_orog_field.get_data(),\n super_fine_flowtocellfield.get_data()\n if super_fine_flowtocellfield is not None else None,\n pair, catchment_bounds,\n scale_factor,\n ref_to_super_fine_scale_factor,\n ref_grid_offset_adjustment=ref_grid.\\\n get_longitude_offset_adjustment(),\n fine_grid_offset_adjustment=fine_grid.\\\n get_longitude_offset_adjustment(),\n super_fine_grid_offset_adjustment=super_fine_grid.\\\n get_longitude_offset_adjustment(),\n point_label_coords_scaling=3,\n river_name=formatted_river_name)\n print(\"Unresolved Conflicts: \")\n for conflict in unresolved_conflicts:\n print(\" Conflict:\")\n for pair in conflict:\n print(\" Ref Point\" + str(pair[0]) + \"Matches\" + str(pair[1]))\n for temp_file in temp_file_list:\n if os.path.basename(temp_file).startswith(\"temp_\"):\n print(\"Deleting File: {0}\".format(temp_file))\n os.remove(temp_file)","def test_hsmcatalog():\n if __name__ == '__main__':\n logger = piff.config.setup_logger(verbose=2)\n else:\n logger = piff.config.setup_logger(log_file='output/test_hsmcatalog.log')\n\n image_file = os.path.join('output','test_stats_image.fits')\n cat_file = os.path.join('output','test_stats_cat.fits')\n psf_file = os.path.join('output','test_starstats.fits')\n hsm_file = os.path.join('output', 'test_hsmcatalog.fits')\n config = {\n 'input' : {\n 'image_file_name' : image_file,\n 'cat_file_name' : cat_file,\n 'stamp_size' : 48,\n },\n 'select' : {\n 'reserve_frac' : 0.2,\n 'seed' : 123\n },\n 'psf' : {\n 'model' : { 'type' : 'Gaussian',\n 'fastfit': True,\n 'include_pixel': False },\n 'interp' : { 'type' : 'Mean' },\n },\n 'output' : {\n 'file_name' : psf_file,\n 'stats' : [\n {\n 'type': 'HSMCatalog',\n 'file_name': hsm_file,\n }\n ]\n }\n }\n piff.piffify(config, logger)\n assert os.path.isfile(hsm_file)\n\n data, header = fitsio.read(hsm_file, header=True)\n for col in ['ra', 'dec', 'x', 'y', 'u', 'v',\n 'T_data', 'g1_data', 'g2_data',\n 'T_model', 'g1_model', 'g2_model',\n 'flux', 'reserve', 'flag_data', 'flag_model']:\n assert len(data[col]) == 10\n true_data = fitsio.read(cat_file)\n\n assert header['PIFF_VERSION'] == piff.__version__\n\n np.testing.assert_allclose(data['x'], true_data['x'])\n np.testing.assert_allclose(data['y'], true_data['y'])\n np.testing.assert_allclose(data['flux'], 123.45, atol=0.001)\n print('reserve = ',data['reserve'])\n print('nreserve = ',np.sum(data['reserve']))\n print('ntot = ',len(data['reserve']))\n assert np.sum(data['reserve']) == int(0.2 * len(data['reserve']))\n np.testing.assert_allclose(data['T_model'], data['T_data'], rtol=1.e-4)\n np.testing.assert_allclose(data['g1_model'], data['g1_data'], rtol=1.e-4)\n np.testing.assert_allclose(data['g2_model'], data['g2_data'], rtol=1.e-4)\n\n # On this file, no hsm errors\n np.testing.assert_array_equal(data['flag_data'], 0)\n np.testing.assert_array_equal(data['flag_model'], 0)\n\n image = galsim.fits.read(image_file)\n world = [image.wcs.toWorld(galsim.PositionD(x,y)) for x,y in zip(data['x'],data['y'])]\n np.testing.assert_allclose(data['ra'], [w.ra.deg for w in world], rtol=1.e-4)\n np.testing.assert_allclose(data['dec'], [w.dec.deg for w in world], rtol=1.e-4)\n\n # Repeat with non-Celestial WCS\n wcs = galsim.AffineTransform(0.26, 0.05, -0.08, -0.24, galsim.PositionD(1024,1024))\n config['input']['wcs'] = wcs\n piff.piffify(config, logger)\n data = fitsio.read(hsm_file)\n np.testing.assert_array_equal(data['ra'], 0.)\n np.testing.assert_array_equal(data['dec'], 0.)\n world = [wcs.toWorld(galsim.PositionD(x,y)) for x,y in zip(data['x'],data['y'])]\n np.testing.assert_allclose(data['u'], [w.x for w in world], rtol=1.e-4)\n np.testing.assert_allclose(data['v'], [w.y for w in world], rtol=1.e-4)\n\n # Use class directly, rather than through config.\n psf = piff.PSF.read(psf_file)\n stars, _, _ = piff.Input.process(config['input'])\n stars = piff.Select.process(config['select'], stars)\n hsmcat = piff.stats.HSMCatalogStats()\n with np.testing.assert_raises(RuntimeError):\n hsmcat.write('dummy') # Cannot write before compute\n hsmcat.compute(psf, stars)\n hsm_file2 = os.path.join('output', 'test_hsmcatalog2.fits')\n with np.testing.assert_raises(ValueError):\n hsmcat.write() # Must supply file_name if not given in constructor\n hsmcat.write(hsm_file2)\n data2 = fitsio.read(hsm_file2)\n for key in data.dtype.names:\n np.testing.assert_allclose(data2[key], data[key], rtol=1.e-5)","def compare_displacements(ds1,ds2):\n # Obteniendo los datos para BP\n t1 = ds1['t']\n t1 = t1[:n_im-1]\n t1 = mplt.dates.date2num(t1)\n d1 = ds1['d_t']\n # Obteniendo los datos para RMA\n t2 = ds2['t']\n t2 = t2[:n_im-1]\n t2 = mplt.dates.date2num(t2)\n d2 = ds2['d_t']\n\n # Graficando las 2 curvas juntas\n formatter = DateFormatter(\"%d/%m - %H:%M\")\n for i in range(len(d1)):\n # Hallando el valor promedio final x zona\n mean_bp = d1[i].mean()\n mean_rma = d2[i].mean()\n print(\"Valor promedio BP_zona\"+str(i)+\": \",mean_bp)\n print(\"Valor promedio RMA_zona\"+str(i)+\": \",mean_rma)\n print(\"\")\n # Graficando\n direction = 'desplazamientosPromedios_dset'+str(i_o)+'-'+str(i_o+n_im-1)+'_zona'+str(i)\n\n fig, ax= plt.subplots(figsize=(10,7))\n ax.plot_date(t1,d1[i],'b',marker='',markerfacecolor='b',markeredgecolor='b',label='Back Projection')\n ax.plot_date(t2,d2[i],'r',marker='',markerfacecolor='r',markeredgecolor='r',label='RMA')\n ax.set(xlabel='Tiempo',ylabel='Desplazamiento(mm)',title=\"Desplazamientos promedios\\n(Zona \"+str(i)+')')\n ax.xaxis.set_major_formatter(formatter)\n ax.xaxis.set_tick_params(rotation=20)\n #ax.set_xlim([R.min(),R.max()])\n ax.set_ylim([-c*1000*4/(4*fc),c*1000*4/(4*fc)])\n ax.grid(linestyle='dashed')\n ax.legend()\n plt.show()\n fig.savefig(os.getcwd()+\"/Results/Desplazamientos/\"+direction,orientation='landscape')\n\n return 'Ok'","def compare_brain_and_stimulus_input_data(self):\t\n\n\t\t# first check which (unique) patches are presented\n\t\tstim_info = np.loadtxt(self.runFile(stage = 'processed/behavior', extension = '.txt', postFix = ['stim_info_all']))\n\t\tunique_stim = np.unique(stim_info[:,2])\n\t\tstimuli = np.array(self.rescale_images(patches = list(np.array(unique_stim, dtype = int))))\n\n\t\t# select patches that are similar and patches that are dissimilar\n\t\tmask = self.create_stim_mask(stim_shape = stimuli.shape[1], radius_inner = 0.04, outer = False)\n\t\t\n\t\t# create correlation matrix for all presented stimuli\n\t\tstim_correlations = np.zeros((stimuli.shape[0], stimuli.shape[0]))\n\t\t\t\n\t\tfor i, stim in enumerate(stimuli): # all stimuli\n\t\t\tstim_correlations[i, :] = np.array([pearsonr(stim.ravel()[mask], stim_2.ravel()[mask])[0] for stim_2 in stimuli])\n\n\t\t# store similarity info per individual stimuli [stimuli, less similar, most, similar]\t\t\n\t\tstim_similarity = np.array([[unique_stim[i], unique_stim[np.argsort(stim_correlations[i])[0]], unique_stim[np.argsort(stim_correlations[i])[-2]]] for i in range(stim_correlations.shape[0])])\t\t\n\n\n\t\tstim_correlations[i][np.argsort(stim_correlations[i])[0]], stim_correlations[i][np.argsort(stim_correlations[i])[-2]]","def run_multi_medium_inversion(datadir, outdir, real_data_fnames, MT_green_func_fnames, single_force_green_func_fnames, data_labels, inversion_type, perform_normallised_waveform_inversion, compare_all_waveforms_simultaneously, num_samples, comparison_metric, manual_indices_time_shift_MT, manual_indices_time_shift_SF, nlloc_hyp_filename, cut_phase_start_vals=[], cut_phase_length=0, plot_switch=False, num_processors=1, set_pre_time_shift_values_to_zero_switch=True, only_save_non_zero_solns_switch=False, return_absolute_similarity_values_switch=False, invert_for_ratio_of_multiple_media_greens_func_switch=False, green_func_fnames_split_index=0, green_func_phase_labels=[], invert_for_relative_magnitudes_switch=False, rel_exp_mag_range=[1.,1.], auto_shift_for_best_fit=True):\n \n # Load input data (completely, for specific inversion type):\n real_data_array, green_func_array = get_overall_real_and_green_func_data(datadir, real_data_fnames, MT_green_func_fnames, single_force_green_func_fnames, inversion_type, manual_indices_time_shift_MT=manual_indices_time_shift_MT, manual_indices_time_shift_SF=manual_indices_time_shift_SF, cut_phase_start_vals=cut_phase_start_vals, cut_phase_length=cut_phase_length, set_pre_time_shift_values_to_zero_switch=set_pre_time_shift_values_to_zero_switch, invert_for_ratio_of_multiple_media_greens_func_switch=invert_for_ratio_of_multiple_media_greens_func_switch, green_func_fnames_split_index=green_func_fnames_split_index)\n \n # Do initial check/s:\n if len(green_func_phase_labels)>0:\n if not len(green_func_array[:,0,0,0]) == len(green_func_phase_labels):\n print(\"Error: Greens functions filename array (for medium 1), does not match length of green_func_phase_labels array.\")\n sys.exit()\n \n # Get number of different phases, if specified:\n num_phase_types_for_media_ratios = 0\n if green_func_phase_labels.count(\"P\")>0:\n num_phase_types_for_media_ratios += 1\n if green_func_phase_labels.count(\"S\")>0:\n num_phase_types_for_media_ratios += 1\n if green_func_phase_labels.count(\"surface\")>0:\n num_phase_types_for_media_ratios += 1\n \n # Define a fraction of the second medium to use for the simple least squares inversion:\n frac_medium_2 = 0.5\n green_func_array_for_lsq_inv = (1. - frac_medium_2)*green_func_array[:,:,:,0] + frac_medium_2*green_func_array[:,:,:,1]\n \n # Perform the inversion:\n M = perform_inversion(real_data_array, green_func_array_for_lsq_inv)\n M_amplitude = ((np.sum(M**2))**0.5)\n\n # And get forward model synthetic waveform result:\n synth_forward_model_result_array = forward_model(green_func_array_for_lsq_inv, M)\n\n # And plot the results:\n if plot_switch:\n plot_specific_forward_model_result(real_data_array, synth_forward_model_result_array, data_labels, plot_title=\"Initial theoretical inversion solution\", perform_normallised_waveform_inversion=perform_normallised_waveform_inversion)\n\n # And save least squares output:\n # Set output arrays to equal least squares output: \n MTs = M\n similarity_curr_sample, shift_idxs = compare_synth_to_real_waveforms(real_data_array, synth_forward_model_result_array, comparison_metric, perform_normallised_waveform_inversion, compare_all_waveforms_simultaneously, auto_shift_for_best_fit) \n MTp = np.array([similarity_curr_sample])\n # And save data to MTFIT style file:\n outdir_least_squares = outdir+\"/least_squares_result\"\n os.system(\"mkdir -p \"+outdir_least_squares)\n save_to_MTFIT_style_file(MTs, MTp, nlloc_hyp_filename, inversion_type, outdir_least_squares, shift_idxs=shift_idxs) # Saves pickled dictionary containing data from inversion\n # And save most likely solution and real data waveforms to file:\n if inversion_type == \"DC_single_force_couple\" or inversion_type == \"DC_single_force_no_coupling\" or inversion_type == \"DC_crack_couple\" or inversion_type == \"single_force_crack_no_coupling\":\n synth_forward_model_most_likely_result_array = forward_model(green_func_array, MTs[:-1, np.where(MTp==np.max(MTp))[0][0]])\n else:\n synth_forward_model_most_likely_result_array = forward_model(green_func_array, MTs[:, np.where(MTp==np.max(MTp))[0][0]])\n # And get shift associated with most likely model:\n if len(shift_idxs) > 0:\n shift_idxs_most_likely_result = np.array(shift_idxs)\n else:\n shift_idxs_most_likely_result = []\n # And save:\n save_specific_waveforms_to_file(real_data_array, synth_forward_model_most_likely_result_array, data_labels, nlloc_hyp_filename, inversion_type, outdir_least_squares, shift_idxs=shift_idxs_most_likely_result, normallise_data=perform_normallised_waveform_inversion)\n\n # And do Monte Carlo random sampling to obtain PDF of moment tensor:\n MTs, MTp, MTp_absolute, shift_idxs_all_samples = perform_monte_carlo_sampled_waveform_inversion(real_data_array, green_func_array, num_samples, M_amplitude=M_amplitude,inversion_type=inversion_type, comparison_metric=comparison_metric, perform_normallised_waveform_inversion=perform_normallised_waveform_inversion, compare_all_waveforms_simultaneously=compare_all_waveforms_simultaneously, num_processors=num_processors, return_absolute_similarity_values_switch=return_absolute_similarity_values_switch, invert_for_ratio_of_multiple_media_greens_func_switch=invert_for_ratio_of_multiple_media_greens_func_switch, green_func_phase_labels=green_func_phase_labels, num_phase_types_for_media_ratios=num_phase_types_for_media_ratios, invert_for_relative_magnitudes_switch=invert_for_relative_magnitudes_switch, rel_exp_mag_range=rel_exp_mag_range, auto_shift_for_best_fit=auto_shift_for_best_fit)\n\n # Check that probability of output is non-zero:\n if math.isnan(MTp[0]):\n print(\"Error: Sum of probabilities is equal to zero - therefore no adiquate solution could be found and inversion is terminating.\")\n sys.exit()\n \n # Remove zero probability values if specified:\n if only_save_non_zero_solns_switch:\n MTp, MTs = remove_zero_prob_results(MTp, MTs)\n\n # And plot most likely solution:\n if plot_switch:\n if inversion_type == \"DC_single_force_couple\" or inversion_type == \"DC_single_force_no_coupling\" or inversion_type == \"DC_crack_couple\" or inversion_type == \"single_force_crack_no_coupling\":\n if invert_for_ratio_of_multiple_media_greens_func_switch:\n if num_phase_types_for_media_ratios>0:\n # Generate different phase fractions:\n tmp_frac_medium_1_diff_phases_dict={}\n tmp_frac_medium_1_diff_phases_dict[\"P\"] = MTs[-3, np.where(MTp==np.max(MTp))[0][0]]\n tmp_frac_medium_1_diff_phases_dict[\"S\"] = MTs[-2, np.where(MTp==np.max(MTp))[0][0]]\n tmp_frac_medium_1_diff_phases_dict[\"surface\"] = MTs[-1, np.where(MTp==np.max(MTp))[0][0]]\n # Create actual greens functions for this solution:\n green_func_array_for_most_likely_amp_ratio = np.zeros(np.shape(green_func_array[:,:,:,0]), dtype=float)\n for j in range(len(green_func_phase_labels)):\n tmp_frac_medium_1 = tmp_frac_medium_1_diff_phases_dict[green_func_phase_labels[j]] # Get fraction for specific phase, for specific greens functions for specific station-phase\n green_func_array_for_most_likely_amp_ratio[j, :, :] = (1. - tmp_frac_medium_1)*green_func_array[j,:,:,0] + tmp_frac_medium_1*green_func_array[j,:,:,1]\n # And get result:\n synth_forward_model_most_likely_result_array = forward_model(green_func_array_for_most_likely_amp_ratio, MTs[:-4, np.where(MTp==np.max(MTp))[0][0]])\n else:\n frac_medium_1 = MTs[-1, np.where(MTp==np.max(MTp))[0][0]]\n green_func_array_for_most_likely_amp_ratio = (1. - frac_medium_1)*green_func_array[:,:,:,0] + frac_medium_1*green_func_array[:,:,:,1]\n synth_forward_model_most_likely_result_array = forward_model(green_func_array_for_most_likely_amp_ratio, MTs[:-2, np.where(MTp==np.max(MTp))[0][0]])\n else:\n synth_forward_model_most_likely_result_array = forward_model(green_func_array, MTs[:-1, np.where(MTp==np.max(MTp))[0][0]])\n else:\n if invert_for_ratio_of_multiple_media_greens_func_switch:\n if num_phase_types_for_media_ratios>0:\n # Generate different phase fractions:\n tmp_frac_medium_1_diff_phases_dict={}\n tmp_frac_medium_1_diff_phases_dict[\"P\"] = MTs[-3, np.where(MTp==np.max(MTp))[0][0]]\n tmp_frac_medium_1_diff_phases_dict[\"S\"] = MTs[-2, np.where(MTp==np.max(MTp))[0][0]]\n tmp_frac_medium_1_diff_phases_dict[\"surface\"] = MTs[-1, np.where(MTp==np.max(MTp))[0][0]]\n # Create actual greens functions for this solution:\n green_func_array_for_most_likely_amp_ratio = np.zeros(np.shape(green_func_array[:,:,:,0]), dtype=float)\n for j in range(len(green_func_phase_labels)):\n tmp_frac_medium_1 = tmp_frac_medium_1_diff_phases_dict[green_func_phase_labels[j]] # Get fraction for specific phase, for specific greens functions for specific station-phase\n green_func_array_for_most_likely_amp_ratio[j, :, :] = (1. - tmp_frac_medium_1)*green_func_array[j,:,:,0] + tmp_frac_medium_1*green_func_array[j,:,:,1]\n # And get result:\n synth_forward_model_most_likely_result_array = forward_model(green_func_array_for_most_likely_amp_ratio, MTs[:-3, np.where(MTp==np.max(MTp))[0][0]])\n else:\n frac_medium_1 = MTs[-1, np.where(MTp==np.max(MTp))[0][0]]\n green_func_array_for_most_likely_amp_ratio = (1. - frac_medium_1)*green_func_array[:,:,:,0] + frac_medium_1*green_func_array[:,:,:,1]\n synth_forward_model_most_likely_result_array = forward_model(green_func_array_for_most_likely_amp_ratio, MTs[:-1, np.where(MTp==np.max(MTp))[0][0]])\n else:\n synth_forward_model_most_likely_result_array = forward_model(green_func_array, MTs[:, np.where(MTp==np.max(MTp))[0][0]])\n plot_specific_forward_model_result(real_data_array, synth_forward_model_most_likely_result_array, data_labels, plot_title=\"Most likely Monte Carlo sampled solution\", perform_normallised_waveform_inversion=perform_normallised_waveform_inversion)\n print(\"Most likely solution:\", MTs[:,np.where(MTp==np.max(MTp))[0][0]])\n\n # And save data to MTFIT style file:\n save_to_MTFIT_style_file(MTs, MTp, nlloc_hyp_filename, inversion_type, outdir, MTp_absolute=MTp_absolute, shift_idxs=shift_idxs_all_samples) # Saves pickled dictionary containing data from inversion\n # And save most likely solution and real data waveforms to file:\n synth_forward_model_most_likely_result_array = get_synth_forward_model_most_likely_result(MTs, MTp, green_func_array, inversion_type, invert_for_ratio_of_multiple_media_greens_func_switch=invert_for_ratio_of_multiple_media_greens_func_switch, green_func_phase_labels=green_func_phase_labels, num_phase_types_for_media_ratios=num_phase_types_for_media_ratios)\n # And get shift associated with most likely model:\n if len(shift_idxs_all_samples) > 0:\n shift_idxs_most_likely_result = np.array(shift_idxs_all_samples)[0, np.where(MTp==np.max(MTp))[0][0]]\n else:\n shift_idxs_most_likely_result = []\n # And save:\n save_specific_waveforms_to_file(real_data_array, synth_forward_model_most_likely_result_array, data_labels, nlloc_hyp_filename, inversion_type, outdir, shift_idxs=shift_idxs_most_likely_result, normallise_data=perform_normallised_waveform_inversion)\n \n print(\"Finished\")","def spectral_check(self, ):\r\n a, b = self.dfa, self.dfm.copy()\r\n b['ts_a']=a.ts\r\n b['flux_a'] = a.flux\r\n b['dflux'] = (b.flux-b.flux_a)/b.flux_unc\r\n b['eflux100_a'] = a.eflux100\r\n b['deflux'] = (b.eflux100-b.eflux100_a)/b.eflux100_unc\r\n b['pindex_a'] = a.pindex\r\n b['gdelta'] = (b.pindex-b.pindex_a)/b.pindex_unc\r\n self.dfm = b # since copy\r\n\r\n fig,axx = plt.subplots(1,2, figsize=(10,5), sharey=True)\r\n hkw = dict(bins=np.linspace(-5,5,51), histtype='step', lw=2, density=True)\r\n\r\n cut = (b.ts>50) & ~pd.isnull(b.deflux) & ~pd.isnull(b.gdelta) &\\\r\n (b.modelname==\"LogParabola\") & (b.pindex<3) & (b.pindex>0.5) &\\\r\n (b.e0>500) &(b.eflux100_unc>0) &(b.pindex_unc>0)\r\n self.check_total = sum(cut)\r\n for ax, title, val in zip(axx.flatten(), ['Energy Flux', 'Spectral index'], [b.deflux, b.gdelta]): \r\n\r\n df=val[cut]\r\n ax.hist(df.clip(-5,5), label='mean {:5.2f}\\nstd {:5.2f}'.format(df.mean(),df.std()), **hkw);\r\n ax.grid(alpha=0.5); \r\n x=np.linspace(-4,4)\r\n ax.plot(x, stats.norm.pdf(x), '--g' );\r\n ax.set(xlabel='normalized fit deviation', title=title, )\r\n ax.legend(loc='upper left',prop=dict(family='monospace'))\r\n fig.suptitle('Normalized devations of fit from model', fontsize=16);\r\n\r\n return fig","def compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs(self):\n ref_base_dir = (\"/Users/thomasriddick/Documents/data/lake_analysis_runs\"\n \"/lake_analysis_one_21_Jun_2021\")\n data_base_dir = (\"/Users/thomasriddick/Documents/data/lake_analysis_runs/\"\n \"lake_analysis_two_26_Mar_2022\")\n ref_filename=os.path.join(ref_base_dir,\n \"rivers/results/diag_version_29_date_0\",\n \"30min_flowtocell.nc\")\n data_filename=os.path.join(data_base_dir,\n \"rivers/results/diag_version_0_date_0\",\n \"30min_flowtocell.nc\")\n lsmask_filename=os.path.join(self.plots_data_dir,\n \"ls_mask_extract_ls_mask_from_corrected_HD_rdirs_20160504_142435.nc\")\n ref_catchment_filename=os.path.join(ref_base_dir,\n \"rivers/results/diag_version_29_date_0\",\n \"30min_catchments.nc\")\n data_catchment_filename=os.path.join(data_base_dir,\n \"rivers/results/diag_version_0_date_0\",\n \"30min_catchments.nc\")\n ref_rdirs_filename=os.path.join(ref_base_dir,\n \"rivers/results/diag_version_29_date_0\",\n \"30min_rdirs.nc\")\n reference_rmouth_outflows_filename=os.path.join(ref_base_dir,\n \"rivers/results/diag_version_29_date_0\",\n \"30min_flowtorivermouths.nc\")\n data_rmouth_outflows_filename=os.path.join(data_base_dir,\n \"rivers/results/diag_version_0_date_0\",\n \"30min_flowtorivermouths.nc\")\n #glacier_mask_filename=os.path.join(self.orog_data_directory,\"ice5g_v1_2_21_0k_10min.nc\")\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\n data_flowmap_filename=data_filename,\n ref_catchment_filename=\\\n ref_catchment_filename,\n data_catchment_filename=\\\n data_catchment_filename,\n ref_rdirs_filename=\\\n ref_rdirs_filename,\n data_rdirs_filename=None,\n reference_rmouth_outflows_filename=\\\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename=\\\n data_rmouth_outflows_filename,\n lsmask_filename=lsmask_filename,\n minflowcutoff=80,\n flip_data=False,\n rotate_data=False,\n flip_ref=False,\n rotate_ref=False,\n lsmask_has_same_orientation_as_ref=False,\n flip_lsmask=False,rotate_lsmask=False,\n invert_ls_mask=False,\n first_datasource_name=\"old\",\n second_datasource_name=\"MERIT derived\",\n matching_parameter_set='extensive',\n catchment_and_outflows_mods_list_filename=\\\n None,\n #\"catch_and_outflow_mods_ice6g_vs_ice5g_lgm.txt\",\n #additional_matches_list_filename=\\\n #\"additional_matches_ice6g_vs_ice5g_lgm.txt\",\n use_single_color_for_discrepancies=True,\n use_only_one_color_for_flowmap=False,\n use_title=False,remove_antartica=True,\n difference_in_catchment_label=\"Difference\",\n grid_type='HD')","def test_lrp_svm(self, syn_genomic_data, syn_fm, syn_idx, rep, tmp_path, syn_true_pvalues): \n rep_to_plot = 0\n ttbrs = [0.5, 1,1.5]\n idx = syn_idx[str(rep_to_plot)]\n fig, axes = plt.subplots(len(ttbrs), 5, figsize=[30,15])\n x_3d = syn_fm(\"3d\")[str(rep_to_plot)][:]\n x_2d = syn_fm(\"2d\")[str(rep_to_plot)][:]\n indices_true= [inds_true for inds_true, x in enumerate(syn_true_pvalues[0].flatten()) if x]\n\n for i, ttbr in enumerate(ttbrs):\n print('Using tbrr={}'.format(ttbr))\n labels = generate_syn_phenotypes(tower_to_base_ratio=ttbr, quantity=rep)\n labels_cat = {}\n for key, l in labels.items():\n labels_cat[key] = tensorflow.keras.utils.to_categorical((l+1)/2)\n \n best_params_montaez['n_snps']= x_3d.shape[1]\n \n l_0b=labels_cat[str(rep_to_plot)]\n\n model = create_montaez_dense_model(best_params_montaez)\n y_integers = np.argmax(l_0b[idx.train], axis=1)\n class_weights = class_weight.compute_class_weight('balanced', np.unique(y_integers), y_integers)\n d_class_weights = dict(enumerate(class_weights))\n\n model.fit(x=x_3d[idx.train], y=l_0b[idx.train], validation_data=(x_3d[idx.test], l_0b[idx.test]), epochs=best_params_montaez['epochs'], class_weight=d_class_weights, callbacks=[ ReduceLROnPlateau(monitor='val_loss', factor=best_params_montaez['factor'], patience=best_params_montaez['patience'], mode='min'),],)\n\n model = iutils.keras.graph.model_wo_softmax(model)\n analyzer = innvestigate.analyzer.LRPAlpha1Beta0(model)\n weights = analyzer.analyze(x_3d).sum(0)\n\n top_indices_sorted, filtered_weights = postprocess_weights(weights, top_k, filter_window_size, p_svm, p_pnorm_filter)\n\n complete_pvalues = chi_square(syn_genomic_data[str(rep_to_plot)][:], labels[str(rep_to_plot)])\n \n pvalues_filled_deep = np.ones(n_total_snps)\n pvalues_filled_deep[top_indices_sorted] = complete_pvalues[top_indices_sorted]\n\n # Plot RPVT\n plot_pvalues(complete_pvalues, indices_true, axes[i][0])\n if i==0:\n axes[i][0].set_title('RPVT $-log_{10}$(p-values)', fontsize=22)\n axes[i][0].set_ylabel('$-log_{10}$(p-value)', fontsize=18)\n plt.setp(axes[i][0].get_yticklabels(), fontsize=16)\n plt.setp(axes[i][0].get_xticklabels(), fontsize=16)\n\n # Plot svm weights \n clf = LinearSVC(penalty='l2', loss='hinge', C=0.0022, dual=True, tol=1e-3, verbose=0, class_weight='balanced')\n idx_now, pvalues, raw_weights = combi_method(clf, syn_genomic_data[str(rep_to_plot)][:],x_2d, labels[str(rep_to_plot)], 35, 2, 2, 30)\n #filtered_svm_weights = postprocess_weights_without_avg(raw_weights, p_svm)\n pvalues_filled_combi = np.ones(len(complete_pvalues))\n pvalues_filled_combi[idx_now] = pvalues\n #svm_weights = toy_classifier.fit(x_2d, labels[str(rep_to_plot)]).coef_\n axes[i][1].scatter(range(len(np.absolute(raw_weights).sum(1))), 1000*np.absolute(raw_weights).sum(1), marker='.', color='darkblue')\n axes[i][1].scatter(indices_true,1000*np.absolute(raw_weights).sum(1)[indices_true], color='fuchsia')\n axes[i][1].set_ylim(0,1000*(np.max(np.absolute(raw_weights).sum(1))+0.001))\n if i==0:\n axes[i][1].set_title('Absolute SVM weights * 1000', fontsize=22)\n plt.setp(axes[i][1].get_yticklabels(), fontsize=16)\n plt.setp(axes[i][1].get_xticklabels(), fontsize=16)\n\t\t\t\n # Plot COMBI\n plot_pvalues(pvalues_filled_combi, indices_true, axes[i][2])\n if i==0:\n axes[i][2].set_title('COMBI $-log_{10}$(p-values)', fontsize=22)\n if i==2:\n axes[i][2].set_xlabel('SNP position', fontsize=18)\n plt.setp(axes[i][2].get_yticklabels(), fontsize=16)\n plt.setp(axes[i][2].get_xticklabels(), fontsize=16)\n\t\t\t\n # Plot LRP relevance scores\n axes[i][3].scatter(range(len(np.absolute(weights).reshape(-1, 3).sum(1))), np.absolute(weights).reshape(-1, 3).sum(1), marker='.', color='darkblue')\n axes[i][3].scatter(indices_true,np.absolute(weights).reshape(-1, 3).sum(1)[indices_true], color='fuchsia')\n #axes[i][1].legend()\n axes[i][3].set_ylim(0,np.max(np.absolute(weights).reshape(-1, 3).sum(1))+1)\n if i==0:\n axes[i][3].set_title('LRP relevance scores', fontsize=22)\n plt.setp(axes[i][3].get_yticklabels(), fontsize=16)\n plt.setp(axes[i][3].get_xticklabels(), fontsize=16)\n\t\t\t\n # Plot DeepCOMBI\n plot_pvalues(pvalues_filled_deep, indices_true, axes[i][4])\n if i==0:\n axes[i][4].set_title('DeepCOMBI $-log_{10}$(p-value)', fontsize=22)\n plt.setp(axes[i][4].get_yticklabels(), fontsize=16)\n plt.setp(axes[i][4].get_xticklabels(), fontsize=16)\n\t\t\t\n ## Plot distribution of postprocessed vectors\n #axes[i][2].plot(postprocessed_weights)\n #axes[i][2].set_title('Postprocessed relevance')\n\n fig.savefig(os.path.join(IMG_DIR, 'manhattan-example-toy-NAR.png'), bbox_inches='tight')","def nominalSensitivities():\n #Scan ranges\n ang = np.linspace(-5*.3e-3,5*.3e-3,100)\n tx = np.linspace(-.3,.3,100)\n\n #Mirror Pair Sensitivities\n pitch2 = [mirrorPair(1000,primalign=[0,0,0,0,a,0]) for a in ang]\n yaw2 = [mirrorPair(1000,primalign=[0,0,0,a,0,0]) for a in ang]\n plt.figure('Pair')\n plt.plot(ang*180/pi*60,pitch2,label='Pitch')\n plt.plot(ang*180/pi*60,yaw2,label='Yaw')\n plt.title('SLF Mirror Pair Alignment Sensitivities')\n plt.grid()\n plt.legend(loc='upper center')\n plt.xlabel('Angular Error (arcmin)')\n plt.ylabel('HPD (arcsec)')\n\n #Secondary Sensitivities\n pitch = [mirrorPair(1000,secalign=[0,0,0,0,a,0]) for a in ang/20]\n yaw = [mirrorPair(1000,secalign=[0,0,0,a,0,0]) for a in ang/20]\n roll = [mirrorPair(1000,secalign=[0,0,0,0,0,a]) for a in ang/20]\n plt.figure('SecondaryAng')\n plt.semilogy(ang/20.*180/pi*60**2,pitch,label='Pitch')\n plt.plot(ang/20.*180/pi*60**2,yaw,label='Yaw')\n plt.plot(ang/20.*180/pi*60**2,roll,label='Roll')\n plt.grid()\n plt.legend(loc='upper center')\n plt.xlabel('Angular Error (arcsec)')\n plt.ylabel('HPD (arcsec)')\n plt.xlim([-5,5])\n plt.ylim([0,3])\n plt.title('SLF Secondary Alignment Sensitivities')\n decenter = [mirrorPair(1000,secalign=[t,0,0,0,0,0]) for t in tx]\n lateral = [mirrorPair(1000,secalign=[0,t,0,0,0,0]) for t in tx]\n despace = [mirrorPair(1000,secalign=[0,0,t,0,0,0]) for t in tx]\n plt.figure('SecondaryTx')\n plt.semilogy(tx,decenter,label='Decenter')\n plt.plot(tx,despace,label='Despace')\n plt.plot(tx,lateral,label='Lateral')\n plt.grid()\n plt.legend(loc='upper center')\n plt.xlabel('Translation Error (mm)')\n plt.ylabel('HPD (arcsec)')\n plt.title('SLF Secondary Translation Sensitivities')\n \n \n #Compensating behavior...\n \n\n return [pitch2,yaw2,pitch,yaw,decenter,lateral,despace]","def compare_ICE5G_and_ICE6G_with_catchments_tarasov_style_orog_corrs_for_both(self):\n ice5g_datetime = \"20170615_174943\"\n ice6g_datetime = \"20170612_202559\"\n ref_filename=os.path.join(self.plots_data_dir,\n \"flowmap_ICE5G_21k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_tarasov\"\n \"_orog_corrs_generation_and_upscaling_{0}_upscaled_updated.nc\".\\\n format(ice5g_datetime))\n data_filename=os.path.join(self.plots_data_dir,\n \"flowmap_ICE6g_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_\"\n \"tarasov_orog_corrs_{0}_upscaled_updated.nc\".\\\n format(ice6g_datetime))\n lsmask_filename=os.path.join(self.plots_data_dir,\n \"ls_mask_ICE6g_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs\"\n \"_tarasov_orog_corrs_{0}_HD_transf.nc\".\\\n format(ice6g_datetime))\n ref_catchment_filename=(\"catchmentmap_ICE5G_21k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_\"\n \"tarasov_orog_corrs_generation_and_upscaling_{0}_upscaled_updated.nc\".\\\n format(ice5g_datetime))\n data_catchment_filename=(\"catchmentmap_ICE6g_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs\"\n \"_tarasov_orog_corrs_{0}_upscaled_updated.nc\".\\\n format(ice6g_datetime))\n ref_rdirs_filename=(\"upscaled_rdirs_ICE5G_21k_ALG4_sinkless_no_true_sinks_oceans_lsmask_\"\n \"plus_upscale_rdirs_tarasov_orog_corrs_generation_and_upscaling_{0}_upscaled_\"\n \"updated.nc\".format(ice5g_datetime))\n reference_rmouth_outflows_filename=os.path.join(self.plots_data_dir,\n \"rmouthflows_ICE5G_21k_ALG4_sinkless_no_true_sinks_oceans_\"\n \"lsmask_plus_upscale_rdirs_tarasov_orog_corrs\"\n \"_generation_and_upscaling_{0}_upscaled_updated.nc\".\\\n format(ice5g_datetime))\n data_rmouth_outflows_filename=os.path.join(self.plots_data_dir,\n \"rmouthflows_ICE6g_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask_\"\n \"plus_upscale_rdirs_tarasov_orog_corrs_{0}_upscaled_updated.nc\".\\\n format(ice6g_datetime))\n #glacier_mask_filename=os.path.join(self.orog_data_directory,\"ice5g_v1_2_21_0k_10min.nc\")\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\n data_flowmap_filename=data_filename,\n ref_catchment_filename=\\\n ref_catchment_filename,\n data_catchment_filename=\\\n data_catchment_filename,\n ref_rdirs_filename=\\\n ref_rdirs_filename,\n data_rdirs_filename=None,\n reference_rmouth_outflows_filename=\\\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename=\\\n data_rmouth_outflows_filename,\n lsmask_filename=lsmask_filename,\n minflowcutoff=100,\n flip_data=False,\n rotate_data=True,\n flip_ref=False,\n rotate_ref=True,\n lsmask_has_same_orientation_as_ref=False,\n flip_lsmask=False,rotate_lsmask=False,\n invert_ls_mask=True,\n first_datasource_name=\"ICE5G\",\n second_datasource_name=\"ICE6G\",\n matching_parameter_set='extensive',\n catchment_and_outflows_mods_list_filename=\\\n \"catch_and_outflow_mods_ice6g_vs_ice5g_lgm.txt\",\n #additional_matches_list_filename=\\\n #\"additional_matches_ice6g_vs_ice5g_lgm.txt\",\n use_single_color_for_discrepancies=True,\n use_only_one_color_for_flowmap=False,\n use_title=False,remove_antartica=True,\n difference_in_catchment_label=\"Difference\",\n rivers_to_plot=[(216,434),(116,426),(111,385),\n (127,473),(71,641),(123,175),\n (147,327),(146,554),(194,590),\n (25,605),(26,691),(69,31),\n (178,267),(88,455),(67,369),\n (253,637),(204,609),(270,238),\n (39,315),(42,252),\n (16,444),(56,232)],\n rivers_to_plot_alt_color=[(193,383),(237,392),(170,369),\n (118,398),(24,591),(114,612),\n (126,167),(87,111),(88,246),\n (160,240),(249,255),(91,421),\n (197,626),(217,598),(135,496),\n (31,112),(14,263),(54,2)],\n rivers_to_plot_secondary_alt_color=[(230,428),(171,377),\n (154,446),(100,467),\n (142,327),(180,445),\n (170,578),(117,131),\n (24,622),(34,8),\n (75,99),(201,287),\n (90,433),(250,632),\n (82,349),(138,536),\n (29,392),(32,200),\n (35,104),(261,246),\n (14,320)],\n grid_type='HD')","def main(folder, quiet=0):\n\n if quiet:\n output_stream = StringIO()\n else:\n output_stream = sys.stdout\n\n\n\n color1 = \"I4\" #filter system for first color of CMD\n color2 = \"M1\" #filter system for second color of CMD\n zeromagc1 = zero.zero_mag[color1]\n zeromagc2 = zero.zero_mag[color2]\n min_mag = 8. #minimal observation limit\n max_mag = 0. #maximal observation limit\n\n#getting file list\n files = sorted(os.listdir('%s/%s' % (os.getcwdu(), folder))) \n out = []\n\n for fil in files:\n#only using files created by the automated simulation\n if fil.startswith('sim_') and not 'settings' in fil.encode(\"ascii\"):\n print(\"%s/%s\" % (folder,fil.encode(\"ascii\")), file=output_stream)\n \n\n # Read in\n hdulist = fits.open('%s/%s' %(folder,fil))\n data = hdulist[1].data\n\n #calculating magnitudes from fluxes and converting to CMD-data\n x = -2.5*(np.log10(data['c%s' % color1]/zeromagc1) - np.log10(data['c%s' % color2]/zeromagc2))\n y = -2.5*(np.log10(data['c%s' % color2]/zeromagc2))\n\n \n sel = np.logical_and( (y > -10./3. * (x-1.) + 10.), np.logical_and(max_mag < y, y < min_mag))\n sel = np.logical_and(sel, y < -x + 12.)\n n = sum(sel)\n t = Table(hdulist[1].data)\n if 'sel' in t.columns:\n t.remove_column('sel')\n t.add_column(Column(name='sel', data=sel.astype('int')))\n \n hdulist[1].data = np.array(t)\n tmp, av, apera, age = fil.split('_')\n fits.update('%s/%s' %(folder,fil), np.array(t), ext = 1, clobber=True)\n out.append([av, apera, age, n])\n\n #writing obtained data to \"folder/__expected_number\"\n head = ['#', 'AV', 'Aperature_size', 'Age', 'Expected_number']\n f = open('%s/__expected_number' % folder, 'w')\n f.write(','.join(head)+'\\n' )\n np.savetxt(f, np.asarray(out).astype(int))\n f.close()\n \n print (\"Analysed %s files and saved output to %s\" % (len(out),'%s/__expected_number' % folder), file=output_stream)","def HD_input_sncosmo_data(self, sn_list):\n\n dico = cPickle.load(open(SUGAR_parameter_pkl))\n self.read_sncosmo(path='../sugar_analysis_data/results/res_salt2_SNF_5_nomodelcov.txt')\n self.read_meta()\n self.read_snfit_results()\n Filtre = np.array([True]*len(self.sncosmo_sn_name))\n self.zcmb = []\n self.z_err = []\n for j, sn_name in enumerate(self.sncosmo_sn_name):\n# if self.sncosmo_sn_name[j] in dico.keys():\n#\n# for i in range (len(self.meta_sn_name_list)):\n# if self.sncosmo_sn_name[j] == self.meta_sn_name_list[i]:\n# \n# self.z_err.append(self.meta_zhl_err[i])\n# self.zcmb.append(self.meta_zcmb[i])\n# if np.abs(self.sncosmo_x1[j] - self.x1[i]) > 0.01:\n# i print 'problem with %s include in sample but big difference between sncosmo and snfit'%(self.sncosmo_sn_name[j])\n# else:\n# Filtre[j] = False\n if sn_name in sn_list:\n Filtre[j] = True\n else:\n Filtre[j] = False\n\n for p in dico.keys():\n if p not in self.sncosmo_sn_name:\n print p\n\n self.sncosmo_x1 = self.sncosmo_x1[Filtre]\n self.sncosmo_x1_err = self.sncosmo_x1_err[Filtre] \n self.sncosmo_c = self.sncosmo_c[Filtre]\n self.sncosmo_c_err = self.sncosmo_c_err[Filtre]\n self.sncosmo_mb = self.sncosmo_mb[Filtre]\n self.sncosmo_mb_err = self.sncosmo_mb_err[Filtre]\n self.sncosmo_cov_x1_c = self.sncosmo_cov_x1_c[Filtre]\n self.sncosmo_cov_mb_x1 = self.sncosmo_cov_mb_x1[Filtre]\n self.sncosmo_cov_mb_c = self.sncosmo_cov_mb_c[Filtre]\n self.sncosmo_z = self.sncosmo_z[Filtre]\n self.zcmb = np.array(self.zcmb)\n self.z_err = np.array(self.z_err)\n\n self.sncosmo_cov_y = np.zeros((len(self.sncosmo_mb)*3,len(self.sncosmo_mb)*3))\n \n for i in range (len(self.sncosmo_mb)):\n self.sncosmo_cov_y[i*3,i*3] = self.sncosmo_mb_err[i]**2\n self.sncosmo_cov_y[i*3+ 1,i*3+ 1] = self.sncosmo_x1_err[i]**2\n \n self.sncosmo_cov_y[i*3+ 2,i*3+ 2] = self.sncosmo_c_err[i]**2\n self.sncosmo_cov_y[i*3+ 0,i*3+ 1] = self.sncosmo_cov_mb_x1[i]\n self.sncosmo_cov_y[i*3+ 1,i*3+ 0] = self.sncosmo_cov_mb_x1[i]\n self.sncosmo_cov_y[i*3+ 0,i*3+ 2] = self.sncosmo_cov_mb_c[i]\n self.sncosmo_cov_y[i*3+ 2,i*3+ 0] = self.sncosmo_cov_mb_c[i]\n self.sncosmo_cov_y[i*3+ 1,i*3+ 2] = self.sncosmo_cov_x1_c[i] \n self.sncosmo_cov_y[i*3+ 2,i*3+ 1] = self.sncosmo_cov_x1_c[i] \n \n self.salt_parm = np.array([self.sncosmo_mb,self.sncosmo_x1,self.sncosmo_c]).T\n print len(self.salt_parm), len(self.sncosmo_cov_y), len(self.sncosmo_z), len(self.zcmb)\n return self.salt_parm, self.sncosmo_cov_y, self.sncosmo_z, self.zcmb, self.z_err","def visitcomp(plate,mjd,indiv=False,apred='test') :\n #plt.close('all')\n load=apload.ApLoad(apred=apred)\n a=load.apVisitSum(plate,mjd)[1].data\n\n #dr14=apload.ApLoad(dr='dr14')\n p=yanny.yanny(os.environ['PLATELIST_DIR']+'/platePlans.par',np=True)\n j=np.where(p['PLATEPLANS']['plateid'] == plate)[0][0]\n locid=p['PLATEPLANS']['locationid'][j]\n b=fits.open(os.environ['APOGEE_REDUX']+'/r8/fields/apo25m/{:04d}/apVisitSum-{:04d}-{:05d}.fits'.format(\n locid,plate,mjd))[1].data\n\n fig,ax=plots.multi(2,2)\n i1,i2=match.match(a['FIBERID'],b['FIBERID'])\n plots.plotc(ax[0,0],a['FIBERID'][i1],a['VHELIO'][i1]-b['VHELIO'][i2],a['RV_TEFF'][i1],zr=[3500,5500],xt='Fiber',yt=r'$\\Delta$ VHELIO')\n plots.plotc(ax[0,1],a['FIBERID'][i1],a['VHELIO'][i1]-b['VHELIO'][i2],a['RV_TEFF'][i1],zr=[3500,5500],yr=[-2.,2.],xt='Fiber',yt=r'$\\Delta$ VHELIO')\n plots.plotc(ax[1,0],a['FIBERID'][i1],a['RV_TEFF'][i1]-b['RV_TEFF'][i2],a['RV_TEFF'][i1],zr=[3500,5500],xt='Fiber',yt=r'$\\Delta$ RV_TEFF')\n plots.plotc(ax[1,1],a['RV_TEFF'][i1]-b['RV_TEFF'][i2],a['VHELIO'][i1]-b['VHELIO'][i2],a['RV_TEFF'][i1],zr=[3500,5500],xt=r'$\\Delta$ RV_TEFF',yt=r'$\\Delta$ VHELIO')\n out=load.filename('Plate',chips=True,plate=plate,mjd=mjd)\n outdir=os.path.dirname(out)\n outname=os.path.basename(out).replace('-a','').replace('.fits','_dr14comp.png')\n fig.tight_layout()\n pdb.set_trace()\n print(outdir+'/plots/'+outname)\n fig.savefig(outdir+'/plots/'+outname)\n\n if indiv :\n va=load.apPlate(plate,mjd)\n vb={}\n for chip in chips :\n tmp=fits.open(os.environ['APOGEE_REDUX']+'/r8/apo25m/{:04d}/{:05d}/apPlate-{:s}-{:04d}-{:05d}.fits'.format(\n plate,mjd,chip,plate,mjd))\n vb[chip] = tmp\n\n fig,ax=plots.multi(1,3,hspace=0.3) \n pfig,pax=plots.multi(1,3,hspace=0.3) \n wfig,wax=plots.multi(1,3,hspace=0.3) \n for i in range(len(i1)) :\n fiber = a['FIBERID'][i1[i]]\n if (a['VHELIO'][i1[i]]-b['VHELIO'][i2[i]]) > 0.5 :\n print(fiber,a['VHELIO'][i1[i]],b['VHELIO'][i2[i]],a['RV_TEFF'][i1[i]],b['RV_TEFF'][i2[i]])\n applot.chip(va,ax=ax,row=300-fiber,color='r')\n #applot.chip(va,ax=pax,row=300-fiber,color='r',pixel=True)\n applot.chip(vb,ax=ax,row=300-fiber,color='b')\n #applot.chip(vb,ax=pax,row=300-fiber,color='b',pixel=True)\n for ichip,chip in enumerate(chips) :\n pax[ichip].plot(va[chip][1].data[300-fiber,:]/vb[chip][1].data[300-fiber,:])\n wax[ichip].plot(va[chip][4].data[300-fiber,:]-vb[chip][4].data[300-fiber,:])\n plt.show()\n\n pdb.set_trace()\n for ichip in range(3) :\n ax[ichip].cla()\n pax[ichip].cla()\n wax[ichip].cla()\n plt.close()","def main():\n Nrep = 8 # number of repetition of EM steps\n nm = 3 # number of mixed gaussians.\n ns = 300 # number of samples.\n \n mu, sg, lm, lm_ind, smp, L_true = generate_synthetic_data(nm, ns)\n plt.figure(1, figsize=(5,4))\n plt.clf()\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\n \n mue, sge, lme = generate_initial_state(nm, ns)\n axi = 0 # subplot number\n plt.figure(2, figsize=(12,9))\n plt.clf()\n for rep in range(Nrep):\n # E-step\n r, L_infer = e_step(smp, mue, sge, lme, nm, ns)\n axi += 1 \n ax = plt.subplot(Nrep/2, 6, axi)\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\n ax.set_title('E-step : %d' % (rep + 1))\n ax.set_yticklabels([])\n ax.set_xticklabels([])\n ax.set_ylim((-0.1, 0.3))\n\n # M-step\n mue, sge, lme = m_step(smp, r, nm, ns)\n axi += 1 \n ax = plt.subplot(Nrep/2, 6, axi)\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\n ax.set_title('M-step : %d' % (rep + 1))\n ax.set_yticklabels([])\n ax.set_xticklabels([])\n ax.set_ylim((-0.1, 0.3))\n\n # plot the ground truth for comparison\n axi += 1 \n ax = plt.subplot(Nrep/2, 6, axi)\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\n ax.set_title('grn_truth')\n ax.set_yticklabels([])\n ax.set_xticklabels([])\n ax.set_ylim((-0.1, 0.3))\n\n print('L_infer = %2.6f , L_true = %2.6f' % (L_infer, L_true))","def compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_new_ts_10min(self):\n ref_base_dir = (\"/Users/thomasriddick/Documents/data/lake_analysis_runs/\"\n \"lake_analysis_one_21_Jun_2021/rivers/results/\"\n \"default_orog_corrs/\"\n \"diag_version_29_date_0_original_truesinks\")\n data_base_dir = (\"/Users/thomasriddick/Documents/data/lake_analysis_runs/\"\n \"lake_analysis_two_26_Mar_2022/\"\n \"rivers/results/diag_version_32_date_0_with_truesinks\")\n ref_filename=os.path.join(ref_base_dir,\"10min_flowtocell.nc\")\n data_filename=os.path.join(data_base_dir,\"10min_flowtocell.nc\")\n #lsmask_filename=os.path.join(self.plots_data_dir,\n # \"ls_mask_extract_ls_mask_from_corrected_HD_rdirs_20160504_142435.nc\")\n lsmask_filename=None\n ref_catchment_filename=os.path.join(ref_base_dir,\n \"10min_catchments_ext.nc\")\n data_catchment_filename=os.path.join(data_base_dir,\n \"10min_catchments_ext.nc\")\n ref_rdirs_filename=os.path.join(ref_base_dir,\n \"10min_rdirs.nc\")\n data_rdirs_filename=os.path.join(data_base_dir,\n \"10min_rdirs.nc\")\n reference_rmouth_outflows_filename=os.path.join(ref_base_dir,\n \"10min_rmouth_flowtocell.nc\")\n data_rmouth_outflows_filename=os.path.join(data_base_dir,\n \"10min_rmouth_flowtocell.nc\")\n #glacier_mask_filename=os.path.join(self.orog_data_directory,\"ice5g_v1_2_21_0k_10min.nc\")\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\n data_flowmap_filename=data_filename,\n ref_catchment_filename=\\\n ref_catchment_filename,\n data_catchment_filename=\\\n data_catchment_filename,\n ref_rdirs_filename=\\\n ref_rdirs_filename,\n data_rdirs_filename=None,\n reference_rmouth_outflows_filename=\\\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename=\\\n data_rmouth_outflows_filename,\n lsmask_filename=lsmask_filename,\n minflowcutoff=80*9/3,\n flip_data=False,\n rotate_data=False,\n flip_ref=False,\n rotate_ref=False,\n lsmask_has_same_orientation_as_ref=False,\n flip_lsmask=False,rotate_lsmask=False,\n invert_ls_mask=False,\n first_datasource_name=\"old\",\n second_datasource_name=\"MERIT derived\",\n matching_parameter_set='minimal',\n additional_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/additional_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day_ext.txt\",\n additional_truesink_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/addmatches_truesinks/\"\n \"additional_truesinks_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day.txt\",\n catchment_and_outflows_mods_list_filename=\\\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\",\n use_single_color_for_discrepancies=True,\n use_only_one_color_for_flowmap=False,\n use_title=False,remove_antartica=False,\n difference_in_catchment_label=\"Difference\",\n grid_type='LatLong10min')\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\n data_flowmap_filename=data_filename,\n ref_catchment_filename=\\\n ref_catchment_filename,\n data_catchment_filename=\\\n data_catchment_filename,\n ref_rdirs_filename=\\\n ref_rdirs_filename,\n data_rdirs_filename=None,\n reference_rmouth_outflows_filename=\\\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename=\\\n data_rmouth_outflows_filename,\n lsmask_filename=lsmask_filename,\n minflowcutoff=20*9/3,\n flip_data=False,\n rotate_data=False,\n flip_ref=False,\n rotate_ref=False,\n lsmask_has_same_orientation_as_ref=False,\n flip_lsmask=False,rotate_lsmask=False,\n invert_ls_mask=False,\n first_datasource_name=\"old\",\n second_datasource_name=\"MERIT derived\",\n matching_parameter_set='minimal',\n additional_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/additional_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day_ext.txt\",\n additional_truesink_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/addmatches_truesinks/\"\n \"additional_truesinks_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day.txt\",\n catchment_and_outflows_mods_list_filename=\\\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\",\n use_single_color_for_discrepancies=True,\n use_only_one_color_for_flowmap=False,\n use_title=False,remove_antartica=False,\n difference_in_catchment_label=\"Difference\",\n grid_type='LatLong10min')\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\n data_flowmap_filename=data_filename,\n ref_catchment_filename=\\\n ref_catchment_filename,\n data_catchment_filename=\\\n data_catchment_filename,\n ref_rdirs_filename=\\\n ref_rdirs_filename,\n data_rdirs_filename=\\\n data_rdirs_filename,\n reference_rmouth_outflows_filename=\\\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename=\\\n data_rmouth_outflows_filename,\n lsmask_filename=lsmask_filename,\n minflowcutoff=20*9/3,\n flip_data=False,\n rotate_data=False,\n flip_ref=False,\n rotate_ref=False,\n lsmask_has_same_orientation_as_ref=False,\n flip_lsmask=False,rotate_lsmask=False,\n invert_ls_mask=False,\n first_datasource_name=\"old\",\n second_datasource_name=\"MERIT derived\",\n matching_parameter_set='minimal',\n additional_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/additional_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day_ext.txt\",\n additional_truesink_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/addmatches_truesinks/\"\n \"additional_truesinks_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day.txt\",\n catchment_and_outflows_mods_list_filename=\\\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\",\n use_single_color_for_discrepancies=True,\n use_only_one_color_for_flowmap=False,\n use_title=False,remove_antartica=False,\n show_true_sinks=True,\n difference_in_catchment_label=\"Difference\",\n grid_type='LatLong10min')\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\n data_flowmap_filename=data_filename,\n ref_catchment_filename=\\\n ref_catchment_filename,\n data_catchment_filename=\\\n data_catchment_filename,\n ref_rdirs_filename=\\\n ref_rdirs_filename,\n data_rdirs_filename=\\\n None,\n reference_rmouth_outflows_filename=\\\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename=\\\n data_rmouth_outflows_filename,\n lsmask_filename=lsmask_filename,\n minflowcutoff=5*9/3,\n flip_data=False,\n rotate_data=False,\n flip_ref=False,\n rotate_ref=False,\n lsmask_has_same_orientation_as_ref=False,\n flip_lsmask=False,rotate_lsmask=False,\n invert_ls_mask=False,\n first_datasource_name=\"old\",\n second_datasource_name=\"MERIT derived\",\n matching_parameter_set='minimal',\n additional_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/additional_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day_ext.txt\",\n additional_truesink_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/addmatches_truesinks/\"\n \"additional_truesinks_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day.txt\",\n catchment_and_outflows_mods_list_filename=\\\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\",\n use_single_color_for_discrepancies=True,\n use_only_one_color_for_flowmap=False,\n use_title=False,remove_antartica=False,\n show_true_sinks=False,\n difference_in_catchment_label=\"Difference\",\n grid_type='LatLong10min')\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\n data_flowmap_filename=data_filename,\n ref_catchment_filename=\\\n ref_catchment_filename,\n data_catchment_filename=\\\n data_catchment_filename,\n ref_rdirs_filename=\\\n ref_rdirs_filename,\n data_rdirs_filename=\\\n data_rdirs_filename,\n reference_rmouth_outflows_filename=\\\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename=\\\n data_rmouth_outflows_filename,\n lsmask_filename=lsmask_filename,\n minflowcutoff=5*9/3,\n flip_data=False,\n rotate_data=False,\n flip_ref=False,\n rotate_ref=False,\n lsmask_has_same_orientation_as_ref=False,\n flip_lsmask=False,rotate_lsmask=False,\n invert_ls_mask=False,\n first_datasource_name=\"old\",\n second_datasource_name=\"MERIT derived\",\n matching_parameter_set='minimal',\n additional_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/additional_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day_ext.txt\",\n additional_truesink_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/addmatches_truesinks/\"\n \"additional_truesinks_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day.txt\",\n catchment_and_outflows_mods_list_filename=\\\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\",\n use_single_color_for_discrepancies=True,\n use_only_one_color_for_flowmap=False,\n use_title=False,remove_antartica=False,\n show_true_sinks=True,\n difference_in_catchment_label=\"Difference\",\n grid_type='LatLong10min')\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\n data_flowmap_filename=data_filename,\n ref_catchment_filename=\\\n ref_catchment_filename,\n data_catchment_filename=\\\n data_catchment_filename,\n ref_rdirs_filename=\\\n ref_rdirs_filename,\n data_rdirs_filename=\\\n data_rdirs_filename,\n reference_rmouth_outflows_filename=\\\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename=\\\n data_rmouth_outflows_filename,\n lsmask_filename=lsmask_filename,\n minflowcutoff=2*9/3,\n flip_data=False,\n rotate_data=False,\n flip_ref=False,\n rotate_ref=False,\n lsmask_has_same_orientation_as_ref=False,\n flip_lsmask=False,rotate_lsmask=False,\n invert_ls_mask=False,\n first_datasource_name=\"old\",\n second_datasource_name=\"MERIT derived\",\n matching_parameter_set='minimal',\n additional_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/additional_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day_ext.txt\",\n additional_truesink_matches_list_filename=\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"addmatches/addmatches_truesinks/\"\n \"additional_truesinks_matches_10min_upscaled_\"\n \"MERIT_rdirs_vs_modern_day.txt\",\n catchment_and_outflows_mods_list_filename=\\\n \"/Users/thomasriddick/Documents/data/HDdata/\"\n \"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\",\n use_single_color_for_discrepancies=True,\n use_only_one_color_for_flowmap=False,\n use_title=False,remove_antartica=False,\n show_true_sinks=True,\n difference_in_catchment_label=\"Difference\",\n grid_type='LatLong10min')","def comparison():\n path = \"Data/data_fronts/\"\n path1 = \"Results/labelled_images1010/fronts/\"\n\n #computes the areas for the first frame in order to normalize the other areas\n pol0 = pd.DataFrame(pd.read_csv(path1 + \"fronts_labelled.m.0.png.txt\",sep =' '))\n #makes an object polygon in order to compute the area\n pol0 = np.array(pol0)\n pol0 = Polygon(pol0)\n\n polsx = pd.DataFrame(pd.read_csv(path + \"Sham_8-2-18_Field 5_1_sx.txt\",sep ='\\t'))\n polsx.columns = [\"y\",\"x\"]\n poldx = pd.DataFrame(pd.read_csv(path + \"Sham_8-2-18_Field 5_1_dx.txt\",sep ='\\t'))\n poldx.columns = [\"y\",\"x\"]\n #makes an object polygon in order to compute the area\n polsx = polsx.append(poldx)\n polsx = np.array(polsx)\n pol1 = Polygon(polsx)\n\n\n areas = []\n areas_hand = []\n #computes the areas for all the frames\n for i in range(42):\n pol = pd.DataFrame(pd.read_csv(path1 + \"fronts_labelled.m.\"+str(i)+\".png.txt\",sep =' '))\n pol = np.array(pol)\n pol = Polygon(pol)\n #normalize the areas with respect to the area of the first frame\n areas.append(pol.area/pol0.area)\n\n polsx = pd.DataFrame(pd.read_csv(path + \"Sham_8-2-18_Field 5_\"+str(i+1)+\"_sx.txt\",sep ='\\t'))\n polsx.columns = [\"y\",\"x\"]\n poldx = pd.DataFrame(pd.read_csv(path + \"Sham_8-2-18_Field 5_\"+str(i+1)+\"_dx.txt\",sep ='\\t'))\n poldx.columns = [\"y\",\"x\"]\n if poldx[\"x\"][0]>100:\n poldx = poldx.reindex(index=poldx.index[::-1])\n if polsx[\"x\"][0]<100:\n polsx = polsx.reindex(index=polsx.index[::-1])\n polsx = polsx.append(poldx)\n polsx = np.array(polsx)\n\n pol2 = Polygon(polsx)\n #normalize the areas with respect to the area of the first frame\n areas_hand.append(pol2.area/pol1.area)\n #returns the two arrays with the normalized areas\n return np.array(areas) , np.array(areas_hand)","def OutFlowComparisonPlotHelpers(self,reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename,\n ref_flowmaps_filename,data_flowmaps_filename,\n rdirs_filename,flip_data_field=False,rotate_data_field=False,\n flip_ref_field=False,rotate_ref_field=False,\n ref_catchment_filename=None,data_catchment_filename=None,\n data_catchment_original_scale_filename=None,\n data_rdirs_filename=None,\n data_original_scale_flow_map_filename=None,\n ref_orog_filename=None,\n data_orog_original_scale_filename=None,\n flip_orog_original_scale_relative_to_data=False,\n super_fine_orog_filename=None,\n super_fine_data_flowmap_filename=None,\n flip_super_fine_orog=False,\n rotate_super_fine_orog=False,\n additional_matches_list_filename=None,\n catchment_and_outflows_mods_list_filename=None,\n plot_simple_catchment_and_flowmap_plots=False,\n return_simple_catchment_and_flowmap_plotters=False,\n return_catchment_plotters=False,\n swap_ref_and_data_when_finding_labels=False,\n rivers_to_plot=None,\n alternative_catchment_bounds=None,\n matching_parameter_set='default',\n split_comparison_plots_across_multiple_canvases=False,\n use_simplified_catchment_colorscheme=False,\n use_simplified_flowmap_colorscheme=False,\n use_upscaling_labels=False,\n select_only_rivers_in=None,\n allow_new_true_sinks=False,\n ref_original_scale_flow_map_filename=None,\n ref_catchment_original_scale_filename=None,\n use_original_scale_field_for_determining_data_and_ref_labels=False,\n external_ls_mask_filename=None,\n flip_external_ls_mask=False,\n rotate_external_ls_mask=False,\n ref_original_scale_grid_type='HD',\n grid_type='HD',data_original_scale_grid_type='HD',\n super_fine_orog_grid_type='HD',\n no_data_path_prefixes=False,\n data_original_scale_grid_kwargs={},\n ref_original_scale_grid_kwargs={},\n super_fine_orog_grid_kwargs={},\n **grid_kwargs):\n ref_flowmaps_filepath = os.path.join(self.plots_data_dir,ref_flowmaps_filename)\n data_flowmaps_filepath = os.path.join(self.plots_data_dir,data_flowmaps_filename)\n rdirs_filepath = os.path.join(self.plots_data_dir,rdirs_filename)\n if ref_catchment_filename:\n ref_catchments_filepath = os.path.join(self.plots_data_dir,\n ref_catchment_filename)\n if data_catchment_filename:\n if no_data_path_prefixes:\n data_catchment_filepath = data_catchment_filename\n else:\n data_catchment_filepath = os.path.join(self.plots_data_dir,\n data_catchment_filename)\n if data_rdirs_filename:\n if no_data_path_prefixes:\n data_rdirs_filepath = data_rdirs_filename\n else:\n data_rdirs_filepath = os.path.join(self.plots_data_dir,\n data_rdirs_filename)\n if ref_orog_filename:\n ref_orog_filepath = os.path.join(self.orog_data_directory,\n ref_orog_filename)\n if data_orog_original_scale_filename:\n if no_data_path_prefixes:\n data_orog_original_scale_filepath = data_orog_original_scale_filename\n else:\n data_orog_original_scale_filepath = os.path.join(self.orog_data_directory,\n data_orog_original_scale_filename)\n if data_catchment_original_scale_filename:\n if no_data_path_prefixes:\n data_catchment_original_scale_filepath = data_catchment_original_scale_filename\n else:\n data_catchment_original_scale_filepath = os.path.join(self.plots_data_dir,\n data_catchment_original_scale_filename)\n if ref_catchment_original_scale_filename:\n ref_catchment_original_scale_filepath = os.path.join(self.plots_data_dir,\n ref_catchment_original_scale_filename)\n if catchment_and_outflows_mods_list_filename:\n catchment_and_outflows_mods_list_filepath = os.path.join(self.catchment_and_outflows_mods_list_directory,\n catchment_and_outflows_mods_list_filename)\n if additional_matches_list_filename:\n additional_matches_list_filepath = os.path.join(self.additional_matches_list_directory,\n additional_matches_list_filename)\n if external_ls_mask_filename:\n external_ls_mask_filepath = os.path.join(self.plots_data_dir,\n external_ls_mask_filename)\n if super_fine_orog_filename:\n super_fine_orog_filepath = os.path.join(self.orog_data_directory,\n super_fine_orog_filename)\n if super_fine_data_flowmap_filename:\n super_fine_data_flowmap_filepath = os.path.join(self.plots_data_dir,\n super_fine_data_flowmap_filename)\n if ref_catchment_filename:\n ref_catchment_field = iohlpr.NetCDF4FileIOHelper.load_field(ref_catchments_filepath,\n grid_type,**grid_kwargs)\n if data_catchment_filename:\n data_catchment_field =\\\n iohlpr.NetCDF4FileIOHelper.load_field(data_catchment_filepath,\n grid_type,**grid_kwargs)\n if grid_type == data_original_scale_grid_type and grid_kwargs == data_original_scale_grid_kwargs:\n catchment_grid_changed = False\n data_catchment_field_original_scale = data_catchment_field\n else:\n catchment_grid_changed = True\n if data_catchment_original_scale_filepath is None:\n raise RuntimeError('require original scale catchment to use upscaled catchments')\n data_catchment_field_original_scale =\\\n iohlpr.NetCDF4FileIOHelper.load_field(data_catchment_original_scale_filepath,\n grid_type=data_original_scale_grid_type,\n **data_original_scale_grid_kwargs)\n if data_original_scale_flow_map_filename is None:\n raise RuntimeError('require original flow to cell data to use upscaled catchments')\n else:\n data_original_scale_flow_map_filepath = os.path.join(self.plots_data_dir,\n data_original_scale_flow_map_filename)\n data_original_scale_flowtocellfield = iohlpr.NetCDF4FileIOHelper.\\\n load_field(data_original_scale_flow_map_filepath,grid_type=data_original_scale_grid_type,\n **data_original_scale_grid_kwargs)\n if use_original_scale_field_for_determining_data_and_ref_labels:\n if ref_original_scale_flow_map_filename is None:\n raise RuntimeError('require original flow to cell field to use upscaled catchments for ref')\n elif ref_catchment_original_scale_filename is None:\n raise RuntimeError('require original scale catchment to use upscaled catchments for ref')\n else:\n ref_original_scale_flow_map_filepath = os.path.join(self.plots_data_dir,\n ref_original_scale_flow_map_filename)\n ref_original_scale_flowtocellfield = iohlpr.NetCDF4FileIOHelper.\\\n load_field(ref_original_scale_flow_map_filepath,grid_type=data_original_scale_grid_type,\n **data_original_scale_grid_kwargs)\n ref_catchment_field_original_scale =\\\n iohlpr.NetCDF4FileIOHelper.load_field(ref_catchment_original_scale_filepath,\n grid_type=ref_original_scale_grid_type,\n **ref_original_scale_grid_kwargs)\n else:\n ref_original_scale_flowtocellfield = None\n ref_catchment_field_original_scale = None\n ref_flowtocellfield = iohlpr.NetCDF4FileIOHelper.load_field(ref_flowmaps_filepath,grid_type,**grid_kwargs)\n data_flowtocellfield = iohlpr.NetCDF4FileIOHelper.load_field(data_flowmaps_filepath,grid_type,**grid_kwargs)\n rdirs_field = iohlpr.NetCDF4FileIOHelper.load_field(rdirs_filepath,grid_type,**grid_kwargs)\n ref_grid = grid.makeGrid(grid_type,**grid_kwargs)\n if data_rdirs_filename:\n if catchment_grid_changed:\n data_rdirs_field = iohlpr.NetCDF4FileIOHelper.load_field(data_rdirs_filepath,\n grid_type=data_original_scale_grid_type,\n **data_original_scale_grid_kwargs)\n data_rdirs_field = utilities.upscale_field(input_field=field.\\\n Field(data_rdirs_field,\n grid=data_original_scale_grid_type,\n **data_original_scale_grid_kwargs),\n output_grid_type=grid_type,\n method='CheckValue',\n output_grid_kwargs=grid_kwargs,\n scalenumbers=False).get_data()\n else:\n data_rdirs_field = iohlpr.NetCDF4FileIOHelper.load_field(data_rdirs_filepath,grid_type,\n **grid_kwargs)\n else:\n data_rdirs_field = None\n if ref_orog_filename:\n ref_orog_field = iohlpr.NetCDF4FileIOHelper.load_field(ref_orog_filepath,grid_type,\n **grid_kwargs)\n ref_orog_field = np.ma.array(ref_orog_field)\n\n if data_orog_original_scale_filename:\n data_orog_original_scale_field = iohlpr.NetCDF4FileIOHelper.\\\n load_field(data_orog_original_scale_filepath,\n grid_type=data_original_scale_grid_type,\n **data_original_scale_grid_kwargs)\n fine_grid = grid.makeGrid(data_original_scale_grid_type,\n **data_original_scale_grid_kwargs)\n if flip_orog_original_scale_relative_to_data:\n #This is an extra flip along with the flip applied below\n data_orog_original_scale_field = np.flipud(data_orog_original_scale_field)\n else:\n fine_grid = ref_grid\n if super_fine_orog_filename:\n super_fine_orog_field = iohlpr.NetCDF4FileIOHelper.\\\n load_field(super_fine_orog_filepath,\n grid_type=super_fine_orog_grid_type,\n **super_fine_orog_grid_kwargs)\n super_fine_grid = grid.makeGrid(super_fine_orog_grid_type,\n **super_fine_orog_grid_kwargs)\n if super_fine_data_flowmap_filename:\n super_fine_data_flowmap = iohlpr.NetCDF4FileIOHelper.\\\n load_field(super_fine_data_flowmap_filepath,\n grid_type=super_fine_orog_grid_type,\n **super_fine_orog_grid_kwargs)\n else:\n super_fine_data_flowmap = None\n if flip_super_fine_orog:\n super_fine_orog_field = np.flipud(super_fine_orog_field)\n if super_fine_data_flowmap is not None:\n super_fine_data_flowmap = np.flipud(super_fine_data_flowmap)\n if rotate_super_fine_orog:\n super_fine_orog_field = np.roll(super_fine_orog_field,\n np.size(super_fine_orog_field,\n axis=1)//2,\n axis=1)\n if super_fine_data_flowmap is not None:\n super_fine_data_flowmap = np.roll(super_fine_data_flowmap,\n np.size(super_fine_data_flowmap,\n axis=1)//2,\n axis=1)\n else:\n super_fine_orog_field = None\n super_fine_data_flowmap = None\n super_fine_grid = ref_grid\n if external_ls_mask_filename:\n external_ls_mask = iohlpr.NetCDF4FileIOHelper.\\\n load_field(external_ls_mask_filepath,\n grid_type=grid_type,\n **grid_kwargs)\n else:\n external_ls_mask = None\n if flip_ref_field:\n ref_flowtocellfield = np.flipud(ref_flowtocellfield)\n rdirs_field = np.flipud(rdirs_field)\n if ref_catchment_filename:\n ref_catchment_field = np.flipud(ref_catchment_field)\n if use_original_scale_field_for_determining_data_and_ref_labels:\n ref_original_scale_flowtocellfield = np.flipud(ref_original_scale_flowtocellfield)\n ref_catchment_field_original_scale = np.flipud(ref_catchment_field_original_scale)\n if flip_data_field:\n data_flowtocellfield = np.flipud(data_flowtocellfield)\n if data_rdirs_filename:\n data_rdirs_field = np.flipud(data_rdirs_field)\n if data_catchment_filename:\n data_catchment_field = np.flipud(data_catchment_field)\n if catchment_grid_changed:\n data_original_scale_flowtocellfield = np.flipud(data_original_scale_flowtocellfield)\n data_catchment_field_original_scale = np.flipud(data_catchment_field_original_scale)\n if data_orog_original_scale_filename:\n data_orog_original_scale_field = np.flipud(data_orog_original_scale_field)\n if rotate_ref_field:\n ref_flowtocellfield = np.roll(ref_flowtocellfield,\n np.size(ref_flowtocellfield,axis=1)//2,\n axis=1)\n rdirs_field = np.roll(rdirs_field,\n np.size(rdirs_field,axis=1)//2,\n axis=1)\n if ref_catchment_filename:\n ref_catchment_field = np.roll(ref_catchment_field,\n np.size(ref_catchment_field,axis=1)//2,\n axis=1)\n if use_original_scale_field_for_determining_data_and_ref_labels:\n ref_original_scale_flowtocellfield = np.roll(ref_original_scale_flowtocellfield,\n np.size(ref_original_scale_flowtocellfield,\n axis=1)//2,\n axis=1)\n ref_catchment_field_original_scale = np.roll(ref_catchment_field_original_scale,\n np.size(ref_catchment_field_original_scale,\n axis=1)//2,\n axis=1)\n if rotate_data_field:\n data_flowtocellfield = np.roll(data_flowtocellfield,\n np.size(data_flowtocellfield,axis=1)//2,\n axis=1)\n if data_rdirs_filename:\n data_rdirs_field = np.roll(data_rdirs_field,\n np.size(data_rdirs_field,axis=1)//2,\n axis=1)\n if data_catchment_filename:\n data_catchment_field = np.roll(data_catchment_field,\n np.size(data_catchment_field,axis=1)//2,\n axis=1)\n if catchment_grid_changed:\n data_original_scale_flowtocellfield = np.roll(data_original_scale_flowtocellfield,\n np.size(data_original_scale_flowtocellfield,\n axis=1)//2,\n axis=1)\n data_catchment_field_original_scale = np.roll(data_catchment_field_original_scale,\n np.size(data_catchment_field_original_scale,\n axis=1)//2,\n axis=1)\n if data_orog_original_scale_filename:\n data_orog_original_scale_field = np.roll(data_orog_original_scale_field,\n np.size(data_orog_original_scale_field,\n axis=1)//2,\n axis=1)\n else:\n data_orog_original_scale_field = None\n if flip_external_ls_mask:\n external_ls_mask = np.flipud(external_ls_mask)\n if rotate_external_ls_mask:\n external_ls_mask = np.roll(external_ls_mask,\n np.size(external_ls_mask,\n axis=1)//2,\n axis=1)\n temp_file_list = []\n if catchment_and_outflows_mods_list_filename:\n ref_outflow_field = iodriver.load_field(reference_rmouth_outflows_filename,\n file_type=iodriver.\\\n get_file_extension(reference_rmouth_outflows_filename),\n field_type='Generic', grid_type=grid_type,**grid_kwargs)\n data_outflow_field = iodriver.load_field(data_rmouth_outflows_filename,\n file_type=iodriver.\\\n get_file_extension(data_rmouth_outflows_filename),\n field_type='Generic', grid_type=grid_type,**grid_kwargs)\n if flip_ref_field:\n ref_outflow_field.flip_data_ud()\n if rotate_ref_field:\n ref_outflow_field.rotate_field_by_a_hundred_and_eighty_degrees()\n if flip_data_field:\n data_outflow_field.flip_data_ud()\n if rotate_data_field:\n data_outflow_field.rotate_field_by_a_hundred_and_eighty_degrees()\n ref_catchment_field, ref_outflow_field, data_catchment_field, data_outflow_field =\\\n rc_pts.modify_catchments_and_outflows(ref_catchments=ref_catchment_field,\n ref_outflows=ref_outflow_field,\n ref_flowmap=ref_flowtocellfield,\n ref_rdirs = rdirs_field,\n data_catchments=data_catchment_field,\n data_outflows=data_outflow_field,\n catchment_and_outflows_modifications_list_filename=\\\n catchment_and_outflows_mods_list_filepath,\n original_scale_catchment=\\\n data_catchment_field_original_scale.get_data(),\n original_scale_flowmap=\\\n data_original_scale_flowtocellfield.get_data(),\n catchment_grid_changed=catchment_grid_changed,\n swap_ref_and_data_when_finding_labels=\\\n swap_ref_and_data_when_finding_labels,\n original_scale_grid_type=\\\n data_original_scale_grid_type,\n original_scale_grid_kwargs=\\\n data_original_scale_grid_kwargs,\n grid_type=grid_type,**grid_kwargs)\n if flip_data_field:\n data_outflow_field.flip_data_ud()\n if rotate_data_field:\n data_outflow_field.rotate_field_by_a_hundred_and_eighty_degrees()\n if flip_ref_field:\n ref_outflow_field.flip_data_ud()\n if rotate_ref_field:\n ref_outflow_field.rotate_field_by_a_hundred_and_eighty_degrees()\n reference_rmouth_outflows_filename=os.path.join(self.scratch_dir,\n self.temp_label + os.path.\\\n basename(reference_rmouth_outflows_filename))\n data_rmouth_outflows_filename=os.path.join(self.scratch_dir,\n self.temp_label + os.path.\\\n basename(reference_rmouth_outflows_filename))\n temp_file_list.append(reference_rmouth_outflows_filename)\n temp_file_list.append(data_rmouth_outflows_filename)\n iodriver.write_field(reference_rmouth_outflows_filename,\n field=ref_outflow_field,\n file_type=iodriver.\\\n get_file_extension(reference_rmouth_outflows_filename))\n iodriver.write_field(data_rmouth_outflows_filename,\n field=data_outflow_field,\n file_type=iodriver.\\\n get_file_extension(data_rmouth_outflows_filename))\n matchedpairs, unresolved_conflicts = mtch_rm.main(reference_rmouth_outflows_filename=\\\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename=\\\n data_rmouth_outflows_filename,\n grid_type=grid_type,\n flip_data_field=flip_data_field,\n rotate_data_field=rotate_data_field,\n flip_ref_field=flip_ref_field,\n rotate_ref_field=rotate_ref_field,\n param_set=matching_parameter_set,\n **grid_kwargs)\n if additional_matches_list_filename:\n additional_matches = mtch_rm.load_additional_manual_matches(additional_matches_list_filepath,\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename,\n flip_data_field=flip_data_field,\n rotate_data_field=rotate_data_field,\n grid_type='HD',**grid_kwargs)\n matchedpairs.extend(additional_matches)\n if ref_orog_filename:\n ref_orog_field[rdirs_field <= 0] = np.ma.masked\n interactive_plots = Interactive_Plots()\n if return_simple_catchment_and_flowmap_plotters and plot_simple_catchment_and_flowmap_plots:\n simple_catchment_and_flowmap_plotters = []\n if return_catchment_plotters:\n catchment_plotters = []\n for pair in matchedpairs:\n if pair[0].get_lat() > 310:\n continue\n if select_only_rivers_in == \"North America\":\n if(pair[0].get_lat() > 156 or pair[0].get_lon() > 260):\n continue\n print(\"Ref Point: \" + str(pair[0]) + \"Matches: \" + str(pair[1]))\n if rivers_to_plot is not None:\n if not (pair[0].get_lat(),pair[0].get_lon()) in rivers_to_plot:\n continue\n if split_comparison_plots_across_multiple_canvases:\n plt.figure(figsize=(25,6.25))\n ax = plt.subplot(121)\n plt.tight_layout()\n else:\n plt.figure(figsize=(25,12.5))\n ax = plt.subplot(222)\n rc_pts.plot_river_rmouth_flowmap(ax=ax,\n ref_flowtocellfield=ref_flowtocellfield,\n data_flowtocellfield=data_flowtocellfield,\n rdirs_field=rdirs_field,\n pair=pair,colors=self.colors)\n if split_comparison_plots_across_multiple_canvases:\n ax_hist = plt.subplot(122)\n plt.figure(figsize=(12.5,12.5))\n ax_catch = plt.subplot(111)\n plt.tight_layout(rect=(0,0,0.9,1))\n else:\n ax_hist = plt.subplot(221)\n ax_catch = plt.subplot(223)\n plot_catchment_and_histogram_output = \\\n rc_pts.plot_catchment_and_histogram_for_river(ax_hist=ax_hist,ax_catch=ax_catch,\n ref_catchment_field=ref_catchment_field,\n data_catchment_field=data_catchment_field,\n data_catchment_field_original_scale=\\\n data_catchment_field_original_scale,\n data_original_scale_flowtocellfield=\\\n data_original_scale_flowtocellfield,\n rdirs_field=rdirs_field,\n data_rdirs_field=data_rdirs_field,pair=pair,\n catchment_grid_changed=catchment_grid_changed,\n swap_ref_and_data_when_finding_labels=\\\n swap_ref_and_data_when_finding_labels,\n colors=self.colors,\n ref_grid=ref_grid,\n grid_type=grid_type,\n alternative_catchment_bounds=\\\n alternative_catchment_bounds,\n use_simplified_catchment_colorscheme=\\\n use_simplified_catchment_colorscheme,\n use_upscaling_labels=\\\n use_upscaling_labels,\n allow_new_sink_points=\\\n allow_new_true_sinks,\n external_landsea_mask=\\\n external_ls_mask,\n ref_original_scale_flowtocellfield=\\\n ref_original_scale_flowtocellfield,\n ref_catchment_field_original_scale=\\\n ref_catchment_field_original_scale,\n use_original_scale_field_for_determining_data_and_ref_labels=\\\n use_original_scale_field_for_determining_data_and_ref_labels,\n return_catchment_plotter=\\\n return_catchment_plotters,\n data_original_scale_grid_type=\\\n data_original_scale_grid_type,\n ref_original_scale_grid_type=\\\n ref_original_scale_grid_type,\n data_original_scale_grid_kwargs=\\\n data_original_scale_grid_kwargs,\n ref_original_scale_grid_kwargs=\\\n ref_original_scale_grid_kwargs,\n **grid_kwargs)\n if return_catchment_plotters:\n catchment_section,catchment_bounds,scale_factor,catchment_plotter =\\\n plot_catchment_and_histogram_output\n catchment_plotters.append(catchment_plotter)\n else:\n catchment_section,catchment_bounds,scale_factor = plot_catchment_and_histogram_output\n if split_comparison_plots_across_multiple_canvases:\n plt.figure(figsize=(12.5,12.5))\n ax = plt.subplot(111)\n plt.tight_layout(rect=(0,0,0.9,1))\n else:\n ax = plt.subplot(224)\n rc_pts.plot_whole_river_flowmap(ax=ax,pair=pair,ref_flowtocellfield=ref_flowtocellfield,\n data_flowtocellfield=data_flowtocellfield,\n rdirs_field=rdirs_field,data_rdirs_field=data_rdirs_field,\n catchment_bounds=catchment_bounds,colors=self.colors,\n simplified_flowmap_plot=use_simplified_flowmap_colorscheme,\n allow_new_sink_points=allow_new_true_sinks)\n if plot_simple_catchment_and_flowmap_plots:\n simple_candf_plt = plt.figure(figsize=(10,6))\n simple_ref_ax = plt.subplot(121)\n simple_data_ax = plt.subplot(122)\n flowtocell_threshold = 75\n plotters = rc_pts.simple_catchment_and_flowmap_plots(fig=simple_candf_plt,\n ref_ax=simple_ref_ax,\n data_ax=simple_data_ax,\n ref_catchment_field=ref_catchment_field,\n data_catchment_field=data_catchment_field,\n data_catchment_field_original_scale=\\\n data_catchment_field_original_scale,\n ref_flowtocellfield=ref_flowtocellfield,\n data_flowtocellfield=data_flowtocellfield,\n data_original_scale_flowtocellfield=\\\n data_original_scale_flowtocellfield,\n pair=pair,catchment_bounds=catchment_bounds,\n flowtocell_threshold=flowtocell_threshold,\n catchment_grid_changed=catchment_grid_changed,\n colors=self.colors,\n external_ls_mask=external_ls_mask,\n grid_type=grid_type,\n data_original_scale_grid_type=\\\n data_original_scale_grid_type,\n data_original_scale_grid_kwargs=\\\n data_original_scale_grid_kwargs,**grid_kwargs)\n if return_simple_catchment_and_flowmap_plotters:\n simple_catchment_and_flowmap_plotters.append(plotters)\n if ref_orog_filename and data_orog_original_scale_filename:\n if super_fine_orog_filename:\n data_to_super_fine_scale_factor = \\\n pts.calculate_scale_factor(coarse_grid_type=data_original_scale_grid_type,\n coarse_grid_kwargs=data_original_scale_grid_kwargs,\n fine_grid_type=super_fine_orog_grid_type,\n fine_grid_kwargs=super_fine_orog_grid_kwargs)\n ref_to_super_fine_scale_factor = data_to_super_fine_scale_factor*scale_factor\n else:\n ref_to_super_fine_scale_factor=None\n interactive_plots.setup_plots(catchment_section,\n ref_orog_field,\n data_orog_original_scale_field,\n ref_flowtocellfield,\n data_flowtocellfield,\n rdirs_field,\n super_fine_orog_field,\n super_fine_data_flowmap,\n pair, catchment_bounds,\n scale_factor,\n ref_to_super_fine_scale_factor,\n ref_grid_offset_adjustment=ref_grid.\\\n get_longitude_offset_adjustment(),\n fine_grid_offset_adjustment=fine_grid.\\\n get_longitude_offset_adjustment(),\n super_fine_grid_offset_adjustment=super_fine_grid.\\\n get_longitude_offset_adjustment())\n elif ref_orog_filename or data_orog_original_scale_filename:\n warnings.warn(\"No orography plot generated, require both a reference orography\"\n \" and a data orography to generate an orography plot\")\n print(\"Unresolved Conflicts: \")\n for conflict in unresolved_conflicts:\n print(\" Conflict:\")\n for pair in conflict:\n print(\" Ref Point\" + str(pair[0]) + \"Matches\" + str(pair[1]))\n for temp_file in temp_file_list:\n if os.path.basename(temp_file).startswith(\"temp_\"):\n print(\"Deleting File: {0}\".format(temp_file))\n os.remove(temp_file)\n if return_simple_catchment_and_flowmap_plotters and plot_simple_catchment_and_flowmap_plots:\n return simple_catchment_and_flowmap_plotters\n if return_catchment_plotters:\n return catchment_plotters","def investigate4DRepeatability():\n parentdir = '/home/rallured/Dropbox/Interferometer/SolarBFlat/Repeatability/'\n avgs = [1,2,4,8,16,32]\n\n #Temporal with fringes tilted\n fn = glob.glob(parentdir+'Tilt/17*RepeatabilityTiltTemporal*.bin')\n fn.sort()\n dx = met.readFlatScript(fn[0].split('.')[0])[1]\n d = np.array([met.readFlatScript(fi.split('.')[0])[0] for fi in fn])\n #Make progressive averaging plot\n plt.figure('TemporalTiltedFigure')\n for i in np.arange(6)*2:\n f,p = fourier.meanPSD(d[i],win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label=str(avgs[i/2]))\n plt.legend(loc='lower left')\n plt.title('Solar B PSD - Temporal,Tilted')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n #Get repeatability\n reptemptilt = d[-1]-d[-2]\n figtemptilt = d[-1]\n\n #Dynamic with fringes tilted\n fn = glob.glob(parentdir+'Tilt/17*RepeatabilityTilt_*.bin')\n fn.sort()\n dx = met.readFlatScript(fn[0].split('.')[0])[1]\n d = [met.readFlatScript(fi.split('.')[0])[0] for fi in fn]\n #Make progressive averaging plot\n plt.figure('DynamicTiltedFigure')\n for i in np.arange(6)*2:\n f,p = fourier.meanPSD(d[i],win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label=str(avgs[i/2]))\n plt.legend(loc='lower left')\n plt.title('Solar B PSD - Dynamic,Tilted')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n #Get repeatability\n repdyntilt = d[-1]-d[-2]\n figdyntilt = d[-1]\n \n #Temporal with fringes nulled\n fn = glob.glob(parentdir+'Nulled/17*.bin')\n fn.sort()\n dx = met.readFlatScript(fn[0].split('.')[0])[1]\n d = np.array([met.readFlatScript(fi.split('.')[0])[0] for fi in fn])\n #Make progressive averaging plot\n plt.figure('TemporalNulledFigure')\n for i in np.arange(6)*2:\n f,p = fourier.meanPSD(d[i],win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label=str(avgs[i/2]))\n plt.legend(loc='lower left')\n plt.title('Solar B PSD - Temporal,Nulled')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n #Get repeatability\n reptempnull = d[-1]-d[-2]\n figtempnull = d[-1]\n \n #Dynamic with fringes nulled\n d = pyfits.getdata('/home/rallured/Dropbox/Interferometer/'\n 'SolarBFlat/Repeatability/'\n 'Nulled/170103_Processed.fits')\n rep = np.array([d[i,0]-d[i,1] for i in range(32)])\n #Make progressive averaging plot\n plt.figure('DynamicNulledFigure')\n for i in [0,1,3,7,15,31]:\n f,p = fourier.meanPSD(d[i,0],win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label=str(i+1))\n plt.legend(loc='lower left')\n plt.title('Solar B PSD - Dynamic,Nulled')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n #Get repeatability\n repdynnull = d[-1][0]-d[-1][1]\n figdynnull = d[-1][0]\n\n #Make comparative repeatability plots with 32 averages\n plt.figure('CompareRepeatability')\n f,p = fourier.meanPSD(repdynnull,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Dynamic,Nulled')\n f,p = fourier.meanPSD(repdyntilt,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Dynamic,Tilted')\n f,p = fourier.meanPSD(reptemptilt,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Temporal,Tilted')\n f,p = fourier.meanPSD(reptempnull,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Temporal,Nulled')\n plt.legend(loc='lower left')\n plt.title('Solar B Repeatability - 32 Averages')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n\n #Make comparative figure plots with 32 averages\n plt.figure('CompareFigure')\n f,p = fourier.meanPSD(figdynnull,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Dynamic,Nulled')\n f,p = fourier.meanPSD(figdyntilt,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Dynamic,Tilted')\n f,p = fourier.meanPSD(figtemptilt,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Temporal,Tilted')\n f,p = fourier.meanPSD(figtempnull,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Temporal,Nulled')\n plt.legend(loc='lower left')\n plt.title('Solar B Figure - 32 Averages')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n\n #Make parroting repeatability plots\n fig = plt.figure('Parroting')\n fig.add_subplot(2,2,1)\n plt.imshow(repdyntilt)\n plt.title('Dynamic Repeatability')\n plt.colorbar()\n fig.add_subplot(2,2,2)\n plt.imshow(reptemptilt)\n plt.title('Temporal Repeatability')\n plt.colorbar()\n fig.add_subplot(2,2,3)\n res = legendre2d(repdyntilt,xo=3,yo=3)[0]\n plt.imshow(repdyntilt-res)\n plt.title('Dynamic Repeatability Filtered')\n plt.colorbar()\n fig.add_subplot(2,2,4)\n res = legendre2d(reptemptilt,xo=3,yo=3)[0]\n plt.imshow(reptemptilt-res)\n plt.title('Temporal Repeatability Filtered')\n plt.colorbar()","def apolco(a,minfeh=-3,out=None) :\n apo=np.where((a['TELESCOPE'] == 'apo25m') & (a['RV_FEH']>minfeh) )[0]\n fig=vscat(a[apo],marker='o',density=True)\n lco=np.where((a['TELESCOPE'] == 'lco25m') & (a['RV_FEH']>minfeh) )[0]\n vscat(a[lco],fig=fig,ls=':',marker='+',density=True)\n if out is not None : \n fig[0].savefig(out+'_1.png')\n plt.close()\n i1,i2=match.match(a['APOGEE_ID'][apo],a['APOGEE_ID'][lco])\n print('matched {:d} stars'.format(len(i1)))\n fig,ax=plots.multi(1,2)\n #plots.plotp(ax[0,0],a['SNR'][apo[i1]],a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],yr=[-3,3],yt=r'$\\Delta$ VHELIO_AVG',xt='S/N')\n #plots.plotp(ax[0,1],a['SNR'][apo[i1]],a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],yr=[-50,50],yt=r'$\\Delta$ VHELIO_AVG',xt='S/N')\n #plots.plotp(ax[1,0],a['SNR'][apo[i1]],a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],yr=[-0.5,0.5],yt=r'$\\Delta$ VSCATTER',xt='S/N')\n #plots.plotp(ax[1,1],a['SNR'][apo[i1]],a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],yr=[-5,5],yt=r'$\\Delta$ VSCATTER',xt='S/N')\n ax[0].hist(a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],bins=np.arange(-0.5,0.5,0.02),histtype='step')\n ax[0].set_xlabel(r'$\\Delta$ VHELIO_AVG')\n ax[1].hist(a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],bins=np.arange(-0.25,0.25,0.01),histtype='step')\n ax[1].set_xlabel(r'$\\Delta$ VSCATTER')\n if out is not None : \n fig.savefig(out+'_2.png')\n plt.close()","def MatchMatrixs (self,Node1,Node2):\n\n T1Native_Node = Node1\n T1Native_Matrix = slicer.util.arrayFromVolume(T1Native_Node)\n DimN = T1Native_Matrix.shape\n T1Enhanced_Node = Node2\n T1Enhanced_Matrix = slicer.util.arrayFromVolume(T1Enhanced_Node)\n DimE = T1Enhanced_Matrix.shape\n\n NMatrix = self.GetIJKToRASnpArray(T1Native_Node)\n NVector = NMatrix[:-1,-1]\n EMatrix = self.GetIJKToRASnpArray(T1Enhanced_Node)\n EVector = EMatrix[:-1,-1]\n NPixelSize = [np.linalg.norm(NMatrix[:-1,0]), np.linalg.norm(NMatrix[:-1,1])]\n EPixelSize = [np.linalg.norm(EMatrix[:-1,0]), np.linalg.norm(EMatrix[:-1,1])]\n\n Niversor = NMatrix[:-1,0]/NPixelSize[0]\n Njversor = NMatrix[:-1,1]/NPixelSize[1]\n Nkversor = np.round(np.cross(Niversor,Njversor),3)\n Nkstep = round(np.linalg.norm(NMatrix[:-1,2]),3)\n\n Eiversor = EMatrix[:-1,0]/EPixelSize[0]\n Ejversor = EMatrix[:-1,1]/EPixelSize[1]\n Ekversor = np.round(np.cross(Eiversor,Ejversor),3)\n Ekstep = round(np.linalg.norm(EMatrix[:-1,2]),3)\n print(Nkversor,Ekversor,Nkstep,Ekstep,NVector,EVector,(NVector-EVector).dot(Ekversor))\n if not ( np.sum(Nkversor==Ekversor) == 3 and Nkstep==Ekstep and ((NVector-EVector).dot(Ekversor)) == 0 ): # it verifies if the slices are oriented in the same direction, with the same step between slices and if the first images are complanar.\n slicer.util.warningDisplay('The geometry of the LL Native and LL Enhanced volume doesn\\'t match. It could deteriorate the ECV map', windowTitle= 'Warning')\n\n if (DimE == DimN):\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.NativeT1_Selector.currentNode()) \n return [T1Native_Matrix,T1Enhanced_Matrix]\n if (DimE[1:3] == DimN[1:3]):\n k = min([DimE[1],DimN[1]])\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.NativeT1_Selector.currentNode())\n return [T1Native_Matrix[:k,:,:],T1Enhanced_Matrix[:k,:,:]]\n\n jN = np.arange(0,DimN[2]*NPixelSize[1],NPixelSize[1])+NPixelSize[1]/2+(NVector-EVector).dot(Njversor)\n iN = np.arange(0,DimN[1]*NPixelSize[0],NPixelSize[0])+NPixelSize[0]/2+(NVector-EVector).dot(Niversor)\n iE = np.arange(0,DimE[1]*EPixelSize[0],EPixelSize[0])+EPixelSize[0]/2\n jE = np.arange(0,DimE[2]*EPixelSize[1],EPixelSize[1])+EPixelSize[1]/2 \n if DimE[1] > DimN[1]: ## I concidered a square image\n T1Nreshaped = np.zeros(DimE)\n for k in range(DimN[0]):\n f = interpolate.interp2d(iN, jN, np.nan_to_num(T1Native_Matrix[k,:,:]), fill_value = 0)\n T1Nreshaped[k,:,:] = f(iE, jE)\n T1Ereshaped = T1Enhanced_Matrix[:k+1,:,:]\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.EnhancedT1_Selector.currentNode())\n return [T1Nreshaped,T1Ereshaped]\n else:\n T1Ereshaped = np.zeros(DimN)\n for k in range(DimE[0]):\n f = interpolate.interp2d(iE, jE, np.nan_to_num(T1Enhanced_Matrix[k,:,:]), fill_value = 0)\n T1Ereshaped[k,:,:] = f(iN, jN) \n T1Nreshaped = T1Native_Matrix[:k+1,:,:]\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.NativeT1_Selector.currentNode()) \n return [T1Nreshaped,T1Ereshaped]","def data_model_residual(surface, dem, unw, incidence):\n los,fem_los,residual = pu.los2pylith(surface,dem,unw,incidence)\n\n # Using image_grid\n fig = plt.figure()\n grid = ImageGrid(fig, 111, # similar to subplot(111)\n nrows_ncols = (1, 3),\n direction=\"row\",\n axes_pad = 0.05,\n add_all=True,\n label_mode = \"1\",\n share_all = True,\n cbar_location=\"top\",\n cbar_mode=\"each\", #\"single\"\n cbar_size=\"5%\",\n cbar_pad=0.05,\n )\n #grid[0].set_xlabel(\"X\")\n #grid[0].set_ylabel(\"Y\")\n #grid2[0].set_xticks([-2, 0])\n #grid2[0].set_yticks([-2, 0, 2])\n\n #NOTE: could find global min/max from three arrays here\n norm = Normalize(vmin=np.nanmin(los), vmax=np.nanmax(los))\n #for ax,data in zip(grid,[los,fem_los,residual]):\n im = grid[0].imshow(los,origin='upper',norm=norm,cmap=plt.cm.jet)\n grid[0].axhline(100,color='m') #show profile\n cax = grid.cbar_axes[0]\n cax.colorbar(im)\n grid[1].axhline(100,color='k') #show profile\n im1 = grid[1].imshow(fem_los,origin='upper',norm=norm,cmap=plt.cm.jet)\n\n cax = grid.cbar_axes[1]\n cax.colorbar(im1)\n\n im2 = grid[2].imshow(residual,origin='upper',cmap=plt.cm.jet)\n cax = grid.cbar_axes[2]\n cax.colorbar(im2)\n\n # Add letter labels\n for ax, label in zip(grid,['A', 'B', 'C']):\n ax.text(0.05, 0.95, label, transform=ax.transAxes,\n fontsize=16, fontweight='bold', va='top')\n\n # Annotate\n # NOTE: way too high!\n #plt.suptitle('FEM Results')\n\n # Add profile\n # NOTE: for now EW, but would be easy to do arbitrary line, and convert to km\n fig = plt.figure()\n #x = arange(los.shape[0])\n plt.axhline(color='k',ls='--')\n plt.plot(los[100],'m.',label='data')\n plt.plot(fem_los[100],'k-',lw=2,label='model')\n plt.xlabel('Distance [km]')\n plt.ylabel('Distance [km]')\n plt.legend(loc='upper left')\n\n plt.show()","def combine_sides(imgID_list_blue, imgID_list_red, output=None, splot='yes'):\r\n \r\n blue_files = ['blue{:04d}_flux.spec.fits'.format(imgID) for imgID in imgID_list_blue]\r\n red_files = ['red{:04d}_flux.spec.fits'.format(imgID) for imgID in imgID_list_red]\r\n blue_err_files = ['blue{:04d}_flux.err.fits'.format(imgID) for imgID in imgID_list_blue]\r\n red_err_files = ['red{:04d}_flux.err.fits'.format(imgID) for imgID in imgID_list_red]\r\n\r\n\r\n if output is None:\r\n hdr = pyfits.getheader(blue_files[0])\r\n obj = hdr['OBJECT'].replace(' ', '_')\r\n # create a unique name based on the input\r\n\r\n def ids_to_string(idlist):\r\n \"\"\"Create hyphen-delimited string from list of ints\"\"\"\r\n if len(idlist) == 1:\r\n return \"{:d}\".format(idlist[0])\r\n else:\r\n return \"-\".join([\"{:d}\".format(id) for id in idlist])\r\n\r\n output = obj + '_' + \\\r\n ids_to_string(imgID_list_blue) + '+' + \\\r\n ids_to_string(imgID_list_red) \r\n\r\n # clobber the old output files if they exist\r\n iraf.delete(output+'.*.fits', verify='no')\r\n iraf.delete(output+'.*.txt', verify='no')\r\n \r\n # determine dispersion: downsample to lower-resolution spectrum\r\n hdr = pyfits.getheader(blue_files[0])\r\n dw_blue = hdr['CDELT1']\r\n hdr = pyfits.getheader(red_files[0])\r\n dw_red = hdr['CDELT1']\r\n dw = np.max([dw_blue, dw_red])\r\n\r\n # find wavelength ranges\r\n def wavelength_range(fits_list):\r\n \"\"\"Given an input list of fits spectra from extract1D, \r\n return the absolute minimum and maximum wavelength ranges\"\"\"\r\n mins = []\r\n maxes = []\r\n for fname in fits_list:\r\n spec = np.genfromtxt(fname.replace('fits', 'txt'), names='wave, flux', \r\n dtype='f4, f4')\r\n mins.append(spec['wave'].min())\r\n maxes.append(spec['wave'].max())\r\n return [np.array(mins).min(), np.array(maxes).max()]\r\n\r\n blue_range = wavelength_range(blue_files)\r\n red_range = wavelength_range(red_files)\r\n\r\n # find overlap region\r\n if red_range[0] >= blue_range[1]:\r\n raise ValueError('No overlap in wavelength solution between sides!')\r\n\r\n # specify total spectral range\r\n w1 = blue_range[0]\r\n w2 = red_range[1]\r\n\r\n # re-disperse to common wavelength solution\r\n def redisperse_list(files,dw,w1,w2,key='spec'):\r\n \"\"\"Re-disperse a list of spectra.\r\n\r\n Wraps iraf.dispcor.\r\n\r\n Parameters\r\n ----------\r\n files : list of strings\r\n Files to disperse\r\n dw : int\r\n rs Spectral dispersion [Angstroms per pixel]\r\n w1 : int\r\n Minimum wavelength [Angstrom]\r\n w2 : int\r\n Maximum wavelength [Angstrom]\r\n key : {'spec' (default) or 'err'}\r\n Whether the files are spectra or uncertainties.\r\n \"\"\"\r\n input_list = ','.join(files)\r\n disp_files = [f.replace(key, key+'-disp') for f in files]\r\n output_disp_list = ','.join(disp_files)\r\n iraf.unlearn('dispcor')\r\n iraf.dispcor.input = input_list\r\n iraf.dispcor.output = output_disp_list\r\n # keep existing wavelength endpoints\r\n iraf.dispcor.dw = dw\r\n iraf.dispcor.w1 = w1\r\n iraf.dispcor.w2 = w2\r\n iraf.dispcor.flux = 'no'\r\n iraf.dispcor()\r\n # write text files\r\n for output in disp_files:\r\n iraf.wspectext(output, output.replace('fits', 'txt'), header=\"no\")\r\n\r\n return disp_files\r\n\r\n # delete any lingering files\r\n iraf.delete('*-disp.fits', verify='no')\r\n iraf.delete('*-disp.txt', verify='no')\r\n\r\n blue_files_redisp = redisperse_list(blue_files, dw, w1, w2)\r\n red_files_redisp = redisperse_list(red_files, dw, w1, w2)\r\n blue_err_files_redisp = redisperse_list(blue_err_files, dw, w1, w2, key='err')\r\n red_err_files_redisp = redisperse_list(red_err_files, dw, w1, w2, key='err')\r\n\r\n # combine individual sides\r\n coadd_spectra(blue_files_redisp, 'tmp-blue')\r\n coadd_spectra(red_files_redisp, 'tmp-red')\r\n\r\n # find optimum weighting between sides\r\n\r\n # combine sides, weighted by uncertainties\r\n coadd_spectra(['tmp-blue.spec.fits', 'tmp-red.spec.fits'], output,\r\n one_side=False)\r\n\r\n # clean up\r\n iraf.delete('*-disp.fits', verify='no')\r\n iraf.delete('*-disp.txt', verify='no')\r\n iraf.delete('tmp-*.fits', verify='no')\r\n iraf.delete('tmp-*.txt', verify='no')\r\n \r\n if splot == 'yes':\r\n iraf.splot(output+'.spec')","def show_corls():\n datar = data_from_fits(\"752_1_373_r.fits\")\n datar = other_object(datar)\n datag = data_from_fits(\"752_1_373_g.fits\")\n datag = other_object(datag)\n corl = correlate2d(datar, datag, mode=\"same\")\n plt.figure()\n plt.imshow(corl)\n\n datar = data_from_fits(\"752_1_373_r.fits\")\n datar = galaxy(datar)\n datag = data_from_fits(\"752_1_373_g.fits\")\n datag = galaxy(datag)\n corl = correlate2d(datar, datag, mode=\"same\")\n plt.figure()\n plt.imshow(corl)\n\n\n datar = data_from_fits(\"752_1_373_r.fits\")\n datar = asteroid(datar)\n datag = data_from_fits(\"752_1_373_g.fits\")\n datag = asteroid(datag)\n corl = correlate2d(datar, datag, mode=\"same\")\n plt.figure()\n plt.imshow(corl)","def eval_pos():\n annotations_dir = \"/home/sdb/wangshentao/myspace/thesis/data/VisDrone2019-MOT-test-dev/annotations\"\n all_iou = []\n seqs_sample = '''\n uav0000249_00001_v\n uav0000249_02688_v\n '''\n seqs_str = seqs_sample\n seqs = [seq.strip() for seq in seqs_str.split()]\n for seq in seqs:\n print(seq)\n bbox, frame_id = get_frame_bbox(annotations_dir, seq + '.txt')\n predict_bbox = []\n for idx in range(len(bbox)):\n kalman_filter = KalmanFilter()\n trace_bbox = bbox[idx]\n trace_predict_bbox = []\n mean, covariance = kalman_filter.initiate(tlwh_to_xyah(trace_bbox[0]))\n for i in range(1, trace_bbox.shape[0]):\n mean, covariance = kalman_filter.predict(mean, covariance)\n trace_predict_bbox.append(tlwh(mean))\n mean, covariance = kalman_filter.update(mean, covariance, tlwh_to_xyah(trace_bbox[i]))\n\n trace_predict_bbox = np.array(trace_predict_bbox)\n for i in range(trace_predict_bbox.shape[0]):\n trace_predict_bbox[i] = tlwh_to_tlbr(trace_predict_bbox[i])\n for i in range(trace_bbox.shape[0]):\n trace_bbox[i] = tlwh_to_tlbr(trace_bbox[i])\n\n predict_bbox.append(trace_predict_bbox)\n bbox[idx] = bbox[idx][1:]\n frame_id[idx] = frame_id[idx][1:]\n assert bbox[idx].shape[0] == predict_bbox[idx].shape[0]\n iou = []\n for i in range(len(bbox)):\n trace_iou = []\n trace_bbox = bbox[i]\n trace_predict_bbx = predict_bbox[i]\n for j in range(trace_bbox.shape[0]):\n iou_val = bbox_ious(np.ascontiguousarray(trace_bbox[j][np.newaxis, :], dtype=np.float),\n np.ascontiguousarray(trace_predict_bbx[j][np.newaxis, :], dtype=np.float))\n trace_iou.append(iou_val)\n iou.append(np.array(trace_iou))\n iou = [int(np.mean(i)*100) for i in iou]\n all_iou += iou\n bins = np.zeros(101)\n for i in all_iou:\n bins[i] += 1\n plt.bar(np.arange(101), bins)\n plt.ylabel('num')\n plt.xlabel('IoU*100')\n plt.show()","def compare_present_day_and_lgm_river_directions_with_catchments_ICE6G_plus_tarasov_style_orog_corrs_for_both(self):\n present_day_data_datetime = \"20170612_202721\"\n lgm_data_datetime = \"20170612_202559\"\n ref_filename=os.path.join(self.plots_data_dir,\n \"flowmap_ICE6g_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_tarasov\"\n \"_orog_corrs_{0}_upscaled_updated.nc\".\\\n format(present_day_data_datetime))\n data_filename=os.path.join(self.plots_data_dir,\n \"flowmap_ICE6g_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_\"\n \"tarasov_orog_corrs_{0}_upscaled_updated.nc\".\\\n format(lgm_data_datetime))\n lsmask_filename=os.path.join(self.plots_data_dir,\n \"ls_mask_ICE6g_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs\"\n \"_tarasov_orog_corrs_{0}_HD_transf.nc\".\\\n format(lgm_data_datetime))\n extra_lsmask_filename=os.path.join(self.plots_data_dir,\n \"ls_mask_ICE6g_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale\"\n \"_rdirs_tarasov_orog_corrs_{0}_HD_transf.nc\".\\\n format(present_day_data_datetime))\n ref_catchment_filename=(\"catchmentmap_ICE6g_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_\"\n \"tarasov_orog_corrs_{0}_upscaled_updated.nc\".\\\n format(present_day_data_datetime))\n data_catchment_filename=(\"catchmentmap_ICE6g_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs\"\n \"_tarasov_orog_corrs_{0}_upscaled_updated.nc\".\\\n format(lgm_data_datetime))\n ref_rdirs_filename=(\"upscaled_rdirs_ICE6g_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_\"\n \"plus_upscale_rdirs_tarasov_orog_corrs_{0}_upscaled_\"\n \"updated.nc\".format(present_day_data_datetime))\n reference_rmouth_outflows_filename=os.path.join(self.plots_data_dir,\n \"rmouthflows_ICE6g_0k_ALG4_sinkless_no_true_sinks_oceans_\"\n \"lsmask_plus_upscale_rdirs_tarasov_orog_corrs\"\n \"_{0}_upscaled_updated.nc\".\\\n format(present_day_data_datetime))\n data_rmouth_outflows_filename=os.path.join(self.plots_data_dir,\n \"rmouthflows_ICE6g_lgm_ALG4_sinkless_no_true_sinks_oceans_\"\n \"lsmask_plus_upscale_rdirs_tarasov_orog_corrs_\"\n \"{0}_upscaled_updated.nc\".\\\n format(lgm_data_datetime))\n glacier_mask_filename=os.path.join(self.orog_data_directory,\"Ice6g_c_VM5a_10min_21k.nc\")\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\n data_flowmap_filename=data_filename,\n ref_catchment_filename=\\\n ref_catchment_filename,\n data_catchment_filename=\\\n data_catchment_filename,\n ref_rdirs_filename=\\\n ref_rdirs_filename,\n data_rdirs_filename=None,\n reference_rmouth_outflows_filename=\\\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename=\\\n data_rmouth_outflows_filename,\n lsmask_filename=lsmask_filename,\n minflowcutoff=75,\n flip_data=False,\n rotate_data=True,\n flip_ref=False,\n rotate_ref=True,\n lsmask_has_same_orientation_as_ref=False,\n invert_ls_mask=True,\n first_datasource_name=\"Present day\",\n second_datasource_name=\"LGM\",\n matching_parameter_set='extensive',\n catchment_and_outflows_mods_list_filename=\\\n \"ice6g_catch_and_outflow_mods_lgm_vs_present_day.txt\",\n additional_matches_list_filename=\\\n \"ice6g_additional_matches_10min_upscaled_lgm_vs_present.txt\",\n use_single_color_for_discrepancies=True,\n use_only_one_color_for_flowmap=False,\n use_title=False,remove_antartica=True,\n difference_in_catchment_label=\"Difference\",\n rivers_to_plot=[(216,433),(117,424),(112,380),(146,327),\n (132,496),(120,176),(251,638),(115,603),\n (33,571),(34,571),(36,660),(181,256),\n (120,457),(77,365),(258,235),(167,361),\n (219,598)],\n rivers_to_plot_alt_color=[(237,393),(192,384),(169,371),\n (119,399),(72,640),(126,165),\n (87,112),(88,419),(160,237),\n (60,35),(147,552),(245,635),\n (86,460),(33,603),\n (247,243),(41,682),(185,276),\n (147,522),(244,612)],\n rivers_to_plot_secondary_alt_color=[(230,427),(170,376),\n (180,446),(143,327),\n (201,287),(136,538),\n (100,467),(116,130),\n (160,572),(32,614),\n (50,712),(210,619),\n (179,445),(212,384),\n (261,230),(85,438)],\n glacier_mask_filename=glacier_mask_filename,\n extra_lsmask_filename=extra_lsmask_filename,\n glacier_mask_grid_type='LatLong10min',\n flip_glacier_mask=True,\n rotate_glacier_mask=True,\n grid_type='HD')","def compare(self, plot=False):\n oldConditionData, newConditionData = self.runSimulations()\n \n #For now make print statements about each none matching data\n conditionsBroken=[]\n variablesFailed=[]\n for i in range(len(oldConditionData)):\n timeOld, dataListOld = oldConditionData[i]\n timeNew, dataListNew = newConditionData[i]\n\n for variableOld, variableNew in zip(dataListOld, dataListNew):\n if not curvesSimilar(timeOld.data, variableOld.data, timeNew.data, variableNew.data, 0.05):\n if i not in conditionsBroken: conditionsBroken.append(i)\n\n if variableOld.species:\n label = variableOld.species.molecule[0].toSMILES()\n print \"Species profile for {0} does not match between the old model ({1}) and \\\n the new model ({2}) in condition {3:d}.\".format(variableOld.species.molecule[0].toSMILES(),\n variableOld.label, \n variableNew.label,\n i+1)\n else:\n label = variableOld.label\n print \"{0} does not match between the old model and \\\n the new model in condition {1:d}.\".format(variableOld.label, i+1)\n\n variablesFailed.append((self.conditions[i], label, variableOld, variableNew))\n print ''\n print 'The following reaction conditions were broken:'\n print ''\n for index in conditionsBroken:\n print \"Condition {0:d}:\"\n print str(self.conditions[index])\n print ''\n\n if plot:\n # Ignore Inerts\n inertList = ['[Ar]','[He]','[N#N]','[Ne]']\n for i in range(len(oldConditionData)):\n time, dataList = oldConditionData[i]\n speciesData = [data for data in dataList if data.species.molecule[0].toSMILES() not in inertList]\n oldSpeciesPlot = SimulationPlot(xVar=time, yVar=speciesData, ylabel='Mole Fraction')\n\n time, dataList = newConditionData[i]\n speciesData = [data for data in dataList if data.species.molecule[0].toSMILES() not in inertList]\n newSpeciesPlot = SimulationPlot(xVar=time, yVar=speciesData, ylabel='Mole Fraction')\n\n # Name after the index of the condition\n # though it may be better to name it after the actual conditions in T, P, etc\n oldSpeciesPlot.comparePlot(newSpeciesPlot,filename='simulation_condition_{0}.png'.format(i+1))\n\n return variablesFailed","def compareRepeatability():\n fc,pc = refCylNoise()\n fp,pp = flatNoisePellicle()\n fcgh,pcgh = flatNoiseCGH()\n fpco,ppco = PCO1S12Noise()\n\n midfreq = [1000*np.sqrt(np.sum(p[np.logical_and(f>.1,f<1.)])) \\\n for f,p in zip([fp,fc,fcgh,fpco],[pp,pc,pcgh,ppco])]\n plt.clf()\n \n plt.loglog(fp,pp/fp[0],label='Flat+Pellicle: %.2f' % midfreq[0])\n plt.loglog(fc,pc/fc[0],label='Cylinder+CGH: % .2f' % midfreq[1])\n plt.loglog(fcgh,pcgh/fcgh[0],label='Flat+CGH: %.2f' % midfreq[2])\n plt.loglog(fpco,ppco/fpco[0],label='PCO1S12: %.2f' % midfreq[3])\n plt.title('Repeatability Comparison')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n plt.legend(loc='lower left')","def evaluate_field_diff(smdf1, smdf2, fieldname, orbitnameone, orbitnametwo, vmin=-1, vmax=1, xaxis='Latitude', save_fig_directory=None):\n logging.debug(\"Evaluating difference between 2 dataframes for field '{}'...\".format(fieldname))\n logging.debug('The difference runs from 1 -> 2, ie. {} -> {}, 2 subtract 1'.format(orbitnameone, orbitnametwo))\n logging.debug('Dataset 1: {}'.format(orbitnameone))\n logging.debug('Dataset 2: {}'.format(orbitnametwo))\n\n # Exclude NaN records (reported as fieldname = -999.0)\n frame1 = smdf1[smdf1[fieldname] != -999.0]\n frame2 = smdf2[smdf2[fieldname] != -999.0]\n\n # Print record counts\n logging.debug('Dataset 1 contains {}/{} valid datarows'.format(len(frame1.index), len(smdf1)))\n logging.debug('Dataset 2 contains {}/{} valid datarows'.format(len(frame2.index), len(smdf2)))\n\n # Get records in common\n common = pd.merge(frame1, frame2, how='inner', on=['Days', 'Seconds', 'Microseconds', 'Grid_Point_ID'])\n common.rename(columns={'Latitude_x': 'Latitude', 'Longitude_x': 'Longitude'}, inplace=True)\n common.drop('Latitude_y', axis=1, inplace=True)\n common.drop('Longitude_y', axis=1, inplace=True)\n common[fieldname+'_Diff'] = common[fieldname+'_y'] - common[fieldname+'_x']\n common.reset_index(inplace=True)\n\n # Outer merge ready for getting new records\n outer = pd.merge(frame1, frame2, how='outer', on=['Days', 'Seconds', 'Microseconds', 'Grid_Point_ID'],\n indicator=True)\n # Get records in 1 but not 2\n leftonly = outer[outer['_merge'] == 'left_only'].copy()\n leftonly.rename(columns={'Latitude_x': 'Latitude', 'Longitude_x': 'Longitude', fieldname+'_x': fieldname},\n inplace=True)\n leftonly.drop('Latitude_y', axis=1, inplace=True)\n leftonly.drop('Longitude_y', axis=1, inplace=True)\n leftonly.drop(fieldname+'_y', axis=1, inplace=True)\n leftonly.drop('_merge', axis=1, inplace=True)\n\n # Get records in 2 but not 1\n rightonly = outer[outer['_merge'] == 'right_only'].copy()\n rightonly.rename(columns={'Latitude_x': 'Latitude', 'Longitude_x': 'Longitude', fieldname+'_y': fieldname},\n inplace=True)\n rightonly.drop('Latitude_y', axis=1, inplace=True)\n rightonly.drop('Longitude_y', axis=1, inplace=True)\n rightonly.drop(fieldname+'_x', axis=1, inplace=True)\n rightonly.drop('_merge', axis=1, inplace=True)\n\n non_zero_diff = common[common[fieldname+'_Diff'] != 0]\n\n logging.debug('Dataset analysis:')\n logging.debug('{} rows common to both datasets.'.format(len(common.index)))\n logging.debug('{}/{} common rows have non-zero differences.'.format(len(non_zero_diff.index), len(common.index)))\n logging.debug('{} rows in dataset 1 only.'.format(len(leftonly.index)))\n logging.debug('{} rows in dataset 2 only.'.format(len(rightonly.index)))\n\n # Get records in common that are same/diff\n\n # Make plots only if we have differences\n if non_zero_diff.empty:\n logging.debug('No differences to plot')\n else:\n # First plot (geographic map)\n plot_sm_difference(common, orbitnameone, orbitnametwo, fieldname=fieldname+'_Diff', vmin=vmin, vmax=vmax, save_fig_directory=save_fig_directory)\n\n #fig2, ax2 = plt.subplots(1)\n ## plot each difference against the index grid point id\n #common.plot(x=xaxis, y=fieldname+'_Diff', ax=ax2, legend=False, rot=90,\n # fontsize=8, clip_on=False, style='o')\n #ax2.set_ylabel(fieldname + ' Diff')\n #ax2.axhline(y=0, linestyle=':', linewidth='0.5', color='k')\n #fig2.tight_layout()\n\n # Second plot (scatter plot, diff by lat)\n # Plot only the ones with a non-zero difference\n fig3, ax3 = plt.subplots(1)\n plt.title('{} : ({}) subtract ({})'.format(fieldname.replace('_',' '), orbitnametwo, orbitnameone), wrap=True)\n non_zero_diff.plot(x=xaxis, y=fieldname+'_Diff', ax=ax3, legend=False,\n rot=90, fontsize=8, clip_on=False, style='o')\n ax3.axhline(y=0, linestyle=':', linewidth='0.5', color='k')\n ax3.set_ylabel(fieldname + ' Diff')\n fig3.tight_layout()\n\n if (save_fig_directory != None):\n # Requested to save the figure\n save_name = 'diff-scatter-({})-subtr-({})-field-({})-{}.png'.format(orbitnametwo, orbitnameone, fieldname.replace(' ', ''), datetime.now().strftime('%Y%m%d-%H%M%S'))\n logging.debug('Attempting to save figure with name \"{}\"'.format(save_name))\n plt.savefig(os.path.join(save_fig_directory, save_name))\n plt.close()\n else:\n plt.show()","def notebook_01():\n\n freq_list, volt_list = las.load_freq_volt()\n\n n_steps, n_det, n_f, _ = np.shape(volt_list)\n\n #y_sym_mat_o = ds.by_sym_mat(volt_list, det_ind=0)\n #y_sym_mat_i = ds.by_sym_mat(volt_list, det_ind=1)\n\n # print(np.shape(y_sym_mat_o))\n # print(np.shape(y_sym_mat_i))\n # (mu_o, sigma_o) = stats.norm.fit(y_sym_mat_o[:,0])\n # (mu_i, sigma_i) = stats.norm.fit(y_sym_mat_i[:,0])\n # print(mu_o, sigma_o)\n # print(mu_i, sigma_i)\n # print(mu_o*89000, mu_i*89000.0, -mu_i*89000.0, -mu_o*89000.0)\n\n volt_list_sym = ds.volt_list_sym_calc(volt_list)\n\n fit_params_mat = fp.fit_params(ff.f_b_field, volt_list_sym)\n\n fit_params_mat_s = fp.fit_params(ff.f_b_field_off, volt_list_sym)\n\n # pbd.plot_bare_signal_and_fit_norm_shifted(0, volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\n\n # pfp.plot_fit_sym_comp(volt_list_sym, fit_params_mat, fit_params_mat_s, freq_list)\n\n\n # pfp.plot_fit_sym_comp_2(volt_list_sym, fit_params_mat_s, freq_list)\n\n #pfp.plot_symmetry_along_z(volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\n\n fp.fit_params_FH_data(ff.f_b_field)\n\n # pbd.plot_rel_diff_bare_signal_and_fit_norm_shifted(0, volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)","def main():\n print(\"Program version: 1.5\")\n StartTime = datetime.now()\n args = parseArguments()\n\n verbose = args.verbose\n images = args.images\n ignore_warnings = args.ignore_warnings\n if(args.silent):\n verbose = False\n images = False\n ignore_warnings = True\n\n if(args.images):\n plt.ioff()\n\n if(args.ignore_warnings):\n warnings.simplefilter('ignore', UserWarning)\n\n #sample header keywords\n # OBJECT = 'P016+03_P1_JKdeep' / Original target\n # RA = ' 01:06:37.759' / 01:06:37.7 RA (J2000) pointing\n # DEC = ' 03:32:36.096' / 03:32:36.0 DEC (J2000) pointing\n # EQUINOX = 2000. / Standard FK5 (years)\n # RADECSYS= 'FK5 ' / Coordinate reference frame\n # CRVAL1 = 16.65733 / 01:06:37.7, RA at ref pixel\n # CRVAL2 = 3.54336 / 03:32:36.0, DEC at ref pixel\n # CRPIX1 = 447. /Ref pixel in X\n # CRPIX2 = 452. / Ref pixel in Y\n # CDELT1 = -8.0000000000000E-5 / SS arcsec per pixel in RA\n # CDELT2 = 8.00000000000003E-5 / SS arcsec per pixel in DEC\n # CTYPE1 = 'RA---TAN' / pixel coordinate system\n # CTYPE2 = 'DEC--TAN' / pixel coordinate system\n # PC1_1 = 0.000000 / Translation matrix element\n # PC1_2 = 1.000000 / Translation matrix element\n # PC2_1 = -1.000000 / Translation matrix element\n # PC2_2 = 0.000000 / Translation matrix element\n\n fits_image_filenames = args.input\n\n #if directory given search for appropriate fits files\n\n if(os.path.isdir(fits_image_filenames[0])):\n print(\"detected a directory. Will search for fits files in it\")\n path = fits_image_filenames[0]\n fits_image_filenames = []\n for file in os.listdir(path):\n if file.endswith(\".fits\") and \"_astro\" not in file:\n fits_image_filenames.append(path+\"/\"+file)\n print(fits_image_filenames)\n\n multiple = False\n if(len(fits_image_filenames)>1):\n multiple = True\n not_converged = []\n converged_counter = 0\n for fits_image_filename in fits_image_filenames:\n\n result,_ = astrometry_script(fits_image_filename, catalog=args.catalog, rotation_scaling=0, xy_transformation=args.xy_transformation, fine_transformation=args.fine_transformation,\n images=images, vignette=args.vignette,vignette_rectangular=args.vignette_rectangular, cutouts=args.cutout, ra=args.ra, dec=args.dec, projection_ra=args.projection_ra, projection_dec=args.projection_dec, verbose=verbose, save_images=args.save_images, ignore_header_rot=args.ignore_header_rot, radius = args.radius, save_bad_result=args.save_bad_result, silent =args.silent, sigma_threshold_for_source_detection= args.sigma_threshold_for_source_detection, high_res=args.high_resolution, hdul_idx=args.hdul_idx, filename_for_sources=args.filename_for_sources, FWHM=args.seeing)\n\n if((not result) and args.rotation_scaling):\n print(\"Did not converge. Will try again with full rotation and scaling\")\n result, _ = astrometry_script(fits_image_filename, catalog=args.catalog, rotation_scaling=args.rotation_scaling, xy_transformation=args.xy_transformation, fine_transformation=args.fine_transformation,\n images=images, vignette=args.vignette,vignette_rectangular=args.vignette_rectangular, cutouts=args.cutout, ra=args.ra, dec=args.dec, projection_ra=args.projection_ra, projection_dec=args.projection_dec, verbose=verbose, save_images=args.save_images, ignore_header_rot=args.ignore_header_rot, radius = args.radius, save_bad_result=args.save_bad_result, silent=args.silent, sigma_threshold_for_source_detection=args.sigma_threshold_for_source_detection, high_res=args.high_resolution, hdul_idx=args.hdul_idx, filename_for_sources=args.filename_for_sources, FWHM=args.seeing)\n\n if(result):\n print(\"Astrometry was determined to be good.\")\n converged_counter = converged_counter+1\n else:\n print(\"Astrometry was determined to be bad.\")\n not_converged.append(fits_image_filename)\n if(args.save_bad_result):\n print(\"Result was saved anyway\")\n else:\n print(\"Result was not saved.\")\n # print(\"\")\n # print(\">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\")\n # print(\"> Astrometry for {} \".format(fits_image_filename))\n #\n # with fits.open(fits_image_filename) as hdul:\n # #print(hdul.info())\n # if(args.verbose):\n # print(\"if image is not at first position in the fits file the program will break later on\")\n # #print(hdul[0].header)\n #\n # hdu = hdul[0]\n # #hdu.verify('fix')\n # hdr = hdu.header\n #\n #\n # image_or = hdul[0].data.astype(float)\n # median = np.nanmedian(image_or)\n # image_or[np.isnan(image_or)]=median\n # image = image_or - median\n #\n # observation = find_sources(image, args.vignette)\n # #print(observation)\n #\n # positions = (observation['xcenter'], observation['ycenter'])\n # apertures = CircularAperture(positions, r=4.)\n #\n #\n # #world coordinates\n # print(\">Info found in the file -- (CRVAl: position of central pixel (CRPIX) on the sky)\")\n # print(WCS(hdr))\n #\n # hdr[\"NAXIS1\"] = image.shape[0]\n # hdr[\"NAXIS2\"] = image.shape[1]\n #\n # #wcsprm = Wcsprm(hdr.tostring().encode('utf-8')) #everything else gave me errors with python 3, seemed to make problems with pc conversios, so i wwitched to the form below\n # wcsprm = WCS(hdr).wcs\n # wcsprm_original = WCS(hdr).wcs\n # if(args.verbose):\n # print(WCS(wcsprm.to_header()))\n # wcsprm, fov_radius, INCREASE_FOV_FLAG, PIXSCALE_UNCLEAR = read_additional_info_from_header(wcsprm, hdr, args.ra, args.dec, args.projection_ra, args.projection_dec)\n # if(args.verbose):\n # print(WCS(wcsprm.to_header()))\n #\n # #print(wcsprm)\n # #wcsprm.pc = [[2, 0],[0,1]]\n #\n #\n # #Possibly usefull examples of how to use wcsprm:\n # #print(wcsprm.set())\n # #print(wcsprm.get_pc())\n # #pc = wcsprm.get_pc()\n # #print(np.linalg.det(pc))\n # #print(wcsprm.get_cdelt())\n # #wcs.fix()\n # #print(wcsprm.print_contents())\n # #print(repr(hdr.update(wcsprm.to_header().encode('utf-8')))) #not working\n #\n # #hdu.verify(\"fix\")\n # #print(repr(hdr))\n # #wcs.wcs_pix2world(pixcrd, 1)\n # #wcs.wcs_world2pix(world, 1)\n # #wcs.wcs.crpix = [-234.75, 8.3393]\n # # wcs.wcs.cdelt = np.array([-0.066667, 0.066667])\n # # wcs.wcs.crval = [0, -90]\n # # wcs.wcs.ctype = [\"RA---AIR\", \"DEC--AIR\"]\n # # wcs.wcs.set_pv([(2, 1, 45.0)])\n # # For historical compatibility, three alternate specifications of the linear transformations\n # # are available in wcslib. The canonical PCi_ja with CDELTia, CDi_ja, and the deprecated CROTAia\n # # keywords. Although the latter may not formally co-exist with PCi_ja,\n # # the approach here is simply to ignore them if given in conjunction with PCi_ja.\n # # has_pc, has_cd and has_crota can be used to determine which of these alternatives are present in the header.\n # # These alternate specifications of the linear transformation matrix are translated immediately to PCi_ja by set\n # # and are nowhere visible to the lower-level routines. In particular, set resets cdelt to unity if CDi_ja is present\n # # (and no PCi_ja). If no CROTAia is associated with the latitude axis, set reverts to a unity PCi_ja matrix.\n #\n #\n #\n #\n #\n # #get rough coordinates\n # #print(hdr[\"RA\"])\n # #coord = SkyCoord(hdr[\"RA\"], hdr[\"DEC\"], unit=(u.hourangle, u.deg), frame=\"icrs\")\n # coord = SkyCoord(wcsprm.crval[0], wcsprm.crval[1], unit=(u.deg, u.deg), frame=\"icrs\")\n # if(not PIXSCALE_UNCLEAR):\n # if(wcsprm.crpix[0] < 0 or wcsprm.crpix[1] < 0 or wcsprm.crpix[0] > image.shape[0] or wcsprm.crpix[1] > image.shape[1] ):\n # print(\"central value outside of the image, moving it to the center\")\n # coord_radec = wcsprm.p2s([[image.shape[0]/2, image.shape[1]/2]], 0)[\"world\"][0]\n # coord = SkyCoord(coord_radec[0], coord_radec[1], unit=(u.deg, u.deg), frame=\"icrs\")\n # #print(wcsprm)\n #\n #\n #\n # #better: put in nice wrapper! with repeated tries and maybe try synchron!\n # print(\">Dowloading catalog data\")\n # radius = u.Quantity(fov_radius, u.arcmin)#will prob need more\n # catalog_data = query.get_data(coord, radius, args.catalog)\n # #reference = reference.query(\"mag <20\")\n # max_sources = 500\n # if(INCREASE_FOV_FLAG):\n # max_sources= max_sources*2.25 #1.5 times the radius, so 2.25 the area\n # if(catalog_data.shape[0]>max_sources):\n # catalog_data = catalog_data.nsmallest(400, \"mag\")\n #\n # if(args.catalog == \"GAIA\" and catalog_data.shape[0] < 5):\n # print(\"GAIA seems to not have enough objects, will enhance with PS1\")\n # catalog_data2 = query.get_data(coord, radius, \"PS\")\n # catalog_data = pd.concat([catalog_data, catalog_data2])\n # #apertures_catalog = CircularAperture(wcs.wcs_world2pix(catalog_data[[\"ra\", \"dec\"]], 1), r=5.)\n # print(\"Now we have a total of {} sources. Keep in mind that there might be duplicates now since we combined 2 catalogs\".format(catalog_data.shape[0]))\n # elif(args.catalog == \"PS\" and (catalog_data is None or catalog_data.shape[0] < 5)):\n # print(\"We seem to be outside the PS footprint, enhance with GAIA data\")\n # catalog_data2 = query.get_data(coord, radius, \"GAIA\")\n # catalog_data = pd.concat([catalog_data, catalog_data2])\n # #apertures_catalog = CircularAperture(wcs.wcs_world2pix(catalog_data[[\"ra\", \"dec\"]], 1), r=5.)\n # print(\"Now we have a total of {} sources. Keep in mind that there might be duplicates now since we combined 2 catalogs\".format(catalog_data.shape[0]))\n #\n # #remove duplicates in catalog?\n #\n # apertures_catalog = CircularAperture(wcsprm.s2p(catalog_data[[\"ra\", \"dec\"]], 1)['pixcrd'], r=5.)\n #\n #\n # #plotting what we have, I keep it in the detector field, world coordinates are more painfull to plot\n # if(args.images):\n # fig = plt.figure()\n # fig.canvas.set_window_title('Input for {}'.format(fits_image_filename))\n # plt.xlabel(\"pixel x direction\")\n # plt.ylabel(\"pixel y direction\")\n # plt.title(\"Input - red: catalog sources, blue: detected sources in img\")\n # plt.imshow(image,cmap='Greys', origin='lower', norm=LogNorm())\n # apertures.plot(color='blue', lw=1.5, alpha=0.5)\n # apertures_catalog.plot(color='red', lw=1.5, alpha=0.5)\n #\n # plt.xlim(-200,image.shape[0]+200)\n # plt.ylim(-200,image.shape[1]+200)\n # if(args.save_images):\n # name_parts = fits_image_filename.rsplit('.', 1)\n # plt.savefig(name_parts[0]+\"_image_before.pdf\")\n #\n # ###tranforming to match the sources\n # print(\"---------------------------------\")\n # print(\">Finding the transformation\")\n # if(args.rotation_scaling):\n # print(\"Finding scaling and rotation\")\n # wcsprm = register.get_scaling_and_rotation(observation, catalog_data, wcsprm, scale_guessed=PIXSCALE_UNCLEAR, verbose=args.verbose)\n # if(args.xy_transformation):\n # print(\"Finding offset\")\n # wcsprm,_,_ = register.offset_with_orientation(observation, catalog_data, wcsprm, fast=False , INCREASE_FOV_FLAG=INCREASE_FOV_FLAG, verbose= args.verbose)\n #\n # #correct subpixel error\n # obs_x, obs_y, cat_x, cat_y, distances = register.find_matches(observation, catalog_data, wcsprm, threshold=3)\n # rms = np.sqrt(np.mean(np.square(distances)))\n # best_score = len(obs_x)/(rms+10) #start with current best score\n # fine_transformation = False\n # if(args.fine_transformation):\n # for i in [2,3,5,8,10,6,4, 20,2,1,0.5]:\n # wcsprm_new, score = register.fine_transformation(observation, catalog_data, wcsprm, threshold=i)\n # if(score> best_score):\n # wcsprm = wcsprm_new\n # best_score = score\n # fine_transformation = True\n # if not fine_transformation:\n # print(\"Fine transformation did not improve result so will be discarded.\")\n # else:\n # print(\"Fine transformation applied to improve result\")\n # #register.calculate_rms(observation, catalog_data,wcs)\n #\n # #make wcsprim more physical by moving scaling to cdelt, out of the pc matrix\n # wcs =WCS(wcsprm.to_header())\n # if(args.verbose):\n # print(wcs)\n #\n # from astropy.wcs import utils\n # scales = utils.proj_plane_pixel_scales(wcs)\n # print(scales)\n # cdelt = wcsprm.get_cdelt()\n # print(cdelt)\n # scale_ratio = scales/cdelt\n # #print(scale_ratio)\n # pc = np.array(wcsprm.get_pc())\n # pc[0,0] = pc[0,0]/scale_ratio[0]\n # pc[1,0] = pc[1,0]/scale_ratio[1]\n # pc[0,1] = pc[0,1]/scale_ratio[0]\n # pc[1,1] = pc[1,1]/scale_ratio[1]\n # wcsprm.pc = pc\n # wcsprm.cdelt = scales\n # if(args.verbose):\n # print(\"moved scaling info to CDelt\")\n # print(WCS(wcsprm.to_header()))\n #\n # #WCS difference before and after\n # print(\"> Compared to the input the Wcs was changed by: \")\n # scales_original = utils.proj_plane_pixel_scales(WCS(hdr))\n # print(\"WCS got scaled by {} in x direction and {} in y direction\".format(scales[0]/scales_original[0], scales[1]/scales_original[1]))\n # #sources:\n # #https://math.stackexchange.com/questions/2113634/comparing-two-rotation-matrices\n # #https://stackoverflow.com/questions/2827393/angles-between-two-n-dimensional-vectors-in-python/13849249#13849249\n # def unit_vector(vector):\n # \"\"\" Returns the unit vector of the vector. \"\"\"\n # return vector / max(np.linalg.norm(vector), 1e-10)\n # def matrix_angle( B, A ):\n # \"\"\" comment cos between vectors or matrices \"\"\"\n # Aflat = A.reshape(-1)\n # Aflat = unit_vector(Aflat)\n # Bflat = B.reshape(-1)\n # Bflat = unit_vector(Bflat)\n # #return np.arccos((np.dot( Aflat, Bflat ) / max( np.linalg.norm(Aflat) * np.linalg.norm(Bflat), 1e-10 )))\n # return np.arccos(np.clip(np.dot(Aflat, Bflat), -1.0, 1.0))\n # #print(matrix_angle(wcsprm.get_pc(), wcsprm_original.get_pc()) /2/np.pi*360)\n # rotation_angle = matrix_angle(wcsprm.get_pc(), wcsprm_original.get_pc()) /2/np.pi*360\n # if((wcsprm.get_pc() @ wcsprm_original.get_pc() )[0,1] > 0):\n # text = \"counterclockwise\"\n # else:\n # text = \"clockwise\"\n # print(\"Rotation of WCS by an angle of {} deg \".format(rotation_angle)+text)\n # old_central_pixel = wcsprm_original.s2p([wcsprm.crval], 0)[\"pixcrd\"][0]\n # print(\"x offset: {} px, y offset: {} px \".format(wcsprm.crpix[0]- old_central_pixel[0], wcsprm.crpix[1]- old_central_pixel[1]))\n #\n #\n # #check final figure\n # if(args.images):\n # fig = plt.figure()\n # fig.canvas.set_window_title('Result for {}'.format(fits_image_filename))\n # plt.xlabel(\"pixel x direction\")\n # plt.ylabel(\"pixel y direction\")\n # plt.title(\"Result - red: catalog sources, blue: detected sources in img\")\n # plt.imshow(image,cmap='Greys', origin='lower', norm=LogNorm())\n # apertures.plot(color='blue', lw=1.5, alpha=0.5)\n # #apertures_catalog = CircularAperture(wcs.wcs_world2pix(catalog_data[[\"ra\", \"dec\"]], 1), r=5.)\n # apertures_catalog = CircularAperture(wcsprm.s2p(catalog_data[[\"ra\", \"dec\"]], 1)['pixcrd'], r=5.)\n #\n # apertures_catalog.plot(color='red', lw=1.5, alpha=0.5)\n # if(args.save_images):\n # name_parts = fits_image_filename.rsplit('.', 1)\n # plt.savefig(name_parts[0]+\"_image_after.pdf\")\n #\n # print(\"--- Evaluate how good the transformation is ----\")\n # register.calculate_rms(observation, catalog_data,wcsprm)\n #\n #\n # #updating file\n # write_wcs_to_hdr(fits_image_filename, wcsprm)\n #\n #\n # print(\"overall time taken\")\n # print(datetime.now()-StartTime)\n # if(args.images):\n # plt.show()\n if(multiple):\n print(\">> Final report:\")\n print(\"Processed {} files, {} of them did converge. The following files failed:\".format(len(fits_image_filenames), converged_counter))\n print(not_converged)\n print(\"-- finished --\")","def compare_present_day_and_lgm_river_directions_with_catchments_ICE5G_plus_tarasov_style_orog_corrs_for_both(self):\n present_day_data_datetime = \"20170521_002051\"\n lgm_data_datetime = \"20170521_151723\"\n ref_filename=os.path.join(self.plots_data_dir,\n \"flowmap_ICE5G_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_tarasov\"\n \"_orog_corrs_generation_and_upscaling_{0}_upscaled_updated.nc\".\\\n format(present_day_data_datetime))\n data_filename=os.path.join(self.plots_data_dir,\n \"flowmap_ICE5G_21k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_\"\n \"tarasov_orog_corrs_generation_and_upscaling_{0}_upscaled_updated.nc\".\\\n format(lgm_data_datetime))\n lsmask_filename=os.path.join(self.plots_data_dir,\n \"ls_mask_ICE5G_21k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs\"\n \"_tarasov_orog_corrs_generation_and_upscaling_{0}_HD_transf.dat\".\\\n format(lgm_data_datetime))\n ref_catchment_filename=(\"catchmentmap_ICE5G_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_\"\n \"tarasov_orog_corrs_generation_and_upscaling_{0}_upscaled_updated.nc\".\\\n format(present_day_data_datetime))\n data_catchment_filename=(\"catchmentmap_ICE5G_21k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs\"\n \"_tarasov_orog_corrs_generation_and_upscaling_{0}_upscaled_updated.nc\".\\\n format(lgm_data_datetime))\n ref_rdirs_filename=(\"upscaled_rdirs_ICE5G_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_\"\n \"plus_upscale_rdirs_tarasov_orog_corrs_generation_and_upscaling_{0}_upscaled_\"\n \"updated_transf.dat\".format(present_day_data_datetime))\n reference_rmouth_outflows_filename=os.path.join(self.plots_data_dir,\n \"rmouthflows_ICE5G_0k_ALG4_sinkless_no_true_sinks_oceans_\"\n \"lsmask_plus_upscale_rdirs_tarasov_orog_corrs\"\n \"_generation_and_upscaling_{0}_upscaled_updated.nc\".\\\n format(present_day_data_datetime))\n data_rmouth_outflows_filename=os.path.join(self.plots_data_dir,\n \"rmouthflows_ICE5G_21k_ALG4_sinkless_no_true_sinks_oceans_\"\n \"lsmask_plus_upscale_rdirs_tarasov_orog_corrs_\"\n \"generation_and_upscaling_{0}_upscaled_updated.nc\".\\\n format(lgm_data_datetime))\n glacier_mask_filename=os.path.join(self.orog_data_directory,\"ice5g_v1_2_21_0k_10min.nc\")\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\n data_flowmap_filename=data_filename,\n ref_catchment_filename=\\\n ref_catchment_filename,\n data_catchment_filename=\\\n data_catchment_filename,\n ref_rdirs_filename=\\\n ref_rdirs_filename,\n data_rdirs_filename=None,\n reference_rmouth_outflows_filename=\\\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename=\\\n data_rmouth_outflows_filename,\n lsmask_filename=lsmask_filename,\n minflowcutoff=100,\n flip_data=False,\n rotate_data=True,\n flip_ref=False,\n rotate_ref=True,\n lsmask_has_same_orientation_as_ref=False,\n invert_ls_mask=True,\n first_datasource_name=\"Present day\",\n second_datasource_name=\"LGM\",\n matching_parameter_set='extensive',\n catchment_and_outflows_mods_list_filename=\\\n \"catch_and_outflow_mods_lgm_vs_present_day.txt\",\n additional_matches_list_filename=\\\n \"additional_matches_10min_upscaled_lgm_vs_present.txt\",\n use_single_color_for_discrepancies=True,\n use_only_one_color_for_flowmap=False,\n use_title=False,remove_antartica=True,\n difference_in_catchment_label=\"Difference\",\n glacier_mask_filename=glacier_mask_filename,\n glacier_mask_grid_type='LatLong10min',\n flip_glacier_mask=True,\n rotate_glacier_mask=True,\n grid_type='HD')","def test_vis_calc():\n\n ant1_enu = np.array([0, 0, 0])\n ant2_enu = np.array([0.0, 14.6, 0])\n\n bl = observatory.Baseline(ant1_enu, ant2_enu)\n\n freqs = np.array([1e8])\n nfreqs = 1\n\n fov = 20 # Deg\n\n # Longitude/Latitude in degrees.\n\n nside = 32\n ind = 10\n center = list(hp.pix2ang(nside, ind, lonlat=True))\n centers = [center]\n npix = nside ** 2 * 12\n shell = np.zeros((npix, nfreqs))\n pix_area = 4 * np.pi / float(npix)\n shell[ind] = 1 # Jy/pix\n shell[ind] *= utils.jy2Tsr(freqs[0], bm=pix_area) # K\n\n obs = observatory.Observatory(latitude, longitude, array=[bl], freqs=freqs)\n obs.pointing_centers = centers\n obs.times_jd = np.array([1])\n obs.set_fov(fov)\n obs.set_beam(\"uniform\")\n\n sky = sky_model.SkyModel(Nside=nside, freqs=freqs, data=shell[np.newaxis, :, :])\n\n visibs, times, bls = obs.make_visibilities(sky)\n assert np.isclose(np.real(visibs), 1.0).all() # Unit point source at zenith","def test_compare_blackrockio_with_matlabloader_v21(self):\n\n dirname = self.get_local_path('blackrock/blackrock_2_1/l101210-001')\n # First run with parameters for ns5, then run with correct parameters for ns2\n parameters = [('blackrock/blackrock_2_1/l101210-001_nev-02_ns5.mat',\n {'nsx_to_load': 5, 'nev_override': '-'.join([dirname, '02'])}, 96),\n ('blackrock/blackrock_2_1/l101210-001.mat', {'nsx_to_load': 2}, 6)]\n for param in parameters:\n # Load data from Matlab generated files\n ml = scipy.io.loadmat(self.get_local_path(param[0]))\n lfp_ml = ml['lfp'] # (channel x time) LFP matrix\n ts_ml = ml['ts'] # spike time stamps\n elec_ml = ml['el'] # spike electrodes\n unit_ml = ml['un'] # spike unit IDs\n wf_ml = ml['wf'] # waveforms\n mts_ml = ml['mts'] # marker time stamps\n mid_ml = ml['mid'] # marker IDs\n\n # Load data from original data files using the Neo BlackrockIO\n reader = BlackrockRawIO(dirname, **param[1])\n reader.parse_header()\n\n # Check if analog data are equal\n stream_index = 0\n self.assertGreater(reader.signal_channels_count(stream_index), 0)\n\n for c in range(0, param[2]):\n raw_sigs = reader.get_analogsignal_chunk(channel_indexes=[c])\n raw_sigs = raw_sigs.flatten()\n assert_equal(raw_sigs[:], lfp_ml[c, :])\n\n # Check if spikes in channels are equal\n nb_unit = reader.spike_channels_count()\n for spike_channel_index in range(nb_unit):\n unit_name = reader.header['spike_channels'][spike_channel_index]['name']\n # name is chXX#YY where XX is channel_id and YY is unit_id\n channel_id, unit_id = unit_name.split('#')\n channel_id = int(channel_id.replace('ch', ''))\n unit_id = int(unit_id)\n\n matlab_spikes = ts_ml[(elec_ml == channel_id) & (unit_ml == unit_id)]\n\n io_spikes = reader.get_spike_timestamps(spike_channel_index=spike_channel_index)\n assert_equal(io_spikes, matlab_spikes)\n\n # Check all waveforms\n io_waveforms = reader.get_spike_raw_waveforms(\n spike_channel_index=spike_channel_index)\n io_waveforms = io_waveforms[:, 0, :] # remove dim 1\n matlab_wf = wf_ml[np.nonzero(\n np.logical_and(elec_ml == channel_id, unit_ml == unit_id)), :][0]\n assert_equal(io_waveforms, matlab_wf)\n\n # Check if digital input port events are equal\n nb_ev_chan = reader.event_channels_count()\n # ~ print(reader.header['event_channels'])\n for ev_chan in range(nb_ev_chan):\n name = reader.header['event_channels']['name'][ev_chan]\n # ~ print(name)\n if name == 'digital_input_port':\n all_timestamps, _, labels = reader.get_event_timestamps(\n event_channel_index=ev_chan)\n\n for label in np.unique(labels):\n python_digievents = all_timestamps[labels == label]\n matlab_digievents = mts_ml[mid_ml == int(label)]\n assert_equal(python_digievents, matlab_digievents)","def test_tastis_output_linearaxis1(self, capsys):\n\n self.get_data(\"input\", \"od3v01bfq_raw.fits\")\n self.get_data(\"input\", \"od3v01bfq_spt.fits\")\n\n capsys.readouterr()\n\n tastis('od3v01bfq_raw.fits')\n\n captured = capsys.readouterr()\n assert captured.out == \"===============================================================================\\n\" \\\n \"od3v01bfq HST/STIS MIRVIS 52X0.05 ACQ/PEAK-UP\\n\" \\\n \"prop: 14493 visit: 01 line: 5 target: 2MASS-J23062928-0502285\\n\" \\\n \"obs date, time: 2016-09-26 04:17:57 exposure time: 10.00\\n\" \\\n \"dom GS/FGS: SB5F000135F1 sub-dom GS/FGS: SB5F000156F2\\n\" \\\n \"ACQ params: bias sub: 1510 method: MAX-FLUX-CENTROID\\n\" \\\n \"subarray (axis1,axis2): size=(32,32) corner=(521,500)\\n\" \\\n \"-------------------------------------------------------------------------------\\n\" \\\n \"Scan type: LINEARAXIS1 Step size (mas): 26\\n\" \\\n \"\\n\" \\\n \" [ 0 848 3069 3432 1912 555 228]\\n\" \\\n \"\\n\" \\\n \" axis1 axis2 axis1 axis2 V2 V3\\n\" \\\n \" (pixels) (arcsec) (arcsec)\\n\" \\\n \"Estimated slew: -0.2 0.0 -0.010 0.000 -0.007 -0.007\\n\" \\\n \"Flux in post-slew confirmation image (40210) - Pedestal (35982) = 4228 DN\\n\" \\\n \"-------------------------------------------------------------------------------\\n\" \\\n \"The confirmation image has a flux between 0.8 and 2.0 times the\\n\" \\\n \"maximum flux in the peakup, which is typical of a successful ACQ/PEAK.\\n\" \\\n \"===============================================================================\\n\"","def _check_xyz_output(self, cwd):\n\n for ii, refname in enumerate(self.files):\n if self.forms[ii] == \"xyz\":\n ref_structs = []\n try:\n with open(Path(cwd) / refname) as ref:\n ref_natoms = int(ref.readline())\n for s, ll in enumerate(ref.readlines()):\n if (s + 1) % (ref_natoms + 2) != 0 and (s + 1) % (\n ref_natoms + 2\n ) != 1:\n ref_structs.append(ll.split()[1:])\n reff = [[float(v) for v in r] for r in ref_structs]\n ref_xyz = np.array(reff)\n except IOError:\n raise IOError(\n \"Please provide a reference file named {} in {}\".format(\n refname, str((self.parent / cwd).absolute())\n )\n )\n\n except ValueError:\n raise ValueError(\n \"Please check the values for the file named {} in {}\".format(\n refname, str((self.parent / cwd).absolute())\n )\n )\n\n fname = refname[4:]\n structs = []\n with open(self.tmp_dir / fname) as f:\n natoms = int(f.readline())\n for s, ll in enumerate(f.readlines()):\n if (s + 1) % (natoms + 2) != 0 and (s + 1) % (natoms + 2) != 1:\n structs.append(ll.split()[1:])\n testt = [[float(v) for v in r] for r in structs]\n test_xyz = np.array(testt)\n\n try:\n np.testing.assert_allclose(\n test_xyz, ref_xyz, rtol=1.0e-7, atol=1.0e-8\n )\n # print(\"No anomaly during the regtest for {}\".format(refname))\n except AssertionError:\n raise AssertionError(\n \"ANOMALY: {} in {}\".format(\n fname,\n str((self.parent / cwd).absolute()).split(\"ipi_tests/\", 1)[\n 1\n ],\n )\n )","def compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_original_ts(self):\n ref_base_dir = (\"/Users/thomasriddick/Documents/data/lake_analysis_runs\"\n \"/lake_analysis_one_21_Jun_2021\")\n data_base_dir = (\"/Users/thomasriddick/Documents/data/lake_analysis_runs/\"\n \"lake_analysis_two_26_Mar_2022\")\n ref_filename=os.path.join(ref_base_dir,\n \"rivers/results/default_orog_corrs/diag_version_29_date_0_original_truesinks\",\n \"30min_flowtocell.nc\")\n data_filename=os.path.join(data_base_dir,\n \"rivers/results/diag_version_0_date_0_original_truesinks\",\n \"30min_flowtocell.nc\")\n lsmask_filename=os.path.join(self.plots_data_dir,\n \"ls_mask_extract_ls_mask_from_corrected_HD_rdirs_20160504_142435.nc\")\n ref_catchment_filename=os.path.join(ref_base_dir,\n \"rivers/results/default_orog_corrs/diag_version_29_date_0_original_truesinks\",\n \"30min_catchments.nc\")\n data_catchment_filename=os.path.join(data_base_dir,\n \"rivers/results/diag_version_0_date_0_original_truesinks\",\n \"30min_catchments.nc\")\n ref_rdirs_filename=os.path.join(ref_base_dir,\n \"rivers/results/default_orog_corrs/\"\n \"diag_version_29_date_0_original_truesinks\",\n \"30min_rdirs.nc\")\n reference_rmouth_outflows_filename=os.path.join(ref_base_dir,\n \"rivers/results/default_orog_corrs/\"\n \"diag_version_29_date_0_original_truesinks\",\n \"30min_rmouth_flowtocell.nc\")\n data_rmouth_outflows_filename=os.path.join(data_base_dir,\n \"rivers/results/diag_version_0_date_0_original_truesinks\",\n \"30min_rmouth_flowtocell.nc\")\n #glacier_mask_filename=os.path.join(self.orog_data_directory,\"ice5g_v1_2_21_0k_10min.nc\")\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\n data_flowmap_filename=data_filename,\n ref_catchment_filename=\\\n ref_catchment_filename,\n data_catchment_filename=\\\n data_catchment_filename,\n ref_rdirs_filename=\\\n ref_rdirs_filename,\n data_rdirs_filename=None,\n reference_rmouth_outflows_filename=\\\n reference_rmouth_outflows_filename,\n data_rmouth_outflows_filename=\\\n data_rmouth_outflows_filename,\n lsmask_filename=lsmask_filename,\n minflowcutoff=80,\n flip_data=False,\n rotate_data=False,\n flip_ref=False,\n rotate_ref=False,\n lsmask_has_same_orientation_as_ref=False,\n flip_lsmask=False,rotate_lsmask=False,\n invert_ls_mask=False,\n first_datasource_name=\"old\",\n second_datasource_name=\"MERIT derived\",\n matching_parameter_set='default',\n catchment_and_outflows_mods_list_filename=\\\n None,\n #additional_matches_list_filename=\\\n #\"additional_matches_ice6g_vs_ice5g_lgm.txt\",\n use_single_color_for_discrepancies=True,\n use_only_one_color_for_flowmap=False,\n use_title=False,remove_antartica=True,\n difference_in_catchment_label=\"Difference\",\n grid_type='HD')","def completeness(input_sources_cat,detected_sources_cat,output_fname,cat_falsedet,Mag_lim,pix_radius):\n\n #Load catalogues in table\n input_cat=ascii.read('%s.txt' % input_sources_cat)\n detected_cat=ascii.read('%s.cat' % detected_sources_cat) \n #print (input_cat)\n #print (detected_cat)\n print ('Number of sources in stuff catalog below the mag lim of %.2f: %d' % (Mag_lim,len(input_cat[input_cat['MAG']<Mag_lim])))\n print ('Number of sources detected: %d \\n' % len(detected_cat))\n\n #Pixel radius\n pixradius=pix_radius\n\n nb=0\n i=0\n det=np.zeros(len(input_cat))\n x_det_list=np.zeros(len(input_cat))\n y_det_list=np.zeros(len(input_cat))\n mag_sex=np.zeros(len(input_cat))\n\n col_det=Column(name='detected',data=det)\n x_det_coord=Column(name='x_coord_det',data=x_det_list)\n y_det_coord=Column(name='y_coord_det',data=y_det_list)\n mag_det=Column(name='mag_det',data=mag_sex)\n input_cat.add_columns([col_det,x_det_coord,y_det_coord,mag_det])\n\n col_det_sex=Column(name='detected',data=np.zeros(len(detected_cat)))\n detected_cat.add_columns([col_det_sex])\n\n\n for x1, y1 in zip (detected_cat['XPEAK_IMAGE'], detected_cat['YPEAK_IMAGE']):\n #print ('object n. {0:d} at position: {1:.2f}-{2:.2f} \\n'.format(nb,x1,y1))\n min_dist=1e40\n j=0\n x_det=-1;y_det=-1;\n for x2,y2,mag in zip(input_cat['COORD_XPIXEL'],input_cat['COORD_YPIXEL'],input_cat['MAG']):\n if detected_cat['detected'][i]==0 and x1 >= int(x2)-pixradius and x1 <= int(x2)+pixradius and y1 >= int(y2)-pixradius and y1 <= int(y2)+pixradius:\n #Test the minimum distance\n dist=(x2-x1)**2+(y2-y1)**2\n if dist < min_dist:# and detected_cat['MAG_AUTO'][i] > 0.9*mag and detected_cat['MAG_AUTO'][i] < 1.1*mag:\n min_dist=dist\n x_det=x1\n y_det=y1\n mag_det=detected_cat['MAG_AUTO'][i]\n index=j\n j+=1\n if min_dist<1e40:\n nb+=1\n detected_cat['detected'][i]=1\n #print ('Matched sources n. {0:d} at position: {1:.2f}-{2:.2f} \\n'.format(i,x_det,y_det))\n input_cat['detected'][index]=1\n input_cat['x_coord_det'][index]=x_det\n input_cat['y_coord_det'][index]=y_det\n input_cat['mag_det'][index]=mag_det\n else:\n detected_cat['detected'][i]=-1\n #print ('Matched sources n. {0:d} at position: {1:.2f}-{2:.2f} \\n'.format(i,x_det,y_det))\n\n i+=1\n\n\n \"\"\"\n for x1,y1 in zip(input_cat['COORD_YPIXEL'],input_cat['COORD_XPIXEL']):\n nb+=1\n #print ('object n. {0:d} at position: {1:.2f}-{2:.2f} \\n'.format(nb,x1,y1))\n min_dist=1e40\n x_det=-1;y_det=-1;\n j=0\n for x2, y2 in zip (detected_cat['XPEAK_IMAGE'], detected_cat['YPEAK_IMAGE']):\n if detected_cat['detected'][j]==0 and x2 >= int(x1)-pixradius and x2 <= int(x1)+pixradius and y2 >= int(y1)-pixradius and y2 <= int(y1)+pixradius:\n #Test the minimum distance\n dist=(x2-x1)**2+(y2-y1)**2\n if dist < min_dist:\n min_dist=dist\n x_det=x2\n y_det=y2\n mag_det=detected_cat['MAG_AUTO'][j]\n index=j\n j+=1\n \n if min_dist<1e40:\n i+=1\n detected_cat['detected'][index]=1\n #print ('Matched sources n. {0:d} at position: {1:.2f}-{2:.2f} \\n'.format(i,x_det,y_det))\n input_cat['detected'][nb-1]=1\n input_cat['x_coord_det'][nb-1]=x_det\n input_cat['y_coord_det'][nb-1]=y_det\n input_cat['mag_det'][nb-1]=mag_det\n \"\"\"\n #Cross match catalog\n print ('Number of sources matched in both catalogs: %d' % nb)\n\n #Write output file\n ascii.write(input_cat,'%s.txt' % output_fname)\n\n\n\n x_false_list=detected_cat['XPEAK_IMAGE'][detected_cat['detected']==-1]\n y_false_list=detected_cat['YPEAK_IMAGE'][detected_cat['detected']==-1]\n mag_sex=detected_cat['MAG_AUTO'][detected_cat['detected']==-1]\n\n #x_det_coord=Column(name='x_coord',data=x_det_list)\n #y_det_coord=Column(name='y_coord',data=y_det_list)\n #mag_det=Column(name='mag_det',data=mag_sex)\n false_det_cat=Table([x_false_list,y_false_list,mag_sex],names=('x_coord','y_coord','mag_det'))\n\n\n #Write false detections in a separated file\n ascii.write(false_det_cat,'%s.txt' % cat_falsedet)","def test_mock_spec():\n\n # try fitting a mock spectrum which you know has a match in the model grid\n lam_obs, flam_obs, ferr_obs, mock_lsf = get_mock_spec()\n\n # read in entire model set\n bc03_all_spec = fits.open(figs_dir + 'all_comp_spectra_bc03_ssp_and_csp_nolsf_noresample.fits')\n\n # prep for fitting\n total_models = 34542 # if ssp + csp\n\n # arrange the model spectra to be compared in a properly shaped numpy array for faster computation\n # first check where the models are\n model_dir = '/Volumes/Bhavins_backup/bc03_models_npy_spectra/m62/'\n # this is if working on the laptop. Then you must be using the external hard drive where the models are saved.\n if not os.path.isdir(model_dir):\n model_dir = home + '/Documents/GALAXEV_BC03/bc03/src/cspout_new/m62/' # this path only exists on firstlight\n if not os.path.isdir(model_dir):\n print \"Model files not found. Exiting...\"\n sys.exit(0)\n\n example_filename_lamgrid = 'bc2003_hr_m62_tauV0_csp_tau100_salp_lamgrid.npy'\n model_lam_grid = np.load(model_dir + example_filename_lamgrid)\n model_comp_spec = np.zeros([total_models, len(model_lam_grid)], dtype=np.float64)\n for j in range(total_models):\n model_comp_spec[j] = bc03_all_spec[j+1].data\n\n # total run time up to now\n print \"All models put in numpy array. Total time taken up to now --\", time.time() - start, \"seconds.\"\n\n # now call the actual fitting function\n mock_redshift_estimate = 1.0 # this behaves like the photo-z\n\n # extend lam_grid to be able to move the lam_grid later \n avg_dlam = old_ref.get_avg_dlam(lam_obs)\n\n lam_low_to_insert = np.arange(5000, lam_obs[0], avg_dlam)\n lam_high_to_append = np.arange(lam_obs[-1] + avg_dlam, 10500, avg_dlam)\n\n resampling_lam_grid = np.insert(lam_obs, obj=0, values=lam_low_to_insert)\n resampling_lam_grid = np.append(resampling_lam_grid, lam_high_to_append)\n\n # call actual fitting function\n do_fitting(flam_obs, ferr_obs, lam_obs, mock_lsf, mock_redshift_estimate, resampling_lam_grid, \\\n model_lam_grid, total_models, model_comp_spec, bc03_all_spec)\n\n # total time\n print \"Total time taken up to now --\", time.time() - start, \"seconds.\"\n sys.exit(0)\n\n return None","def data_vis():\n dataroot = 'solar_data.txt'\n debug = False \n diff = False\n X, y = read_data(dataroot, debug, diff)\n\n # First plot the original timeseries\n fig = plt.figure(figsize=(40,40))\n\n fig.add_subplot(3,3,1)\n plt.plot(y)\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\n # plt.show()\n\n fig.add_subplot(3,3,2)\n plt.plot(X[:,0])\n plt.title('Avg Zenith Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,3)\n plt.plot(X[:,1])\n plt.title('Avg Azimuth Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,4)\n plt.plot(X[:,2])\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\n # plt.show()\n\n fig.add_subplot(3,3,5)\n plt.plot(X[:,3])\n plt.title('Avg Tower RH [%]')\n # plt.show()\n\n fig.add_subplot(3,3,6)\n plt.plot(X[:,4])\n plt.title('Avg Total Cloud Cover [%]')\n # plt.show()\n\n fig.add_subplot(3,3,7)\n plt.plot(X[:,5])\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\n # plt.show()\n\n ##########################################################################################\n # Plotting the Fourier Transform of the signals\n\n freq = np.fft.fftfreq(len(y), 1*60*60)\n\n fig = plt.figure(figsize=(40,40))\n\n fig.add_subplot(3,3,1)\n plt.plot(freq, np.abs(np.fft.fft(y)))\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\n # plt.show()\n\n fig.add_subplot(3,3,2)\n plt.plot(freq, np.abs(np.fft.fft(X[:,0])))\n plt.title('Avg Zenith Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,3)\n plt.plot(freq, np.abs(np.fft.fft(X[:,1])))\n plt.title('Avg Azimuth Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,4)\n plt.plot(freq, np.abs(np.fft.fft(X[:,2])))\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\n # plt.show()\n\n fig.add_subplot(3,3,5)\n plt.plot(freq, np.abs(np.fft.fft(X[:,3])))\n plt.title('Avg Tower RH [%]')\n # plt.show()\n\n fig.add_subplot(3,3,6)\n plt.plot(freq, np.abs(np.fft.fft(X[:,4])))\n plt.title('Avg Total Cloud Cover [%]')\n # plt.show()\n\n fig.add_subplot(3,3,7)\n plt.plot(freq, np.abs(np.fft.fft(X[:,5])))\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\n # plt.show()\n\n ##################################################################################################\n # Print correlation matrix\n\n df = pd.DataFrame(np.c_[y, X])\n df.columns = ['Avg Global PSP (vent/cor) [W/m^2]','Avg Zenith Angle [degrees]','Avg Azimuth Angle [degrees]','Avg Tower Dry Bulb Temp [deg C]','Avg Tower RH [%]','Avg Total Cloud Cover [%]','Avg Avg Wind Speed @ 6ft [m/s]']\n f = plt.figure(figsize=(19, 15))\n plt.matshow(df.corr(), fignum=f.number)\n plt.xticks(range(df.shape[1]), df.columns, fontsize=14, rotation=20)\n plt.yticks(range(df.shape[1]), df.columns, fontsize=14)\n cb = plt.colorbar()\n cb.ax.tick_params(labelsize=14)\n plt.title('Correlation Matrix', fontsize=16);\n plt.show()","def diff_mat(fmin, fmax, mat_dir=None, ROI_labels=None,\n incon_event=['LRst', 'RLst'], con_event=['LLst', 'RRst']):\n\n fn_con1 = mat_dir + '/%s_%d_%dHz.npy' % (con_event[0], fmin, fmax)\n fn_con2 = mat_dir + '/%s_%d_%dHz.npy' % (con_event[1], fmin, fmax)\n fn_incon1 = mat_dir + '/%s_%d_%dHz.npy' % (incon_event[0], fmin, fmax)\n fn_incon2 = mat_dir + '/%s_%d_%dHz.npy' % (incon_event[1], fmin, fmax)\n am_ROI = len(ROI_labels)\n con_cau1 = np.load(fn_con1)\n con_cau2 = np.load(fn_con2)\n con_cau = con_cau1 + con_cau2\n incon_cau = np.load(fn_incon1) + np.load(fn_incon2)\n con_cau[con_cau > 0] = 1\n incon_cau[incon_cau > 0] = 1\n dif_cau = incon_cau - con_cau\n dif_cau[dif_cau < 0] = 0\n com_cau = incon_cau - dif_cau\n com_cau[com_cau < 0] = 0\n fn_dif = mat_dir + '/incon_con_%d-%dHz.npy' % (fmin, fmax)\n fn_com = mat_dir + '/com_incon_con_%d-%dHz.npy' % (fmin, fmax)\n fig_dif = mat_dir + '/incon_con_%d-%dHz.png' % (fmin, fmax)\n plt.matshow(dif_cau, interpolation='nearest')\n plt.xticks(np.arange(am_ROI), ROI_labels, fontsize=9, rotation='vertical')\n plt.yticks(np.arange(am_ROI), ROI_labels, fontsize=9)\n # pl.tight_layout(pad=2)\n # pl.show()\n plt.savefig(fig_dif, dpi=300)\n plt.close()\n np.save(fn_dif, dif_cau)\n np.save(fn_com, com_cau)\n # print len(np.argwhere(dif_cau))","def detail_matching(self):\n paradic = self.cfg['param']['paradic']\n work_dir = self.work_dir\n \n x = float(self.cfg['param']['x']) # selected pixel in the first image\n y = float(self.cfg['param']['y'])\n \n # sift parameters\n # number of bins in the orientation histogram\n n_bins = int(paradic['n_bins']) \n n_hist = int(paradic['n_hist']) \n # descriptor of n_hist X n_hist weighted histograms with n_ori\n n_ori = int(paradic['n_ori']) \n delta_min = float(paradic['delta_min'])\n sigma_min = float(paradic['sigma_min'])\n sigma_in = float(paradic['sigma_in'])\n lambda_ori = float(paradic['lambda_ori'])\n lambda_descr = float(paradic['lambda_descr'])\n #threshold defining reference orientations\n n_spo = int(paradic['n_spo'])\n \n # Read feature vectors from output files\n if (os.path.getsize(work_dir+'OUTmatches.txt') > 0 ):\n pairdata = find_nearest_keypoint(work_dir+'OUTmatches.txt', y, x)\n \n illustrate_pair(pairdata, n_bins, n_hist, n_ori, work_dir)\n\n \n # Read keys coordinates.\n d = 6+n_bins+n_hist*n_hist*n_ori # size of keydata inside pairdata\n v = n_hist*n_hist*n_ori\n [x1, y1, sigma1, theta1] = [float(x) for x in pairdata[0:4]]\n [o1, s1] = [float(x) for x in pairdata[4+v:4+v+2]]\n [x2a, y2a, sigma2a, theta2a] = [float(x) for x in pairdata[d:d+4]]\n [o2a, s2a] = [float(x) for x in pairdata[d+4+v:d+4+v+2]]\n [x2b, y2b, sigma2b, theta2b] = \\\n [float(x) for x in pairdata[2*d:2*d+4]]\n [o2b, s2b] = [float(x) for x in pairdata[2*d+4+v:2*d+4+v+2]]\n \n draw_one_match(pairdata,\n work_dir+'input_0.png',\n work_dir+'input_1.png',\n d,\n lambda_ori,\n lambda_descr,\n n_hist,\n work_dir+'OUTonepair.png')\n \n \n # Extract thumbnails.\n # keypoint 1 (image 1)\n print ' '.join(['demo_extract_patch', work_dir+'input_0.png',\n str(x1), str(y1), str(sigma1), str(theta1), str(o1), str(s1),\n str(delta_min), str(sigma_min), str(sigma_in), str(n_spo),\n str(lambda_ori), str(lambda_descr), str(n_hist),\n work_dir+\"detail_im1\"])\n proc = self.run_proc(['demo_extract_patch', work_dir+'input_0.png',\n str(x1), str(y1), str(sigma1), str(theta1), str(o1), str(s1),\n str(delta_min), str(sigma_min), str(sigma_in), str(n_spo),\n str(lambda_ori), str(lambda_descr), str(n_hist),\n work_dir+\"detail_im1\"])\n self.wait_proc(proc, timeout=self.timeout)\n \n # keypoint 2a (nearest neighbor in image 2)\n print ' '.join(['demo_extract_patch', work_dir+'input_1.png',\n str(x2a), str(y2a), str(sigma2a), str(theta2a), str(o2a), str(s2a),\n str(delta_min), str(sigma_min), str(sigma_in), str(n_spo),\n str(lambda_ori), str(lambda_descr), str(n_hist),\n work_dir+\"detail_im2a\"])\n proc = self.run_proc(['demo_extract_patch', work_dir+'input_1.png',\n str(x2a), str(y2a), str(sigma2a), str(theta2a), str(o2a), str(s2a),\n str(delta_min), str(sigma_min), str(sigma_in), str(n_spo),\n str(lambda_ori), str(lambda_descr), str(n_hist),\n work_dir+\"detail_im2a\"])\n self.wait_proc(proc, timeout=self.timeout) \n \n # keypoint 2b (second nearest neighbor in image 2)\n proc = self.run_proc(['demo_extract_patch', work_dir+'input_1.png',\n str(x2b), str(y2b), str(sigma2b), str(theta2b), str(o2b), str(s2b),\n str(delta_min), str(sigma_min), str(sigma_in), str(n_spo),\n str(lambda_ori), str(lambda_descr), str(n_hist),\n work_dir+\"detail_im2b\"])\n self.wait_proc(proc, timeout=self.timeout) \n \n \n return 1","def decode_plot(model,datapath,img_size=100,vae=False,compare=False,adjust=False,discrepancy=0.1):\n target = set_creation(datapath,img_size=img_size,nrand=5,adjust=adjust)\n model.eval()\n out, _ = model(target.float())\n plt.style.use('seaborn')\n plt.figure(figsize=(14,6*(1+int(compare))),dpi=80)\n for i in range(5):\n # Load and plot original image\n ax1 = plt.subplot(2*(1+int(compare)),5,i+1)\n ax1.imshow(target[i][0],cmap='viridis')\n ax1.set_title('Original image')\n normout = out[i][0]-out[i][0].min()\n normout = normout/normout.max()\n # Plot decoded image\n ax2 = plt.subplot(2*(1+int(compare)),5,6+i)\n ax2.imshow(normout.data,cmap='viridis')\n ax2.set_title('Decoded image'+(' (reference)' if i==0 and compare else ''))\n if compare:\n diff = normout-target[i][0]\n accuracy = len(diff[numpy.array(abs(diff)<discrepancy)])/args.img_size**2*100\n # Plot difference between decoded and original image\n ax3 = plt.subplot(4,5,11+i)\n ax3.imshow((normout-target[i][0]).data,cmap='seismic',vmin=-1,vmax=1)\n ax3.set_title('%.2f%% accuracy'%accuracy)\n # Plot difference between decoded and reference images\n if i==0:\n refout = normout\n ax4 = plt.subplot(4,5,16+i)\n ax4.imshow(abs(normout-refout).data,cmap='OrRd')\n ax4.set_title('Decoded - Reference')\n plt.tight_layout()\n plt.show()","def report_sim_difference(sim0: rebound.Simulation, sim1: rebound.Simulation, \n object_names: List[str], verbose: bool=False) -> \\\n Tuple[np.array, np.array]:\n # Extract configuration arrays for the two simulations\n cfg0: np.array = sim_cfg_array(sim0, object_names)\n cfg1: np.array = sim_cfg_array(sim1, object_names)\n \n # Convert both arrays to heliocentric coordinates\n cfg0 = cfg0 - cfg0[0:1,:]\n cfg1 = cfg1 - cfg1[0:1,:]\n\n # Displacement of each body to earth\n earth_idx: int = object_names.index('Earth')\n q0: np.array = cfg0[:, 0:3] - cfg0[earth_idx, 0:3]\n q1: np.array = cfg1[:, 0:3] - cfg1[earth_idx, 0:3]\n \n # Right Ascension and Declination\n r0, asc0, dec0 = cart_to_sph(q0)\n r1, asc1, dec1 = cart_to_sph(q1)\n\n # Error in asc and dec; convert from radians to arcseconds\n asc_err: np.array = np.degrees(np.abs(asc1-asc0)) * 3600\n dec_err: np.array = np.degrees(np.abs(dec1-dec0)) * 3600\n\n # Take differences\n cfg_diff: np.array = (cfg1 - cfg0)\n pos_diff: np.array = cfg_diff[:, 0:3]\n vel_diff: np.array = cfg_diff[:, 3:6]\n\n # Error in position and velocity in heliocentric coordinates; skip the sun\n pos_err: np.array = np.linalg.norm(pos_diff, axis=1)\n pos_err_den: np.array = np.linalg.norm(cfg0[:, 0:3], axis=1)\n pos_err_den[0] = 1.0\n pos_err_rel: np.array = pos_err / pos_err_den\n vel_err: np.array = np.linalg.norm(vel_diff, axis=1)\n vel_err_den: np.array = np.linalg.norm(cfg0[:, 3:6], axis=1)\n vel_err_den[0] = 1.0\n vel_err_rel: np.array = vel_err / vel_err_den\n\n if verbose:\n print(f'\\nPosition difference - absolute & relative')\n print(f'(Angle errors in arcseconds, position in AU)')\n print(f'Body : Phi : Theta : Pos AU : Pos Rel : Vel Rel')\n object_names_short: List[str] = [nm.replace(' Barycenter', '') for nm in object_names]\n for i, nm in enumerate(object_names_short):\n print(f'{nm:10} : {asc_err[i]:5.2e}: {dec_err[i]:5.2e}: {pos_err[i]:5.2e}: '\n f'{pos_err_rel[i]:5.2e}: {vel_err_rel[i]:5.2e}')\n print(f'Overall : {rms(asc_err):5.2e}: {rms(dec_err):5.2e}: {rms(pos_err):5.2e}: '\n f'{rms(pos_err_rel):5.2e}: {rms(vel_err_rel):5.2e}')\n\n # Extract orbital element arrays from the two simulations\n elt0: np.array = sim_elt_array(sim0, object_names[1:])\n elt1: np.array = sim_elt_array(sim1, object_names[1:])\n\n # Take differences\n elt_diff: np.array = (elt1 - elt0)\n # Angle differences are mod two pi\n two_pi: float = 2.0 * np.pi\n elt_diff[:,2:] = (elt_diff[:,2:] +np.pi ) % two_pi - np.pi\n \n # Compute RMS difference by orbital element\n elt_rms: np.array = rms(elt_diff, axis=0)\n elt_err: np.array = np.abs(elt_diff)\n\n # Names of selected elements\n elt_names: List[str] = ['a', 'e', 'inc', 'Omega', 'omega', 'f', 'M', 'pomega', 'long']\n\n # Report RMS orbital element differences\n if verbose:\n print(f'\\nOrbital element errors:')\n print(f'elt : RMS : worst : max_err : HRZN : REB')\n for j, elt in enumerate(elt_names):\n idx = np.argmax(elt_err[:, j])\n worse = object_names_short[idx+1]\n print(f'{elt:6} : {elt_rms[j]:5.2e} : {worse:10} : {elt_err[idx, j]:5.2e} : '\n f'{elt0[idx, j]:11.8f} : {elt1[idx, j]:11.8f}')\n print(f'RMS (a, e, inc) = {rms(elt_diff[:,0:3]):5.2e}')\n print(f'RMS (f, M, pomega, long) = {rms(elt_diff[:,5:9]):5.2e}') \n\n # One summary error statistic\n ang_err: np.array = rms(np.array([asc_err, dec_err]))\n \n # Return the RMS position error and angle errors\n return pos_err, ang_err","def avCDNC(CL,abovesize=nan,uppersize=nan,inst=\"FSSP96\",scan=0):\n if len(CL.times[\"verticloud\"])<=scan:\n print(\"[avCDNC] No vertical scan for this cloud.\")\n return nan\n else:\n ts=CL.times[\"verticloud\"][scan] # times of the vertical scan\n pos=[i for i,x in enumerate(CL.sd) if inst.lower() in x[\"Distname\"].lower()]; \n if len(pos)<=0: cancel=1; raise ValueError(\"This instrument name has not been found (inst=%s).\" % inst)\n else: pos=pos[0]\n calt=[i for i,x in enumerate(CL.dttl) if x == 'altitude']; calt=calt[0]\n ctim=[i for i,x in enumerate(CL.dttl) if x == 'time']; ctim=ctim[0]\n alt=CL.data[calt]\n tim=CL.data[ctim]\n clwc=[i for i,x in enumerate(CL.dttl) if x == 'LWC']; \n if len(clwc)>1: print(\"[avCDNC] Multiple LWC found.\"); lwc=np.ones((2,))*NaN; lwctime=ts # LWC found in the basic data\n elif len(clwc)==1: lwc=CL.data[clwc[0]]; lwctime=tim; \n else: # looking for LWC in the extradata\n posx=[] \n for i,L in enumerate(CL.extrattl): # for all extra datasets available\n posx=posx+[[i,j] for j,x in enumerate(L) if x.lower() == 'lwc'] # check all titles matching with LWC\n if len(posx)==1: \n lwc=CL.extradata[posx[0][0]][posx[0][1]] # loading the LWC data\n j=[j for j,x in enumerate(CL.extrattl[i]) if x.lower() == 'time'][0]\n lwctime=CL.extradata[posx[0][0]][j] # loading associated time stamp\n else: print(\"[avCDNC] No LWC (or multiple) was found in the basic data or the extra data.\"); return nan\n \n \n timtc=CL.sd[pos][\"time\"] # time corresponding to the concentration tc\n # find shortest common time stamp\n ta1=np.max([lwctime[0],tim[0],timtc[0],ts[0]]); ta2=np.min([lwctime[-1],tim[-1],timtc[-1],ts[1]]); \n taix=[nonzero((timtc>=ta1)*(timtc<=ta2))[0]]; \n usedtime=timtc[taix]\n if len(usedtime)==0: WA=nan # weighted average is not calculable (no data for the vertical scan)\n else:\n tc=samac.dNdlogDp2N(CL.sd[pos],abovesize,uppersize)[taix] # total concentration between above- and upper-size\n test=tim.__array__()==timtc\n if len(tim)==len(timtc): \n if (tim.__array__()==timtc).all()==True: alt=alt[taix]\n else:\n print(\"[avCDNC] nonequal times (although same length): altitude was interpolated.\")\n # interpolating on size distribution data.\n falt=interpolate.interp1d(tim,alt,kind='linear') \n alt=falt(usedtime); \n else:\n print(\"[avCDNC] nonequal times: altitude was interpolated.\")\n # interpolating on size distribution data.\n falt=interpolate.interp1d(tim,alt,kind='linear') \n alt=falt(usedtime); \n if len(lwctime)==len(timtc):\n if (lwctime.__array__()==timtc).all()==True: lwc=lwc[taix]\n else: flwc=interpolate.interp1d(lwctime,lwc,kind='linear'); lwc=flwc(usedtime)\n # integrating\n dalt=np.diff(alt);\n lwc=lwc[1:];\n tc=tc[1:];\n WA=abs(sum(tc*lwc*dalt))/(samac.lwp(CL)[scan][0]) # if inst conc is cm-3 (cm-3 lwc*meters / lwc*meters = cm-3)\n return WA","def visitspec(load,plate,mjd,fiber,gridfile='apg_rvsynthgrid',apstar=False) :\n grid = fits.open(os.environ['APOGEE_DIR']+'/data/synthgrid/'+gridfile+'.fits')\n if gridfile == 'apg_rvsynthgrid' : hdu=1\n elif gridfile == 'apg_rvsynthgrid_v2': hdu=0\n elif apstar : hdu=2\n else : hdu=1\n gridspec=grid[hdu].data\n gridwave = 10.**spectra.fits2vector(grid[hdu].header,2)\n griderr = np.ones(gridspec.shape[0])\n #for ispec in range(gridspec.shape[1]) :\n # cont = norm.cont(gridspec[:,ispec],griderr)\n # gridspec[:,ispec] /= cont\n\n data = load.apVisit(plate,mjd,fiber)\n\n # compare with DR14 \n comp(a,b,domatch=False,out='plots/dr14all')\n grid.append(['dr14all_1.png',''])\n xtit.append('all stars: DR14 (dotted) and test DR16 (solid)')\n\n comp(a,b,domatch=True,out='plots/dr14match')\n grid.append(['dr14match_1.png','dr14match_2.png'])\n xtit.append('same stars: DR14 (dotted) and test DR16 (solid)')\n # set bad pixels to nan\n shape=data[1].data.shape\n spec = copy.copy(data[1].data).flatten()\n specerr = copy.copy(data[2].data)\n specwave=data[4].data\n pixmask=bitmask.PixelBitMask()\n bd = np.where( ((data[3].data & pixmask.badval()) > 0) | \n ((data[3].data & pixmask.getval('SIG_SKYLINE')) > 0) ) [0]\n spec[bd] = np.nan\n spec = spec.reshape(shape)\n\n # continuum normalize and sample to grid\n outspec = np.full(len(gridwave),np.nan)\n if not apstar :\n # apVisit wavelengths are reversed\n spec=np.flip(spec)\n specwave=np.flip(specwave)\n specerr=np.flip(specerr)\n for ichip in range(3) :\n cont = norm.cont(spec[ichip,:],specerr[ichip,:])\n spec[ichip,:] /= cont\n gd=np.where(np.isfinite(spec[ichip,:]))[0]\n ip= interpolate.InterpolatedUnivariateSpline(specwave[ichip,gd],spec[ichip,gd],k=3)\n out = ip(gridwave)\n gd = np.where( (gridwave > specwave[ichip,0]) & (gridwave < specwave[ichip,-1]) )[0]\n outspec[gd] = out[gd]\n plt.plot(specwave[ichip,:],spec[ichip,:])\n plt.plot(gridwave[gd],out[gd])\n plt.show()\n\n for ispec in range(gridspec.shape[1]) :\n print(ispec)\n bd=np.where(np.isnan(outspec))\n outspec[bd]=1.\n out=correlate(outspec,gridspec[:,ispec])\n pdb.set_trace()","def extract_relevant_data( case_list = [], exceptions = [], y_delta_locs = [],\n x_2h_locs = [] , plot = False, output_root = '',\n overwrite = False, just_plot = False ):\n\n from os import listdir\n from os.path import join,split,isfile\n from pandas import DataFrame, HDFStore\n from boundary_layer_routines import return_bl_parameters\n from progressbar import ProgressBar,Percentage\n from progressbar import Bar,ETA,SimpleProgress\n from numpy import array, round, linspace, nan, sign\n from data_cleaning_routines import show_surface_from_df\n\n x_2h_locs = round( array( x_2h_locs ), 2 )\n y_delta_locs = round( array( y_delta_locs ), 2 )\n\n if not output_root:\n output_root = '/media/carlos/6E34D2CD34D29783/' +\\\n '2015-02_SerrationPIV/TR_Data_Location_Calibrated_Article3'\n\n # Get the available HDF5 files #############################################\n hdf5_root = '/media/carlos/6E34D2CD34D29783/' +\\\n '2015-02_SerrationPIV/TR_Data_Location_Calibrated_Article3'\n\n if not len(case_list):\n hdf5_files = [f for f in listdir( hdf5_root ) \\\n if f.endswith('.hdf5') \\\n and not f in exceptions ]\n else:\n hdf5_files = [f for f in listdir( hdf5_root ) \\\n if f.endswith('.hdf5') \\\n and f in case_list ]\n # ##########################################################################\n\n for hf in [join( hdf5_root, f ) for f in hdf5_files]:\n\n suffix = '_AirfoilNormal'\n\n mean_flow_rotated = False\n if hf.endswith(\"MeanFlowRotated.hdf5\"):\n mean_flow_rotated = True\n suffix = ('_MeanFlowRotated')\n\n f = split( hf )[1].replace(suffix,'')\\\n .replace('_Aligned.hdf5','').replace('.hdf5','')\n if mean_flow_rotated:\n f = f + '_mfr'\n\n # Get the normalization locations depending on the case ################\n if 'z00' in f and not 'STE' in f:\n x_bl_loc = 38\n elif 'z05' in f:\n x_bl_loc = 18\n elif 'z10' in f or 'STE' in f:\n x_bl_loc = -2\n\n #if mean_flow_rotated:\n # mean_flow_df = read_pickle( mean_flow_pickle )\n # mean_flow_angle = mean_flow_df.T.ix[ \n # f.replace('.hdf5','')\n # ].ix[0].values[0]\n\n # yshift = - x_bl_loc * sin( radians( mean_flow_angle ) )\n #else:\n # yshift = 0\n\n print \" Processing {0}\".format( f )\n if not overwrite and isfile( 'ReservedData/' + f + '.hdf5' ):\n print \" File exists; skipping\"\n continue\n\n\n hdf_t = HDFStore( hf, 'r' )\n\n # Get the available coordinates ########################################\n hf_coords = hdf_t.select('data', where = [ 't = 0' ], \n columns = [ 'x', 'y' , 'u' ] )\n # ######################################################################\n\n # Turn the non-dim requested locations into physical coords ############\n requested_locations = []\n requested_normalized_locations = []\n #for x,x_norm in zip(x_2h_locs * tooth_length, x_2h_locs):\n # for y_d in y_delta_locs:\n # bl_params = return_bl_parameters( f , [x] )\n # d_99 = bl_params.delta_99.values[0]\n # #if \"STE\" in f:\n # # d_99 = 9.4\n # y = y_d * d_99\n # requested_locations.append( (x,y) )\n # requested_normalized_locations.append( ( x_norm, y_d ) )\n\n bl_params = return_bl_parameters( \n f.replace( '_mfr', '' ) , \n [x_bl_loc] )\n d_99 = bl_params.delta_99.values[0]\n\n for x,x_norm in zip(x_2h_locs * tooth_length, x_2h_locs):\n for y_d in y_delta_locs:\n y = y_d * d_99\n requested_locations.append( (x,y) )\n requested_normalized_locations.append( ( x_norm, y_d ) )\n print \" Normalizing to a BL thickness of {0:.2f} mm\".\\\n format(d_99)\n # ######################################################################\n\n hf_coords = hf_coords.replace( 0, nan )\n hf_coords = hf_coords.dropna()\n\n min_x_real_loc = min( x_2h_locs ) * tooth_length\n max_x_real_loc = max( x_2h_locs ) * tooth_length\n\n # This is the max y location for a full square in the rotated FoV ######\n max_y_field_of_view = min(\n hf_coords[ \n ( hf_coords.x < max_x_real_loc * 1.1 ) & \\\n ( hf_coords.x > max_x_real_loc * 0.9 ) \n ].y.max(),\n\n hf_coords[ \n ( hf_coords.x < \\\n min_x_real_loc * ( 1 + sign( min_x_real_loc ) * 0.1 ) ) & \\\n ( hf_coords.x > \\\n min_x_real_loc * ( 1 - sign( min_x_real_loc ) * 0.1 ) ) \n ].y.max()\n )\n # ######################################################################\n\n # This is the minimum (and x_loc aligned) y location for a full square\n # in the rotated FoV ###################################################\n min_y_field_of_view = max(\n hf_coords[ \n ( hf_coords.x < \\\n min_x_real_loc * ( 1 + sign( min_x_real_loc ) * 0.1 ) ) & \\\n ( hf_coords.x > \\\n min_x_real_loc * ( 1 - sign( min_x_real_loc ) * 0.1 ) ) \n ].y.min(), \n hf_coords[ \n ( hf_coords.x < max_x_real_loc * 1.1 ) & \\\n ( hf_coords.x > max_x_real_loc * 0.9 ) \n ].y.min()\n )\n\n # ######################################################################\n\n if max( y_delta_locs ) * d_99 < max_y_field_of_view:\n max_y_loc = max( y_delta_locs ) * d_99\n else:\n max_y_loc = max_y_field_of_view\n\n if min( y_delta_locs ) * d_99 > min_y_field_of_view:\n min_y_loc = min( y_delta_locs ) * d_99\n else:\n min_y_loc = min_y_field_of_view\n\n available_xy_locs = hf_coords[\n ( hf_coords.x > min( x_2h_locs ) * 40. ) & \\\n ( hf_coords.x < max( x_2h_locs ) * 40. ) & \\\n ( hf_coords.y > min_y_loc ) & \\\n ( hf_coords.y < max_y_loc )\n ][ ['x','y'] ]\n\n if available_xy_locs.empty:\n return 0\n \n available_xy_locs = [ tuple(x) for x in available_xy_locs.values ]\n\n #if mean_flow_rotated:\n # y_correction = - x_bl_loc * sin( radians( mean_flow_angle ) )\n\n #if plot:\n\n # trailing_edge,phi,alpha,U,z = decript_case_name( f )\n\n # if trailing_edge == 'serrated': device = 'Sr20R21'\n # elif trailing_edge == 'straight': device = 'STE'\n # elif trailing_edge == 'slitted': device = 'Slit20R21'\n\n # case_name = \"{0}_phi{1}_alpha{2}_U{3}_loc{4}_tr.dat\".format(\n # device, phi, alpha, U, z\n # )\n\n # plot_name = ''\n # if mean_flow_rotated:\n # average_pickle_name = 'averaged_data/' + case_name + \\\n # '_mean_flow_rotated.p'\n # else:\n # average_pickle_name = 'averaged_data/' + case_name + '.p'\n # df_av = read_pickle( average_pickle_name )\n\n # if mean_flow_rotated:\n # df_av.y = df_av.y - yshift\n\n # plot_name = 'ReservedData/' + f + '.png'\n # show_surface_from_df( \n # df_av , \n # points = available_xy_locs ,\n # plot_name = plot_name,\n # point_correction = ( 0 , 0 )\n # )\n # if not plot_name:\n # continue\n\n # Don't try to get it all at once; split the vertical in 4 pieces\n vertical_split_blocks = 10\n\n y_ranges = linspace( \n min_y_loc,\n max_y_loc,\n vertical_split_blocks\n ) \n\n xmin = min(x_2h_locs) * tooth_length\n xmax = max(x_2h_locs) * tooth_length\n\n print \" Extracting data from {0}\".format(f)\n print \" at the streamwise locations:\",\n print \" {0:.2f} to {1:.2f}\".format( xmin, xmax )\n print \" at the wall-normal locations:\",\n print \" {0:.2f} to {1:.2f}\".format( min_y_loc, max_y_loc )\n\n if plot:\n query = \" x>={0} & x<{1} & y>={2} & y<{3} & t=0\".\\\n format( xmin, xmax, min_y_loc, max_y_loc )\n\n df0 = hdf_t.select(\n key = 'data',\n where = [ query ],\n )\n\n plot_name = 'ReservedData/' + f + '.png'\n if mean_flow_rotated:\n plot_name = plot_name.replace( '.png', '_mfr.png' )\n\n show_surface_from_df( \n df0,\n plot_name = plot_name,\n point_correction = ( 0 , 0 )\n )\n if just_plot:\n return 0\n\n query = ''\n cnt_all = 0\n\n cnt = 0\n time_series_hdf = HDFStore( 'ReservedData/' + f + '.hdf5', 'w' )\n\n progress = ProgressBar(\n widgets=[\n Bar(),' ',\n Percentage(),' ',\n ETA(), ' (query bunch ',\n SimpleProgress(),')'], \n maxval = vertical_split_blocks\n ).start()\n\n for ymin, ymax in zip( y_ranges[:-1], y_ranges[1:] ):\n\n query = \" x>={0} & x<{1} & y>={2} & y<{3} \".\\\n format( xmin, xmax, ymin, ymax )\n\n df_t = hdf_t.select(\n key = 'data',\n where = [ query ],\n )\n\n df_t['near_x_2h'] = round( df_t.x / 40., 4 )\n df_t['near_y_delta'] = round( df_t.y / d_99, 4 )\n\n # If it has been flow rotated, the zero y direction needs to be\n # brought back to the location of the wall at the reference x\n # location #########################################################\n #if mean_flow_rotated:\n # df_t.y = df_t.y - y_correction\n # ##################################################################\n # The translation now happens when pickling the raw data\n\n if not cnt:\n time_series_hdf.put( 'data', df_t , \n data_columns = [\n 'near_x_2h',\n 'near_y_delta',\n 't'\n ],\n format = 't')\n else:\n time_series_hdf.append( 'data', df_t , \n data_columns = [\n 'near_x_2h',\n 'near_y_delta',\n 't'\n ],\n format = 't')\n\n cnt_all += 1\n cnt += 1\n\n progress.update(cnt_all)\n\n df_t = DataFrame()\n\n\n progress.finish()\n hdf_t.close()\n time_series_hdf.close()","def test_jam_axi_rms():\n np.random.seed(123)\n xbin, ybin = np.random.uniform(low=[-55, -40], high=[55, 40], size=[1000, 2]).T\n\n inc = 60. # Assumed galaxy inclination\n r = np.sqrt(xbin**2 + (ybin/np.cos(np.radians(inc)))**2) # Radius in the plane of the disk\n a = 40 # Scale length in arcsec\n vr = 2000*np.sqrt(r)/(r+a) # Assumed velocity profile\n vel = vr * np.sin(np.radians(inc))*xbin/r # Projected velocity field\n sig = 8700/(r+a) # Assumed velocity dispersion profile\n rms = np.sqrt(vel**2 + sig**2) # Vrms field in km/s\n\n surf = np.array([39483., 37158., 30646., 17759., 5955.1, 1203.5, 174.36, 21.105, 2.3599, 0.25493])\n sigma = np.array([0.153, 0.515, 1.58, 4.22, 10, 22.4, 48.8, 105, 227, 525])\n qObs = np.full_like(sigma, 0.57)\n\n distance = 16.5 # Assume Virgo distance in Mpc (Mei et al. 2007)\n mbh = 1e8 # Black hole mass in solar masses\n beta = np.full_like(surf, 0.3)\n\n surf_lum = surf # Assume self-consistency\n sigma_lum = sigma\n qobs_lum = qObs\n surf_pot = surf\n sigma_pot = sigma\n qobs_pot = qObs\n\n sigmapsf = 0.6\n pixsize = 0.8\n goodbins = r > 10 # Arbitrarily exclude the center to illustrate how to use goodbins\n\n # The model is similar but not identical to the adopted kinematics!\n rmsModel, ml, chi2, flux = jam_axi_rms(\n surf_lum, sigma_lum, qobs_lum, surf_pot, sigma_pot, qobs_pot,\n inc, mbh, distance, xbin, ybin, plot=True, rms=rms, sigmapsf=sigmapsf,\n beta=beta, pixsize=pixsize, tensor='zz', goodbins=goodbins)\n plt.pause(0.01)","def test_fourth_order():\n if __name__ == '__main__':\n logger = piff.config.setup_logger(verbose=2)\n else:\n logger = piff.config.setup_logger(log_file='output/test_hsmcatalog.log')\n\n image_file = os.path.join('output','test_stats_image.fits')\n cat_file = os.path.join('output','test_stats_cat.fits')\n psf_file = os.path.join('output','test_starstats.fits')\n hsm_file = os.path.join('output', 'test_hsmcatalog.fits')\n config = {\n 'input' : {\n 'image_file_name' : image_file,\n 'cat_file_name' : cat_file,\n 'stamp_size' : 48,\n },\n 'psf' : {\n 'model' : { 'type' : 'Gaussian',\n 'fastfit': True,\n 'include_pixel': False },\n 'interp' : { 'type' : 'Mean' },\n },\n 'output' : {\n 'file_name' : psf_file,\n 'stats' : [\n {\n 'type': 'HSMCatalog',\n 'file_name': hsm_file,\n 'fourth_order': True\n }\n ]\n }\n }\n piff.piffify(config, logger)\n assert os.path.isfile(hsm_file)\n\n data = fitsio.read(hsm_file)\n print('data = ',data)\n # Check that the model and data measurements are close\n np.testing.assert_allclose(data['T_model'], data['T_data'], rtol=1.e-4)\n np.testing.assert_allclose(data['g1_model'], data['g1_data'], rtol=1.e-4)\n np.testing.assert_allclose(data['g2_model'], data['g2_data'], rtol=1.e-4)\n np.testing.assert_allclose(data['T4_model'], data['T4_data'], rtol=1.e-4)\n np.testing.assert_allclose(data['g41_model'], data['g41_data'], atol=1.e-4)\n np.testing.assert_allclose(data['g42_model'], data['g42_data'], atol=1.e-4)\n np.testing.assert_allclose(data['h41_model'], data['h41_data'], rtol=1.e-4)\n np.testing.assert_allclose(data['h42_model'], data['h42_data'], rtol=1.e-4)\n\n # Check that the moment values are what we intend them to be\n psf = piff.read(psf_file)\n stars = piff.Star.load_images(psf.stars, image_file)\n for i, star in enumerate(stars):\n moments = piff.util.calculate_moments(star, fourth_order=True)\n T = moments['M11']*2\n shape = galsim.Shear(e1=moments['M20']/moments['M11'],\n e2=moments['M02']/moments['M11'])\n print('moments = ',moments)\n print('hsm = ',star.hsm)\n print('data = ',data[i])\n print(data['T_data'][i], T, 2*star.hsm[3]**2 / (1-shape.e**2)**0.5)\n print(data['g1_data'][i], shape.g1, star.hsm[4])\n print(data['g2_data'][i], shape.g2, star.hsm[5])\n np.testing.assert_allclose(data['T_data'][i], T, rtol=1.e-5)\n np.testing.assert_allclose(data['g1_data'][i], shape.g1, rtol=1.e-5)\n np.testing.assert_allclose(data['g2_data'][i], shape.g2, rtol=1.e-5)\n T4 = moments['M22'] / T\n np.testing.assert_allclose(data['T4_data'][i], moments['M22']/moments['M11'], rtol=1.e-5)\n np.testing.assert_allclose(data['g41_data'][i],\n moments['M31']/moments['M11']**2 - 3*shape.e1, atol=1.e-5)\n np.testing.assert_allclose(data['g42_data'][i],\n moments['M13']/moments['M11']**2 - 3*shape.e2, atol=1.e-5)\n np.testing.assert_allclose(data['h41_data'][i],\n moments['M40']/moments['M11']**2, rtol=1.e-5)\n np.testing.assert_allclose(data['h42_data'][i],\n moments['M04']/moments['M11']**2, rtol=1.e-5)\n\n # Our simulated data here are elliptical Gaussians, so check that the fourth order terms\n # match what we expect for them.\n #\n # First, for a round Gaussian, M22 = T^2.\n # When there is some ellipticity, there is a correction of (1-e^2).\n # It doesn't come out exact, but it's reasonably close. Not sure why it's not closer...\n print('T4: ', data['T4_data'][i], T/(1-shape.e**2)**0.5)\n np.testing.assert_allclose(data['T4_data'][i], T/(1-shape.e**2)**0.5, rtol=0.05)\n\n # Next, the naive 4th order shape of an elliptical Gaussian is approximately 3e:\n # M31/M11^2 ~= 3 M20/M11\n # M13/M11^2 ~= 3 M02/M11\n print('e4: ', moments['M31']/moments['M11']**2, 3*moments['M20']/moments['M11'])\n print('e4: ', moments['M13']/moments['M11']**2, 3*moments['M02']/moments['M11'])\n np.testing.assert_allclose(moments['M31']/moments['M11'], 3*moments['M20'], rtol=1.e-3)\n np.testing.assert_allclose(moments['M13']/moments['M11'], 3*moments['M02'], rtol=1.e-3)\n # Our g4 measurements subtract off this leading order effect, so for these Gaussian\n # profiles, the 4th order terms are close to 0.\n print('g4: ', data['g41_data'][i], data['g42_data'][i])\n np.testing.assert_allclose(data['g41_data'][i], 0, atol=1.e-3)\n np.testing.assert_allclose(data['g42_data'][i], 0, atol=1.e-3)\n\n # I didn't try to figure out what the spin-4 values should be for a Gaussian.\n # If someone wants to work that out, it would be nice to add a test that they are right.\n # Empirically, it seems to come out pretty close to 10 x (g1+i g2)^2.\n # The g^2 bit makes sense, but I can't figure out where the factor of ~10 comes from.\n print('h4: ', data['h41_data'][i], data['h42_data'][i])\n\n # Repeat, adding in raw_moments\n config['output']['stats'][0]['raw_moments'] = True\n piff.piffify(config, logger)\n data = fitsio.read(hsm_file)\n\n # Check that the model and data measurements are close\n for name in ('T', 'g1', 'g2', 'T4', 'h41', 'h42',\n 'M00', 'M10', 'M01', 'M11', 'M20', 'M02',\n 'M22', 'M31', 'M13', 'M40', 'M04',\n 'M22n', 'M33n', 'M44n'):\n np.testing.assert_allclose(data[name+'_model'], data[name+'_data'], rtol=1.e-4)\n for name in ('g41', 'g42', 'M21', 'M12', 'M30', 'M03'):\n # These are close to 0, so use atol, not rtol.\n np.testing.assert_allclose(data[name+'_model'], data[name+'_data'], atol=1.e-4)\n\n # Check that the moment values are what we intend them to be\n for i, star in enumerate(stars):\n moments = piff.util.calculate_moments(star, third_order=True, fourth_order=True,\n radial=True)\n # Repeat the tests from above to ensure that raw_moments=True doesn't mess up the\n # fourth_order=True measurements.\n T = moments['M11']*2\n shape = galsim.Shear(e1=moments['M20']/moments['M11'],\n e2=moments['M02']/moments['M11'])\n np.testing.assert_allclose(data['T_data'][i], T, rtol=1.e-5)\n np.testing.assert_allclose(data['g1_data'][i], shape.g1, rtol=1.e-5)\n np.testing.assert_allclose(data['g2_data'][i], shape.g2, rtol=1.e-5)\n T4 = moments['M22'] / T\n np.testing.assert_allclose(data['T4_data'][i], moments['M22']/moments['M11'], rtol=1.e-5)\n np.testing.assert_allclose(data['g41_data'][i],\n moments['M31']/moments['M11']**2 - 3*shape.e1, atol=1.e-5)\n np.testing.assert_allclose(data['g42_data'][i],\n moments['M13']/moments['M11']**2 - 3*shape.e2, atol=1.e-5)\n np.testing.assert_allclose(data['h41_data'][i],\n moments['M40']/moments['M11']**2, rtol=1.e-5)\n np.testing.assert_allclose(data['h42_data'][i],\n moments['M04']/moments['M11']**2, rtol=1.e-5)\n np.testing.assert_allclose(data['T4_data'][i], T/(1-shape.e**2)**0.5, rtol=0.05)\n np.testing.assert_allclose(moments['M31']/moments['M11'], 3*moments['M20'], rtol=1.e-3)\n np.testing.assert_allclose(moments['M13']/moments['M11'], 3*moments['M02'], rtol=1.e-3)\n np.testing.assert_allclose(data['g41_data'][i], 0, atol=1.e-3)\n np.testing.assert_allclose(data['g42_data'][i], 0, atol=1.e-3)\n\n for name in moments.keys():\n # These should be exactly the same.\n np.testing.assert_allclose(data[name+'_data'][i], moments[name])\n # And the model ones should be close.\n np.testing.assert_allclose(data[name+'_model'][i], moments[name], atol=1.e-4)\n\n # Finally make sure raw_moments works without fourth_order=True\n del config['output']['stats'][0]['fourth_order']\n piff.piffify(config, logger)\n data = fitsio.read(hsm_file)\n for i, star in enumerate(stars):\n moments = piff.util.calculate_moments(star, third_order=True, fourth_order=True,\n radial=True)\n for name in moments.keys():\n # These should be exactly the same.\n np.testing.assert_allclose(data[name+'_data'][i], moments[name])\n # And the model ones should be close.\n np.testing.assert_allclose(data[name+'_model'][i], moments[name], atol=1.e-4)","def test_find_dispersion_axis():\n wavelengths = np.arange(100) * 0.1 + np.exp(0.1) * 13.0\n # [14.36722193, 14.46722193, 14.56722193, ... 24.16722193, 24.26722193]\n\n wavelengths_horizontal = np.tile(wavelengths, 15).reshape(15, 100)\n assert find_dispersion_axis(wavelengths_horizontal) == 0\n\n wavelengths_vertical = np.repeat(wavelengths, 15).reshape(100, 15)\n assert find_dispersion_axis(wavelengths_vertical) == 1\n\n # Make sure it works for decreasing wavelengths\n assert find_dispersion_axis(np.fliplr(wavelengths_horizontal)) == 0\n assert find_dispersion_axis(np.flipud(wavelengths_vertical)) == 1\n\n # Make sure it works if there are NaNs\n wavelengths_horizontal[:,0] = np.nan\n assert find_dispersion_axis(wavelengths_horizontal) == 0\n\n wavelengths_vertical[:,0] = np.nan\n assert find_dispersion_axis(wavelengths_vertical) == 1\n\n # Make sure if wavelengths don't change it produces an error\n wavelengths_zeros = np.zeros((15, 100))\n with pytest.raises(RuntimeError):\n find_dispersion_axis(wavelengths_zeros)","def fiducial_comparison():\n \n # observed gd1\n g = Table(fits.getdata('/home/ana/projects/GD1-DR2/output/gd1_members.fits'))\n \n # fiducial model\n wangle = 180*u.deg\n pk = pickle.load(open('../data/gd1_fiducial.pkl', 'rb'))\n xi, eta = pk['xi'], pk['eta']\n \n plt.close()\n fig, ax = plt.subplots(2,1,figsize=(7,6), sharex=True)\n \n plt.sca(ax[0])\n plt.scatter(g['phi1']+40, g['phi2'], s=g['pmem']*2, c=g['pmem'], cmap=mpl.cm.binary, vmin=0.5, vmax=1.1, rasterized=True)\n \n plt.ylabel('$\\phi_2$ [deg]')\n plt.text(0.05, 0.9, 'Most likely GD-1 members', transform=plt.gca().transAxes, va='top', fontsize=17)\n plt.xlim(-20,20)\n plt.ylim(-10,10)\n plt.gca().set_aspect('equal')\n \n plt.sca(ax[1])\n plt.plot(xi.wrap_at(wangle), eta, 'o', mec='none', color=mpl.cm.Blues(0.9), ms=5)\n \n plt.xlabel('$\\phi_1$ [deg]')\n plt.ylabel('$\\phi_2$ [deg]')\n plt.text(0.05, 0.9, 'Simulated GD-1\\n0.5 Gyr after subhalo flyby', transform=plt.gca().transAxes, va='top', fontsize=17)\n plt.ylim(-10,10)\n plt.gca().set_aspect('equal')\n \n plt.tight_layout()\n plt.savefig('../plots/fiducial_comparison.pdf')","def magn(names, values, data, model_key, plot_key=False):\n # Making sure number of parameters matches number of names given:\n assert len(names) == len(values), \"len(names) != len(values) in datasim.magn\"\n\n zpicks = data['zpicks']\n # Corrected absolute magnitude M of SN.\n M = values[0]\n\n# dlpc, da, integrated_zpicks, integrated_dlpc, plot_var = zodesolve.zodesolve(names, values, zpicks, model_key, plot_key)\n\n dlpc, da, plot_var = zodesolve.zodesolve(names, values, zpicks, model_key, plot_key)\n\n # Calculating apparent magnitudes of supernovae at the simulated\n # luminosity distances using the distance modulus formula.\n mag = 5 * np.log10(dlpc/10) + M\n# integrated_mag = 5 * np.log10(integrated_dlpc/10) + M\n# print('redshift =',zpicks[-1],'da =', da[-1])\n\n# # plotting interpoated data vs input and full\n# import matplotlib.pyplot as plt\n# import matplotlib as mpl\n# #mpl.style.use('default') # has to be switched on to set figure size\n# mpl.style.use('fivethirtyeight')\n# plt.rcParams['axes.facecolor'] = 'white'\n# plt.rcParams['figure.facecolor'] = 'white'\n# plt.rcParams['grid.color'] = 'white'\n#\n# print('integrated_zpicks',integrated_zpicks[0])\n# print('zpicks', zpicks[0])\n#\n# plt.figure()\n# plt.scatter(integrated_zpicks, integrated_mag, s=70, label='integrated', c=\"C{}\".format(0))\n# plt.plot(zpicks, mag, label='interpolated', linestyle='-', c=\"C{}\".format(1))\n# plt.legend()\n\n if plot_key:\n # Plotting evolution of parameters in the model.\n import plots\n plots.modelcheck(mag, zpicks, plot_var, model_key)\n\n return mag, da","def main():\n\n convergence_rates_e1 = pd.DataFrame(index=['Mean', 'St.D'])\n convergence_rates_e4 = pd.DataFrame(index=['Mean', 'St.D'])\n success_rates = pd.DataFrame(index=['1e-1', '1e-2', '1e-3', '1e-4', '1e-5'])\n peak_ratios = pd.DataFrame(index=['1e-1', '1e-2', '1e-3', '1e-4', '1e-5'])\n\n for function in range(1, 21):\n results = pickle.load(open('results/benchmarking_result_{}.pkl'.format(function), 'rb'))\n\n col_name = 'F{}'.format(function)\n index = function-1\n\n convergence_rates_e1.insert(index, col_name, results.ConvergenceRates[0])\n convergence_rates_e4.insert(index, col_name, results.ConvergenceRates[3])\n\n success_rates.insert(index, col_name, results.SuccessRate)\n peak_ratios.insert(index, col_name, results.PeakRatio)\n\n for i in results.SimulationSwarms:\n\n x_axis = [k for k, _ in i.items()]\n y_axis = [v for _, v in i.items()]\n\n plt.subplot(4, 5, function) # subplot indexes from 1\n plt.plot(x_axis, y_axis, 'k-')\n\n plt.savefig('results/nmmso_benchmark.png')\n plt.show()\n\n pd.set_option('display.max_columns', None) # make sure all columns are printed below\n print(convergence_rates_e1)\n print(convergence_rates_e4)\n print(success_rates)\n print(peak_ratios)\n\n # Table V from Fieldsend et al.\n table4 = pd.Series([\n peak_ratios.stack().median(),\n peak_ratios.stack().mean(),\n peak_ratios.stack().std()\n ])\n print(table4)\n\n # do we want to reproduce Fig. 3","def vsone_matching(metadata, cfgdict={}, verbose=None):\n # import vtool as vt\n #assert isinstance(metadata, ut.LazyDict), 'type(metadata)=%r' % (type(metadata),)\n\n annot1 = metadata['annot1']\n annot2 = metadata['annot2']\n\n ensure_metadata_feats(annot1, cfgdict=cfgdict)\n ensure_metadata_feats(annot2, cfgdict=cfgdict)\n\n if 'dlen_sqrd' not in annot2:\n def eval_dlen_sqrd(annot):\n rchip = annot['rchip']\n dlen_sqrd = rchip.shape[0] ** 2 + rchip.shape[1] ** 2\n return dlen_sqrd\n annot2.set_lazy_func('dlen_sqrd', lambda: eval_dlen_sqrd(annot2))\n\n # Exceute relevant dependencies\n kpts1 = annot1['kpts']\n vecs1 = annot1['vecs']\n kpts2 = annot2['kpts']\n vecs2 = annot2['vecs']\n dlen_sqrd2 = annot2['dlen_sqrd']\n flann1 = annot1.get('flann', None)\n flann2 = annot2.get('flann', None)\n\n matches, output_metdata = vsone_feature_matching(\n kpts1, vecs1, kpts2, vecs2, dlen_sqrd2, cfgdict=cfgdict,\n flann1=flann1, flann2=flann2, verbose=verbose)\n metadata.update(output_metdata)\n return matches, metadata","def plot_feeding_zones_and_power_law_fit_MMEN_per_system_observed_and_physical(sssp_per_sys, sssp, n_mult_min=2, n_mult_max=10, max_core_mass=10., prescription='CL2013', n=10., a0=1., p0=1., p1=-1.5, scale_up=False, N_sys=10):\n y_sym_star = '*' if scale_up else ''\n assert 2 <= n_mult_min <= n_mult_max\n count = 0\n for i,det_sys in enumerate(sssp_per_sys['det_all']):\n if count >= N_sys:\n break\n if n_mult_min <= np.sum(det_sys) <= n_mult_max:\n count += 1\n print('##### System %s (i=%s):' % (count, i))\n\n Mstar = sssp['Mstar_all'][i]\n Mp_sys = sssp_per_sys['mass_all'][i]\n core_mass_sys = np.copy(Mp_sys) # all planet masses including padded zeros\n core_mass_sys[core_mass_sys > max_core_mass] = max_core_mass\n R_sys = sssp_per_sys['radii_all'][i] # all planet radii including padded zeros\n a_sys = sssp_per_sys['a_all'][i] # all semimajor axes including padded zeros\n\n core_mass_sys_obs = np.copy(Mp_sys)[det_sys == 1] # masses of observed planets\n core_mass_sys_obs[core_mass_sys_obs > max_core_mass] = max_core_mass\n R_sys_obs = R_sys[det_sys == 1] # radii of observed planets\n a_sys_obs = a_sys[det_sys == 1] # semimajor axes of observed planets\n core_mass_sys = core_mass_sys[a_sys > 0] # masses of all planets\n R_sys = R_sys[a_sys > 0] # radii of all planets\n a_sys = a_sys[a_sys > 0] # semimajor axes of all planets\n\n sigma_sys = solid_surface_density_prescription(core_mass_sys, R_sys, a_sys, Mstar=Mstar, n=n, prescription=prescription) # using all planets\n sigma_sys_obs = solid_surface_density_prescription(core_mass_sys_obs, R_sys_obs, a_sys_obs, Mstar=Mstar, n=n, prescription=prescription) # using observed planets only\n\n if scale_up:\n sigma0, beta, scale_factor_sigma0 = fit_power_law_and_scale_up_MMEN(a_sys, sigma_sys, a0=a0, p0=p0, p1=p1)\n sigma0_obs, beta_obs, scale_factor_sigma0_obs = fit_power_law_and_scale_up_MMEN(a_sys_obs, sigma_sys_obs, a0=a0, p0=p0, p1=p1)\n else:\n sigma0, beta = fit_power_law_MMEN(a_sys, sigma_sys, a0=a0, p0=p0, p1=p1)\n scale_factor_sigma0 = 1.\n sigma0_obs, beta_obs = fit_power_law_MMEN(a_sys_obs, sigma_sys_obs, a0=a0, p0=p0, p1=p1)\n scale_factor_sigma0_obs = 1.\n\n # Plot the system:\n a_array = np.linspace(1e-3,2,1001)\n sigma_MMSN = MMSN(a_array)\n\n delta_a_sys_S2014 = feeding_zone_S2014(core_mass_sys, R_sys, a_sys, Mstar=Mstar)\n delta_a_sys_nHill = feeding_zone_nHill(core_mass_sys, a_sys, Mstar=Mstar, n=n)\n delta_a_sys_RC2014, a_bounds_sys = feeding_zone_RC2014(a_sys)\n\n fig = plt.figure(figsize=(12,8))\n plot = GridSpec(1,1,left=0.1,bottom=0.15,right=0.95,top=0.95,wspace=0,hspace=0)\n ax = plt.subplot(plot[0,0])\n plt.scatter(a_sys, np.log10(sigma_sys), marker='o', s=100.*R_sys**2., facecolors='none', edgecolors='k', label='All planets')\n plt.scatter(a_sys_obs, np.log10(sigma_sys_obs), marker='o', s=100.*R_sys_obs**2., color='k', label='Observed planets')\n for j,a in enumerate(a_sys):\n # Plot various feeding zones for each planet:\n da_S2014 = delta_a_sys_S2014[j]\n da_nHill = delta_a_sys_nHill[j]\n #da_RC2014 = delta_a_sys_RC2014[j]\n #plt.plot([0.5*a, 1.5*a], [np.log10(1.15*sigma_sys[j])]*2, lw=1, color='k')\n #plt.plot([a - da_S2014/2., a + da_S2014/2.], [np.log10(1.05*sigma_sys[j])]*2, lw=1, color='r')\n #plt.plot([a - da_nHill/2., a + da_nHill/2.], [np.log10(0.95*sigma_sys[j])]*2, lw=1, color='b')\n #plt.plot([a_bounds_sys[j], a_bounds_sys[j+1]], [np.log10(0.85*sigma_sys[j])]*2, lw=1, color='m')\n #plt.plot([a_bounds_sys[j], a_bounds_sys[j+1]], [np.log10(sigma_sys[j])]*2, lw=2, color='k') # lines for feeding zones\n plt.axvspan(a_bounds_sys[j], a_bounds_sys[j+1], alpha=0.2 if j%2==0 else 0.1, ec=None, fc='k')\n\n # To compare the planet masses to the integrated disk masses:\n Mp_core = core_mass_sys[j]\n plt.annotate(r'${:0.1f} M_\\oplus$'.format(Mp_core), (a, np.log10(1.5*sigma_sys[j])), ha='center', fontsize=16)\n if prescription == 'CL2013':\n Mp_intdisk = solid_mass_integrated_r0_to_r_given_power_law_profile(1.5*a, 0.5*a, sigma0, beta, a0=a0)\n print('Planet (core) mass: {:0.2f} M_earth --- Integrated disk mass (CL2013): {:0.2f} M_earth'.format(Mp_core, Mp_intdisk))\n elif prescription == 'S2014':\n Mp_intdisk = solid_mass_integrated_r0_to_r_given_power_law_profile(a + da_S2014/2., a - da_S2014/2., sigma0, beta, a0=a0)\n print('Planet (core) mass: {:0.2f} M_earth --- Integrated disk mass (S2014): {:0.2f} M_earth'.format(Mp_core, Mp_intdisk))\n elif prescription == 'nHill':\n Mp_intdisk = solid_mass_integrated_r0_to_r_given_power_law_profile(a + da_nHill/2., a - da_nHill/2., sigma0, beta, a0=a0)\n print('Planet (core) mass: {:0.2f} M_earth --- Integrated disk mass (nHill): {:0.2f} M_earth'.format(Mp_core, Mp_intdisk))\n elif prescription == 'RC2014':\n Mp_intdisk = solid_mass_integrated_r0_to_r_given_power_law_profile(a_bounds_sys[j+1], a_bounds_sys[j], sigma0, beta, a0=a0)\n print('Planet (core) mass: {:0.2f} M_earth --- Integrated disk mass (RC2014): {:0.2f} M_earth'.format(Mp_core, Mp_intdisk))\n\n plt.plot(a_array, np.log10(MMEN_power_law(a_array, sigma0, beta, a0=a0)), lw=3, ls='-', color='r', label=r'Fit to all planets ($\\Sigma_0^%s = {:0.0f}$, $\\beta = {:0.2f}$)'.format(sigma0, beta) % y_sym_star)\n plt.plot(a_array, np.log10(MMEN_power_law(a_array, sigma0_obs, beta_obs, a0=a0)), lw=3, ls='--', color='r', label=r'Fit to observed planets ($\\Sigma_0^%s = {:0.0f}$, $\\beta = {:0.2f}$)'.format(sigma0_obs, beta_obs) % y_sym_star)\n plt.plot(a_array, np.log10(sigma_MMSN), lw=3, color='g', label=r'MMSN ($\\Sigma_0 = {:0.0f}$, $\\beta = {:0.2f}$)'.format(MMSN(a0), -1.5))\n ax.tick_params(axis='both', labelsize=20)\n plt.gca().set_xscale(\"log\")\n plt.xticks([0.05, 0.1, 0.2, 0.4, 0.8])\n ax.get_xaxis().set_major_formatter(ticker.ScalarFormatter())\n plt.xlim([0.04,0.9])\n plt.ylim([-0.5,5.5])\n plt.xlabel(r'Semimajor axis, $a$ (AU)', fontsize=20)\n plt.ylabel(r'Surface density, $\\log_{10}(\\Sigma/{\\rm g\\,cm}^{-2})$', fontsize=20)\n plt.legend(loc='lower left', bbox_to_anchor=(0.,0.), ncol=1, frameon=False, fontsize=16)\n\n plt.show()","def IR():\n s = np.array(\n [2.40774137,2.287696084,2.203613927,2.048710132,1.899829585,1.591776247,\n 2.021218754,2.572949552,3.298381484,3.635993426,3.788266224,3.8307278,3.834208811]\n )\n\n TI = np.array([50, 75, 100, 150, 200, 300, 400, 500, 750, 1000, 1500, 2000, 3000])\n\n comp1 = s * np.array([-159.1,-134.2,-109.1,-64.7,25.0,40.1,88.6,126.8,187.6,219.4,245.4,253.6,256.1])\n comp2 = s * np.array([-368.3,-356.9,-343.8,-318.1,-292.0,-242.5,-199.3,-158.4,-68.8,14.2,131.9,219.5,333.5])\n comp3 = s * np.array([-77.5,-51.9,-29.8,9.9,40.2,85.7,115.4,135.1,160.1,167.6,172.3,171.7,171.8])\n comp4 = s * np.array([-265.0,-240.6,-216.7,-170.5,-128.2,-53.5,9.6,62.3,159.7,223.8,296.5,328.3,346.7])\n comp5 = s * np.array([-346.5,-328.9,-312.1,-278.5,-244.4,-182.3,-128.0,-80.0,30.8,109.3,225.1,299.5,372.2])\n\n comp = [comp1, comp2, comp3, comp4, comp5]\n MSE = []\n colors = [\"#1f77b4\", \"#ff7f0e\", \"#2ca02c\", \"#d62728\", \"#9467bd\"]\n x_new = np.linspace(0, 3000, 10000)\n for i, j, k in zip(comp, colors, np.arange(1, 6)):\n plt.scatter(TI, i, c=j)\n # popt, _ = curve_fit(MZ, TI, i, p0=np.array([200, 220, 300]))\n popt, _ = curve_fit(MZ, TI, i, p0=np.array([300, 220]))\n # M_z0, T1, M0 = popt\n M0, T1 = popt\n y_new = MZ(x_new, *popt)\n plt.plot(x_new, y_new, \"--\", c=j, label=f\"Fit Comp. {k:d} : $T_1$={T1:3.2f}\")\n MSE.append(mean_squared_error(i,y_new[TI]))\n print(MSE)\n print(np.mean(MSE))\n plt.grid()\n plt.legend(loc=\"best\")\n plt.xlabel(\"TI\")\n plt.ylabel(r\"Singal Intensity $M_z$\")\n plt.show()","def compare_winds(mr1='waroona_run2', mr2='waroona_run2uc', \n hour=datetime(2016,1,5,15),\n extent=None,\n subsubdir=None):\n extentname = mr1.split('_')[0]\n if extent is None:\n extent = constants.extents[extentname]\n \n\n cubes1 = fio.read_model_run(mr1, hour, extent=extent, add_winds=True)\n cubes2 = fio.read_model_run(mr2, hour, extent=extent, add_winds=True)\n \n # pull out horizontal winds\n u,v,s,wd = cubes1.extract(['u','v','s','wind_direction'])\n cu,cv,cs,cwd = cubes2.extract(['u','v','s','wind_direction'])\n dates = utils.dates_from_iris(u)\n height = utils.height_from_iris(s)#.coord('level_height').points\n lats = s.coord('latitude').points\n lons = s.coord('longitude').points\n clats = cs.coords('latitude').points\n clons = cs.coords('longitude').points\n\n ff1,ff2=None,None\n if fio.run_info[mr1]['hasfire']:\n ff1, = fio.read_fire(mr1,dtimes=dates,extent=extent,firefront=True)\n if fio.run_info[mr2]['hasfire']:\n ff2, = fio.read_fire(mr2,dtimes=dates,extent=extent,firefront=True)\n \n # density plot arguments\n bandwidth=1\n # x axis for wind speed\n xs = np.linspace(0,20,100)\n # x axis for wind dir\n xwd = np.linspace(0,360,100)\n # x axis for vert wind speed\n xw = np.linspace(-32,32,100)\n \n ## Colourmap setup for contourf plots\n # Horizontal wind colorbar should be the same for both runs\n hmaxthresh=[5,10,15,20,25,30,35]\n hcmap=plotting._cmaps_['windspeed']\n # vertical wind colourbar is constant\n wcmap=plotting._cmaps_['verticalvelocity']\n wnorm=colors.SymLogNorm(0.25,base=2.) # linear to +- 0.25, then log scale\n wcontours=np.union1d(np.union1d(2.0**np.arange(-2,6),-1*(2.0**np.arange(-2,6))),np.array([0]))\n \n # make 4 vertical bins\n row1 = (0<=height) * (height<500)\n row2 = (500<=height) * (height<2000)\n row3 = (2000<=height) * (height<5000)\n row4 = (5000<=height) * (height<9000)\n \n # loop over datetimes:\n for di, date in enumerate(dates):\n \n s1, s2, s3, s4 = [np.mean(s[di,row,:,:].data, axis=0) for row in [row1,row2,row3,row4]]\n u1, u2, u3, u4 = [np.mean(u[di,row,:,:].data, axis=0) for row in [row1,row2,row3,row4]]\n v1, v2, v3, v4 = [np.mean(v[di,row,:,:].data, axis=0) for row in [row1,row2,row3,row4]]\n wd1, wd2, wd3, wd4 = [np.mean(wd[di,row,:,:].data, axis=0) for row in [row1,row2,row3,row4]]\n \n cs1, cs2, cs3, cs4 = [np.mean(cs[di,row,:,:].data, axis=0) for row in [row1,row2,row3,row4]]\n cu1, cu2, cu3, cu4 = [np.mean(cu[di,row,:,:].data, axis=0) for row in [row1,row2,row3,row4]]\n cv1, cv2, cv3, cv4 = [np.mean(cv[di,row,:,:].data, axis=0) for row in [row1,row2,row3,row4]]\n cwd1, cwd2, cwd3, cwd4 = [np.mean(cwd[di,row,:,:].data, axis=0) for row in [row1,row2,row3,row4]]\n \n \n # Plotting\n plt.close()\n fig, axes = plt.subplots(4,4,figsize=[12,12])\n for i, (si, ui, vi, wdi, csi, cui, cvi, cwdi) in \\\n enumerate(zip([s1,s2,s3,s4],[u1,u2,u3,u4],[v1,v2,v3,v4],[wd1,wd2,wd3,wd4],\n [cs1,cs2,cs3,cs4],[cu1,cu2,cu3,cu4],[cv1,cv2,cv3,cv4],[cwd1,cwd2,cwd3,cwd4])):\n ## Show contourf of wind speed\n plt.sca(axes[0,i])\n \n # first determine colourmap contours so that they are the same between plots (and useful)\n hmax_index=np.sum(np.max(np.max(si),np.max(csi))>hmaxthresh)\n hcontours=np.linspace(0,hmaxthresh[hmax_index],20)\n \n # plot the filled contour for h-wind speeds\n plotting.map_contourf(extent, si, lats, lons, cmap=hcmap,\n clabel=\"\", cbar=False,\n cbarform=None,\n levels=hcontours)\n # overlaid with quiver of wind dir\n #plotting.map_quiver(ui,vi,lats,lons,nquivers=7)\n plt.streamplot(lons,lats,ui,vi,color='grey',minlength=0.5)\n # set limits back to latlon limits\n plt.ylim(lats[0],lats[-1])\n plt.xlim(lons[0],lons[-1])\n \n # Add locations and fire\n plotting.map_add_locations_extent(extentname, \n hide_text=True,\n color='k')\n if ff1 is not None:\n plotting.map_fire(ff1[di].data,lats,lons)\n # Add ylabel on left most plot\n if i==0: plt.ylabel(mr1)\n # add title along top row\n plt.title(['<500m','500m-2000m','2km-5km','5km-9km'][i])\n \n ## for comparison model also\n plt.sca(axes[1,i])\n img,_ = plotting.map_contourf(extent, csi, clats, clons, cmap=hcmap, \n clabel=\"\", \n cbar=False, cbarform=None,\n levels=hcontours,)\n \n # overlaid with quiver of wind dir\n #plotting.map_quiver(cui,cvi,lats,lons,nquivers=7)\n \n plt.streamplot(clons,clats,cui,cvi,color='grey',minlength=0.5)\n # set limits back to latlon limits\n plt.ylim(lats[0],lats[-1])\n plt.xlim(lons[0],lons[-1])\n \n plotting.map_add_locations_extent(extentname, \n hide_text=True,\n color='k')\n # add fire\n if ff2 is not None:\n plotting.map_fire(ff2[di].data,clats,clons)\n # add label on leftmost\n if i==0: plt.ylabel(mr2)\n \n ## Add colourbar for column\n cbar_ax = fig.add_axes([0.14+0.2025*i, 0.508, 0.14, 0.01])# X Y Width Height\n cbar=fig.colorbar(img, cax=cbar_ax, format=ticker.ScalarFormatter(), pad=0,\n orientation='horizontal')\n cbar.set_ticks(np.arange(0,hmaxthresh[hmax_index]+1,5))\n cbar.set_ticklabels(np.arange(0,hmaxthresh[hmax_index]+1,5))\n \n ## add density plot for wind speed\n plt.sca(axes[2,i])\n # density function:\n sdens = gaussian_kde(si.flatten(),bw_method=bandwidth)\n plt.plot(xs,sdens(xs), label=mr1,linewidth=2)\n csdens = gaussian_kde(csi.flatten(),bw_method=bandwidth)\n plt.plot(xs,csdens(xs), label=mr2)\n plt.yticks([],[])\n if i==0: plt.ylabel('wind speed density')\n if i==3: plt.legend()\n \n \n ## add density plot for wind dir\n plt.sca(axes[3,i])\n # density function:\n wddens = gaussian_kde(wdi.flatten(),bw_method=bandwidth)\n plt.plot(xwd,wddens(xwd), label=mr1, linewidth=2)\n cwddens = gaussian_kde(cwdi.flatten(),bw_method=bandwidth)\n plt.plot(xwd,cwddens(xwd), label=mr2, linewidth=2, linestyle='--')\n plt.yticks([],[])\n if i==0: plt.ylabel('wind dir density')\n if i==3: plt.legend()\n \n plt.suptitle(date.strftime(\"%Y%m%d %H:%M(UTC)\"))\n subdir='horizontal'\n if subsubdir is not None:\n subdir += '/'+subsubdir\n fio.save_fig(mr2, _sn_, date, plt, subdir=subdir)\n \n ## Also want to look at vertical winds\n w, = cubes1.extract(['upward_air_velocity'])\n cw, = cubes2.extract(['upward_air_velocity'])\n \n w1, w2, w3, w4 = [np.mean(w[di,row,:,:].data, axis=0) for row in [row1,row2,row3,row4]]\n cw1, cw2, cw3, cw4 = [np.mean(cw[di,row,:,:].data, axis=0) for row in [row1,row2,row3,row4]]\n \n # Plotting\n plt.close()\n fig, axes = plt.subplots(3,4,figsize=[12,12])\n for i, (wi, cwi) in enumerate(zip([w1,w2,w3,w4],[cw1,cw2,cw3,cw4])):\n ## Show contourf of wind speed\n plt.sca(axes[0,i])\n plotting.map_contourf(extent, wi, lats,lons,cmap=wcmap,clabel=\"\",levels=wcontours,norm=wnorm,cbar=False,cbarform=None)\n plotting.map_add_locations_extent(extentname, \n hide_text=True,\n color='k')\n if ff1 is not None:\n plotting.map_fire(ff1[di].data,lats,lons)\n if i==0: plt.ylabel(mr1)\n plt.title(['<500m','500m-2000m','2km-5km','5km-9km'][i])\n \n ## for comparison model also\n plt.sca(axes[1,i])\n img,_=plotting.map_contourf(extent, cwi, clats,clons,cmap=wcmap,clabel=\"\",levels=wcontours,norm=wnorm,cbar=False,cbarform=None)\n plotting.map_add_locations_extent(extentname, \n hide_text=True,\n color='k')\n if ff2 is not None:\n plotting.map_fire(ff2[di].data,clats,clons)\n if i==0: plt.ylabel(mr2)\n \n ## add density plot for wind speed\n plt.sca(axes[2,i])\n ## density function:\n #wdens = gaussian_kde(wi.flatten(),bw_method=bandwidth)\n #plt.plot(xw,wdens(xw), label=mr1, linewidth=2)\n #cwdens = gaussian_kde(cwi.flatten(),bw_method=bandwidth)\n #plt.plot(xw,cwdens(xw), label=mr2, linewidth=2, linestyle='--')\n ## cumulative frequency\n wcdf = cumfreq(wi.flatten(), numbins=len(xw), defaultreallimits=(min(xw),max(xw)))\n plt.plot(xw,wcdf.cumcount,label=mr1, linewidth=2)\n cwcdf = cumfreq(cwi.flatten(), numbins=len(xw), defaultreallimits=(min(xw),max(xw)))\n plt.plot(xw,cwcdf.cumcount,label=mr2, linewidth=2, linestyle='--')\n plt.yticks([],[])\n if i==0: plt.ylabel('wind speed cdf')\n if i==3: plt.legend()\n ## Add colourbar\n cbar_ax = fig.add_axes([.35, 0.37, 0.3, 0.015])# X Y Width Height\n cbar=fig.colorbar(img, cax=cbar_ax, format=ticker.ScalarFormatter(), pad=0,\n orientation='horizontal')\n cbar.set_ticks([-32,-8,-2,0,2,8,32])\n cbar.set_ticklabels([-32,-8,-2,0,2,8,32])\n # title and save\n plt.suptitle(date.strftime(\"%Y%m%d %H:%M(UTC)\"))\n \n subdir='vertical'\n if subsubdir is not None:\n subdir += '/'+subsubdir\n fio.save_fig(mr2, _sn_, date, plt, subdir=subdir)","def plot_hist_snfit_meta(self): \n \n self.read_meta()\n self.read_snfit_results()\n\n \n self.diff_x0 = []\n self.diff_x0_err = []\n self.diff_x1 = []\n self.diff_x1_err = [] \n self.diff_c = []\n self.diff_c_err = [] \n self.diff_mb = []\n self.diff_mb_err = [] \n self.diff_cov_x0_x1 = []\n self.diff_cov_x0_c = []\n self.diff_cov_x1_c = []\n self.diff_cov_mb_x1 = []\n self.diff_cov_mb_c = []\n\n for i in range (len(self.sn_name)):\n for j in range (len(self.meta_sn_name_list)):\n if self.sn_name[i] == self.meta_sn_name_list[j]:\n if np.abs(self.mb[i] - self.meta_mb[j]) < 0.0001:\n self.diff_x0.append(self.x0[i] - self.meta_x0[j])\n self.diff_x0_err.append(self.x0_err[i] - self.meta_x0_err[j])\n self.diff_x1.append(self.x1[i] - self.meta_x1[j])\n self.diff_x1_err.append(self.x1_err[i] - self.meta_x1_err[j]) \n self.diff_c.append(self.c[i] - self.meta_c[j])\n self.diff_c_err.append(self.c_err[i] - self.meta_c_err[j]) \n self.diff_mb.append(self.mb[i] - self.meta_mb[j])\n self.diff_mb_err.append(self.mb_err[i] - self.meta_mb_err[j])\n# self.diff_cov_x0_x1.append()\n# self.diff_cov_x0_c.append()\n# self.diff_cov_x1_c.append()\n# self.diff_cov_mb_x1.append()\n# self.diff_cov_mb_c.append()\n else:\n print self.x1[i] - self.meta_x1[j], self.sn_name[i],self.meta_sn_name_list[j], self.x1[i], self.meta_x1[j]\n\n\n fig = plt.figure(figsize=(8.,8.)) \n \n gs = gridspec.GridSpec(2, 1) #subplots ratio\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\n f.subplots_adjust(hspace = 0.5)\n ax0_1 = plt.subplot(gs[0, 0])\n ax0_2 = plt.subplot(gs[1, 0])\n \n ax0_1.hist(self.diff_x0,25,label='$\\Delta$ X0')\n ax0_2.hist(self.diff_x0_err,25,label='$\\Delta$ X0 error')\n ax0_1.legend()\n ax0_2.legend()\n ax0_1.set_ylabel('N')\n ax0_2.set_ylabel('N')\n pdffile = '../sugar_analysis_data/results/x0_plot_meta_snfit.pdf'\n plt.savefig(pdffile, bbox_inches='tight')\n plt.show()\n \n gs = gridspec.GridSpec(2, 1) #subplots ratio\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\n f.subplots_adjust(hspace = 0.5)\n ax0_1 = plt.subplot(gs[0, 0])\n ax0_2 = plt.subplot(gs[1, 0])\n \n ax0_1.hist(self.diff_x1,25,label='$\\Delta$ X1')\n ax0_2.hist(self.diff_x1_err,25,label='$\\Delta$ X1 error')\n ax0_1.legend()\n ax0_2.legend()\n ax0_1.set_ylabel('N')\n ax0_2.set_ylabel('N')\n pdffile = '../sugar_analysis_data/results/x1_plot_meta_snfit.pdf'\n plt.savefig(pdffile, bbox_inches='tight')\n plt.show()\n \n gs = gridspec.GridSpec(2, 1) #subplots ratio\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\n f.subplots_adjust(hspace = 0.5)\n ax0_1 = plt.subplot(gs[0, 0])\n ax0_2 = plt.subplot(gs[1, 0])\n \n ax0_1.hist(self.diff_c,25,label='$\\Delta$ Color')\n ax0_2.hist(self.diff_c_err,25,label='$\\Delta$ Color error')\n ax0_1.legend()\n ax0_2.legend()\n ax0_1.set_ylabel('N')\n ax0_2.set_ylabel('N')\n pdffile = '../sugar_analysis_data/results/color_plot_meta_snfit.pdf'\n plt.savefig(pdffile, bbox_inches='tight')\n plt.show()\n\n gs = gridspec.GridSpec(2, 1) #subplots ratio\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\n f.subplots_adjust(hspace = 0.5)\n ax0_1 = plt.subplot(gs[0, 0])\n ax0_2 = plt.subplot(gs[1, 0])\n \n ax0_1.hist(self.diff_mb,50,label='$\\Delta$ mb')\n ax0_2.hist(self.diff_mb_err,50,label='$\\Delta$ mb error')\n ax0_1.legend()\n ax0_2.legend()\n ax0_1.set_ylabel('N')\n ax0_2.set_ylabel('N')\n pdffile = '../sugar_analysis_data/results/mb_plot_meta_snfit.pdf'\n plt.savefig(pdffile, bbox_inches='tight')\n plt.show()","def parameter_checks():\n \n with open (datafile, 'r') as yaml_datafile: \n #Load as python object \n yaml_datafile = yaml.load(yaml_datafile, Loader=yaml.FullLoader)\n #Organize by layers\n df = pd.json_normalize(yaml_datafile)\n\n comp_df = df.iloc[0]['component']\n comp_df = pd.DataFrame(comp_df)\n comp_df.to_csv('component.csv')\n\n error_count = 0\n\n #Check spans in each direction is greater than 0\n for i in range(len(comp_df)):\n if comp_df.loc[i,'x_span']<0:\n print (\"ERROR: Component x_span has a value of less than 0\")\n error_count+=1\n if comp_df.loc[i,'y_span']<0:\n print (\"ERROR: Component y_span has a value of less than 0\")\n error_count+=1\n if comp_df.loc[i,'z_span']<0:\n print (\"ERROR: Component z_span has a value of less than 0\")\n error_count+=1\n \n comp_df = comp_df.set_index('name')\n #check that components need to be mirrored at the y-axis\n\n x_coord_in = comp_df.loc['input_wg','x']\n x_coord_out = comp_df.loc['output_wg_top','x']\n\n if x_coord_in >0 or x_coord_out<0:\n print (\"ERROR: components are not mirrored on the Y axis\")\n\n #check distance between input and output waveguides in the x direction\n\n distance_x = (comp_df.loc['output_wg_top','x']-(comp_df.loc['output_wg_top','x_span']/2))-(comp_df.loc['input_wg','x']+(comp_df.loc['input_wg','x_span']/2))\n if distance_x < 0:\n print (\"ERROR: distance between input and output waveguides (\" +str(distance_x)+\") is less than 0, Y-Branch has insufficent spacing to be created\")\n error_count+=1\n\n #check distance between two waveguides is greater than 0 in y axis\n \n distance_y = (comp_df.loc['output_wg_top','y']-(comp_df.loc['output_wg_top','y_span']/2))-(comp_df.loc['output_wg_bottom','y']+(comp_df.loc['output_wg_bottom','y_span']/2))\n if distance_y < 0:\n print (\"ERROR: distance between top and bottom waveguides(\" +str(distance_y)+\") is less than 0, output waveguides need to be separated more\")\n error_count+=1\n\n #check if output waveguides if they're aligned on the same axis\n\n alignment_output_wg = (comp_df.loc['output_wg_top','x']-(comp_df.loc['output_wg_top','x_span']/2))-(comp_df.loc['output_wg_bottom','x']-(comp_df.loc['output_wg_bottom','x_span']/2))\n if alignment_output_wg != 0:\n print (\"ERROR: output waveguides are not aligned along y axis, has an alignment mismatch of \"+ str(alignment_output_wg))\n error_count+=1\n\n if error_count == 0:\n print (\"No errors detected, datafile can be used for simulations/optimizations\")\n else:\n print (\"Please revise YAML file, \" + str(error_count) + \"errors detected\")","def main():\n\n # Create model_dict from arguments\n model_dict = model_dict_create()\n\n # No. of deviations to consider\n no_of_mags = 50\n dev_list = np.linspace(0.1, 5.0, no_of_mags)\n\n # Load dataset specified in model_dict\n print('Loading data...')\n dataset = model_dict['dataset']\n if (dataset == 'MNIST'):\n X_train, y_train, X_val, y_val, X_test, y_test = load_dataset(model_dict)\n # rd_list = [None, 784, 331, 200, 100, 90, 80, 70, 60, 50, 40, 30, 20, 10]\n rd_list = [None, 331, 100, 80, 60, 40, 20]\n # rd_list = [None,784,100]\n elif dataset == 'GTSRB':\n X_train, y_train, X_val, y_val, X_test, y_test = load_dataset(model_dict)\n rd_list = [1024, 338, 200, 100, 90, 80, 70, 60, 50, 40, 33, 30, 20, 10]\n elif dataset == 'HAR':\n X_train, y_train, X_test, y_test = load_dataset(model_dict)\n # rd_list = [561, 200, 100, 90, 80, 70, 60, 50, 40, 30, 20, 10]\n rd_list = [561]\n X_val = None\n y_val = None\n\n mean = np.mean(X_train, axis=0)\n X_train -= mean\n X_test -= mean\n if (dataset == 'MNIST') or (dataset == 'GTSRB'): X_val -= mean\n\n # fig, ax = plt.subplots(nrows=1, ncols=1)\n\n # for rd in rd_list:\n # model_setup_carlini(model_dict, X_train, y_train, X_test, y_test, X_val, y_val, mean, rd, ax)\n\n partial_carlini = partial(model_setup_carlini, model_dict=model_dict, X_train=X_train, y_train=y_train, X_test=X_test, y_test=y_test, X_val=X_val, y_val=y_val,\n mean=mean)\n pool=multiprocessing.Pool(processes=8)\n pool.map(partial_carlini,rd_list,1)\n pool.close()\n pool.join()\n\n # dim_red = model_dict['dim_red']\n # plt.legend()\n # plt.savefig('carlini_l2_hist_'+dim_red+'.png')","def upscaled_rdirs_with_and_without_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison(self):\n\n data_label=\"20170511_230901\"\n ref_label=\"20170507_135726\"\n ref_filename=os.path.join(self.plots_data_dir,\n 'flowmap_ICE5G_data_ALG4_sinkless_downscaled_ls_mask_0k_upscale'\n '_rdirs_{0}_updated.nc'.format(ref_label))\n data_filename=os.path.join(self.plots_data_dir,\n 'flowmap_ICE5G_and_tarasov_upscaled_srtm30plus_north_america_only_data_ALG4_sinkless'\n '_downscaled_ls_mask_0k_upscale_rdirs_' + data_label + '_updated.nc')\n lsmask_filename=os.path.join(self.plots_data_dir,\n \"ls_mask_extract_ls_mask_from_corrected_\"\n \"HD_rdirs_20160504_142435.nc\")\n corrected_hd_rdirs_rmouthoutflow_file = os.path.join(self.plots_data_dir,\n \"rmouthflows_ICE5G_data_ALG4_sinkless_downscaled_ls_mask_0k_upscale_rdirs\"\n \"_{0}_updated.nc\".format(ref_label))\n upscaled_rdirs_rmouthoutflow_file = os.path.join(self.plots_data_dir,\n \"rmouthflows_ICE5G_and_tarasov_upscaled_srtm30plus_north_america_only_\"\n \"data_ALG4_sinkless_\"\n \"downscaled_ls_mask_0k_upscale_rdirs_\" + data_label + \"_updated.nc\")\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\n data_flowmap_filename=data_filename,\n ref_catchment_filename=\\\n \"catchmentmap_ICE5G_data_ALG4_\"\n \"sinkless_downscaled_ls_mask_0k_upscale_rdirs_{0}_updated.nc\"\\\n .format(ref_label),\n data_catchment_filename=\"catchmentmap_ICE5G_and_tarasov_upscaled_\"\n \"srtm30plus_north_america_only_data_ALG4_sinkless_downscaled_ls_\"\n \"mask_0k_upscale_rdirs_\" + data_label + \"_updated.nc\",\n ref_rdirs_filename=\"upscaled_rdirs_ICE5G_data\"\n \"_ALG4_sinkless_downscaled_\"\n \"ls_mask_0k_upscale_rdirs_{0}_updated.nc\".format(ref_label),\n data_rdirs_filename=None,\n reference_rmouth_outflows_filename=\\\n corrected_hd_rdirs_rmouthoutflow_file,\n data_rmouth_outflows_filename=\\\n upscaled_rdirs_rmouthoutflow_file,\n lsmask_filename=lsmask_filename,\n minflowcutoff=50,flip_data=False,\n rotate_data=True,flip_ref=False,rotate_ref=True,\n lsmask_has_same_orientation_as_ref=False,\n invert_ls_mask=False,\n first_datasource_name=\"Reference\",\n matching_parameter_set='magnitude_extensive',\n use_single_color_for_discrepancies=True,\n second_datasource_name=\"Data\",grid_type='HD')","def dorv(visitfiles) :\n # last list elements has configuration variables in a tuple\n allvisit = visitfiles[0]\n load = visitfiles[1]\n field=visitfiles[-1][0]\n obj=visitfiles[-1][1].decode('UTF-8')\n clobber=visitfiles[-1][2]\n verbose=visitfiles[-1][3]\n tweak=visitfiles[-1][4]\n plot=visitfiles[-1][5]\n windows=visitfiles[-1][6]\n #rvrange=visitfiles[-1][7]\n if tweak: suffix='_tweak'\n else : suffix='_out'\n outdir = os.path.dirname(load.filename('Star',field=field,obj=obj))\n outdir = outdir.replace('/stars/','/rv/')\n\n if os.path.exists(outdir+'/'+obj+suffix+'.pkl') and not clobber:\n print(obj,' already done')\n fp=open(outdir+'/'+obj+suffix+'.pkl','rb')\n try: \n out=pickle.load(fp)\n fp.close()\n return out\n except: \n print('error loading: ', obj+suffix+'.pkl')\n pass\n\n speclist=[]\n pixelmask=bitmask.PixelBitMask()\n badval=pixelmask.badval()|pixelmask.getval('SIG_SKYLINE')|pixelmask.getval('LITTROW_GHOST')\n \n # if we have a significant number of low S/N visits, combine first using\n # barycentric correction only, use that to get an estimate of systemic\n # velocity, then do RV determination restricting RVs to within 50 km/s\n # of estimate. This seems to help significant for faint visits\n lowsnr_visits=np.where(allvisit['SNR']<10)[0]\n if (len(lowsnr_visits) > 1) & (len(lowsnr_visits)/len(allvisit) > 0.1) :\n try :\n apstar_bc=visitcomb(allvisit,bconly=True,load=load,write=False,dorvfit=False) \n apstar_bc.setmask(badval)\n spec=doppler.Spec1D(apstar_bc.flux[0,:],err=apstar_bc.err[0,:],bitmask=apstar_bc.bitmask[0,:],\n mask=apstar_bc.mask[0,:],wave=apstar_bc.wave,lsfpars=np.array([0]),\n lsfsigma=apstar_bc.wave/22500/2.354,instrument='APOGEE',\n filename=apstar_bc.filename)\n print('running BC jointfit for :',obj)\n out= doppler.rv.jointfit([spec],verbose=verbose,plot=plot,tweak=tweak,maxvel=[-500,500])\n rvrange=[out[1][0]['vrel']-50,out[1][0]['vrel']+50]\n except :\n print(' BC jointfit failed')\n rvrange=[-500,500]\n elif allvisit['H'].max() > 13.5 : \n # if it's faint, restrict to +/- 500 km/s\n rvrange=[-500,500]\n else :\n # otherwise, restrict to +/ 1000 km/s\n rvrange=[-1000,1000]\n\n for i in range(len(allvisit)) :\n\n # load all of the visits into doppler Spec1D objects\n if load.telescope == 'apo1m' :\n visitfile= load.allfile('Visit',plate=allvisit['PLATE'][i],\n mjd=allvisit['MJD'][i],reduction=allvisit['APOGEE_ID'][i])\n else :\n visitfile= load.allfile('Visit',plate=int(allvisit['PLATE'][i]),\n mjd=allvisit['MJD'][i],fiber=allvisit['FIBERID'][i])\n spec=doppler.read(visitfile,badval=badval)\n\n if windows is not None :\n # if we have spectral windows to mask, do so here\n for ichip in range(3) :\n mask = np.full_like(spec.mask[:,ichip],True)\n gd = []\n for window in windows :\n gd.extend(np.where((spec.wave[:,ichip] > window[0]) & (spec.wave[:,ichip] < window[1]))[0])\n mask[gd] = False\n spec.mask[:,ichip] |= mask\n \n if spec is not None : speclist.append(spec)\n\n # now do the doppler jointfit to get RVs\n # dump empty pickle to stand in case of failure (to prevent redo if not clobber)\n try:\n # dump empty pickle to stand in case of failure (to prevent redo if not clobber)\n fp=open(outdir+'/'+obj+suffix+'.pkl','wb')\n pickle.dump(None,fp)\n fp.close()\n print('running jointfit for : {:s} rvrange:[{:.1f},{:.1f}] nvisits: {:d}'.format(obj,*rvrange,len(speclist)))\n out= doppler.rv.jointfit(speclist,maxvel=rvrange,verbose=verbose,\n plot=plot,saveplot=plot,outdir=outdir+'/',tweak=tweak)\n print('running decomp for :',obj)\n gout = gauss_decomp(out[1],phase='two',filt=True)\n fp=open(outdir+'/'+obj+suffix+'.pkl','wb')\n pickle.dump([out,gout],fp)\n fp.close()\n print('running plots for :',obj,outdir)\n try : os.makedirs(outdir+'/plots/')\n except : pass\n dop_plot(outdir+'/plots/',obj,out,decomp=gout)\n except KeyboardInterrupt : \n raise\n except ValueError as err:\n print('Exception raised in dorv for: ', field, obj)\n print(\"ValueError: {0}\".format(err))\n return\n except RuntimeError as err:\n print('Exception raised in dorv for: ', field, obj)\n print(\"Runtime error: {0}\".format(err))\n return\n except :\n raise\n print('Exception raised in dorv for: ', field, obj)\n return\n\n # return summary RV info, visit RV info, decomp info \n return [out[0:2],gout]","def main_multimodal_fusion(im_vis, im_ir, kernel, levels, window_size):\n\n im_vis = convert_image_to_floats(im_vis)\n im_ir = convert_image_to_floats(im_ir)\n\n im_vis_hsv = rgb2hsv(im_vis)\n value_channel = im_vis_hsv[:, :, 2]\n\n plt.subplot(1, 2, 1)\n plt.imshow(value_channel, cmap='gray')\n plt.subplot(1, 2, 2)\n plt.imshow(im_ir, cmap='gray')\n plt.show()\n\n # kernels to compute visibility\n kernel1 = classical_gaussian_kernel(5, 2)\n kernel2 = classical_gaussian_kernel(5, 2)\n\n # Computation of local entropy, local contrast and visibility for value channel\n local_entropy_value = normalized_local_entropy(value_channel, window_size)\n local_contrast_value = local_contrast(value_channel, window_size)\n visibility_value = visibility(value_channel, kernel1, kernel2)\n # Combination of local entropy, local contrast and visibility for value channel\n weight_value = weight_combination(local_entropy_value, local_contrast_value, visibility_value, 1, 1, 1)\n\n # Computation of local entropy, local contrast and visibility for IR image\n local_entropy_ir = normalized_local_entropy(im_ir, window_size)\n local_contrast_ir = local_contrast(im_ir, window_size)\n visibility_ir = visibility(im_ir, kernel1, kernel2)\n # Combination of local entropy, local contrast and visibility for IR image\n weight_ir = weight_combination(local_entropy_ir, local_contrast_ir, visibility_ir, 1, 1, 1)\n\n plt.subplot(2, 3, 1)\n plt.imshow(local_entropy_value, cmap='gray')\n plt.subplot(2, 3, 2)\n plt.imshow(local_contrast_value, cmap='gray')\n plt.subplot(2, 3, 3)\n plt.imshow(visibility_value, cmap='gray')\n plt.subplot(2, 3, 4)\n plt.imshow(local_entropy_ir, cmap='gray')\n plt.subplot(2, 3, 5)\n plt.imshow(local_contrast_ir, cmap='gray')\n plt.subplot(2, 3, 6)\n plt.imshow(visibility_ir, cmap='gray')\n plt.show()\n\n # Normalising weights of value channel and IR image\n weightN_value, weightN_ir = weight_normalization(weight_value, weight_ir)\n\n plt.subplot(1, 2, 1)\n plt.imshow(weightN_value, cmap='gray')\n plt.subplot(1, 2, 2)\n plt.imshow(weightN_ir, cmap='gray')\n plt.show()\n\n # Creating Gaussian pyramids of the weights maps of respectively the value channel and IR image\n gauss_pyr_value_weights = gaussian_pyramid(weightN_value, kernel, levels)\n gauss_pyr_ir_weights = gaussian_pyramid(weightN_ir, kernel, levels)\n\n # Creating Laplacian pyramids of respectively the value channel and IR image\n lap_pyr_value = laplacian_pyramid(value_channel, kernel, levels)\n lap_pyr_ir = laplacian_pyramid(im_ir, kernel, levels)\n\n # Creating the fused Laplacian of the two modalities\n lap_pyr_fusion = fused_laplacian_pyramid(gauss_pyr_value_weights, gauss_pyr_ir_weights, lap_pyr_value, lap_pyr_ir)\n\n i = 1\n for l in lap_pyr_fusion:\n plt.subplot(1, len(lap_pyr_fusion), i)\n plt.imshow(l, cmap='gray')\n i += 1\n plt.show()\n\n # Creating the Gaussian pyramid of value channel in order to collapse the fused Laplacian pyramid\n gauss_pyr_value = gaussian_pyramid(value_channel, kernel, levels)\n collapsed_image = collapse_pyramid(lap_pyr_fusion, gauss_pyr_value)\n\n # Replacing the value channel in HSV visible image by the collapsed image\n im_vis_hsv_fusion = im_vis_hsv.copy()\n im_vis_hsv_fusion[:, :, 2] = collapsed_image\n im_vis_rgb_fusion = hsv2rgb(im_vis_hsv_fusion)\n\n plt.subplot(1, 2, 1)\n plt.imshow(im_vis)\n plt.subplot(1, 2, 2)\n plt.imshow(im_vis_rgb_fusion)\n plt.show()","def analyse_colour_mag_diagrams(params,star_catalog,catalog_header,\n target,source,blend,RC,\n det_idx,cat_idx,close_cat_idx,log):\n\n tol = 2.0\n\n filters = { 'ip': 'SDSS-i', 'rp': 'SDSS-r', 'gp': 'SDSS-g' }\n\n inst_i = star_catalog['cal_ref_mag_ip'][det_idx]\n inst_r = star_catalog['cal_ref_mag_rp'][det_idx]\n inst_g = star_catalog['cal_ref_mag_gp'][det_idx]\n cal_i = star_catalog['imag'][cat_idx]\n cal_r = star_catalog['rmag'][cat_idx]\n cal_g = star_catalog['gmag'][cat_idx]\n inst_ri = inst_r - inst_i # Catalogue column order is red -> blue\n inst_gr = inst_g - inst_r\n inst_gi = inst_g - inst_i\n cal_ri = cal_r - cal_i\n cal_gr = cal_g - cal_r\n cal_gi = cal_g - cal_i\n\n linst_i = star_catalog['cal_ref_mag_ip'][close_cat_idx]\n linst_r = star_catalog['cal_ref_mag_rp'][close_cat_idx]\n linst_g = star_catalog['cal_ref_mag_gp'][close_cat_idx]\n lcal_i = star_catalog['imag'][close_cat_idx]\n lcal_r = star_catalog['rmag'][close_cat_idx]\n lcal_g = star_catalog['gmag'][close_cat_idx]\n linst_ri = linst_r - linst_i # Catalogue column order is red -> blue\n linst_gr = linst_g - linst_r\n linst_gi = linst_g - linst_i\n lcal_ri = lcal_r - lcal_i\n lcal_gr = lcal_g - lcal_r\n lcal_gi = lcal_g - lcal_i\n\n plot_colour_mag_diagram(params,inst_i, inst_ri, linst_i, linst_ri, target,\n source, blend, RC, 'r', 'i', 'i', tol, log)\n\n plot_colour_mag_diagram(params,inst_r, inst_ri, linst_r, linst_ri, target,\n source, blend, RC, 'r', 'i', 'r', tol, log)\n\n plot_colour_mag_diagram(params,inst_g, inst_gr, linst_g, linst_gr, target,\n source, blend, RC, 'g', 'r', 'g', tol, log)\n\n plot_colour_mag_diagram(params,inst_g, inst_gi, linst_g, linst_gi, target,\n source, blend, RC, 'g', 'i', 'g', tol, log)"],"string":"[\n \"def compare_CII_w_models(**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n if not p.xlim: p.xlim = [-4,2]\\n if not p.ylim: p.ylim = [4,10]\\n\\n fig,ax = plt.subplots(figsize=(8,6))\\n ax.set_ylim(p.ylim)\\n ax.set_xlim(p.xlim)\\n\\n # SIGAME Simba-100 ext ON (default run)\\n GR = glo.global_results(sim_run=p.sim_runs[1],nGal=p.nGals[1],grid_ext=p.grid_exts[1])\\n L_line = getattr(GR,'L_[CII]158_sun')\\n SFR = getattr(GR,'SFR')\\n # Phantom points to close contour lines...\\n L_line = np.append(L_line,np.array([1e8,10**9.3]))\\n SFR = np.append(SFR,np.array([0.1,10**0.85]))\\n lL_line = np.log10(L_line)\\n lSFR = np.log10(SFR)\\n lSFR = lSFR[L_line > 0]\\n lL_line = lL_line[L_line > 0]\\n # ax.plot(np.log10(SFR),np.log10(L_line),'o',ms=4,color='midnightblue',\\\\\\n # alpha=0.7,label='SIGAME with Simba-100',zorder=10)\\n # Evaluate a gaussian kde on a regular grid of nbins x nbins over data extents\\n nbins = 100\\n k = kde.gaussian_kde(np.column_stack([lSFR,lL_line]).T)\\n x, y = np.mgrid[lSFR.min():lSFR.max():nbins*1j,4:lL_line.max():nbins*1j]\\n z = k(np.vstack([x.flatten(), y.flatten()]))\\n CS = ax.contour(x, y, z.reshape(x.shape),colors='forestgreen',levels=6,zorder=10)\\n CS.collections[0].set_label('SIGAME 100Mpc_arepoPDF')\\n\\n # Select only MS galaxies\\n L_line = getattr(GR,'L_[CII]158_sun')\\n indices = aux.select_salim18(GR.M_star[L_line > 0],GR.SFR[L_line > 0])\\n print('With MS selection criteria: only %i galaxies' % (len(L_line)))\\n lSFR = lSFR[indices]\\n lL_line = lL_line[indices]\\n lSFR = np.append(lSFR,np.array([-1,0.85,1.5]))\\n lL_line = np.append(lL_line,np.array([8,9.3,8.4]))\\n nbins = 100\\n k = kde.gaussian_kde(np.column_stack([lSFR,lL_line]).T)\\n x, y = np.mgrid[lSFR.min():lSFR.max():nbins*1j,4:lL_line.max():nbins*1j]\\n z = k(np.vstack([x.flatten(), y.flatten()]))\\n CS = ax.contour(x, y, z.reshape(x.shape),colors='purple',linestyles='dashed',levels=6,zorder=10)\\n CS.collections[0].set_label('SIGAME 100Mpc_arepoPDF (MS)')\\n\\n\\n # SIGAME Simba-100 ext OFF\\n # GR = glo.global_results(sim_run=p.sim_runs[1],nGal=p.nGals[1],grid_ext=p.grid_exts[0])\\n # L_line = getattr(GR,'L_[CII]158_sun')\\n # SFR = getattr(GR,'SFR')\\n # # Phantom points to close contour lines...\\n # L_line = np.append(L_line,np.array([10.**9.2,1e8]))\\n # SFR = np.append(SFR,np.array([0.9,0.1]))\\n # lL_line = np.log10(L_line)\\n # lSFR = np.log10(SFR)\\n # lSFR = lSFR[L_line > 0]\\n # lL_line = lL_line[L_line > 0]\\n # # ax.plot(np.log10(SFR),np.log10(L_line),'o',ms=4,color='midnightblue',\\\\\\n # # alpha=0.7,label='SIGAME with Simba-100',zorder=10)\\n # # Evaluate a gaussian kde on a regular grid of nbins x nbins over data extents\\n # nbins = 100\\n # k = kde.gaussian_kde(np.column_stack([lSFR,\\\\\\n # lL_line]).T)\\n\\n # x, y = np.mgrid[lSFR.min():lSFR.max():nbins*1j, \\\\\\n # 4:lL_line.max():nbins*1j]\\n # z = k(np.vstack([x.flatten(), y.flatten()]))\\n # CS = ax.contour(x, y, z.reshape(x.shape),colors='brown',levels=6,linestyles='dotted')\\n # CS.collections[0].set_label('SIGAME 100Mpc_arepoPDF_no_ext')\\n\\n # SIGAME Simba-25\\n # GR = glo.global_results(sim_run=p.sim_runs[0],nGal=p.nGals[0])\\n # L_line = getattr(GR,'L_[CII]158_sun')\\n # SFR = getattr(GR,'SFR')\\n # ax.plot(np.log10(SFR),np.log10(L_line),'^',ms=6,color='darkorchid',alpha=0.7,label='SIGAME with Simba-25')\\n\\n # Observations in background\\n add_line_SFR_obs('[CII]158',L_line,ax,plot_fit=False)\\n\\n # Popping 2019\\n G19 = pd.read_csv(p.d_data + 'models/Popping2019.csv',skiprows=1,sep=' ',\\\\\\n names=['logSFR', 'logLCII', 'log LCII 14th percentile', 'log LCII 86th percentile'])\\n ax.plot(G19.logSFR,G19.logLCII,'k-',label='Popping 2019',alpha=0.8)\\n ax.fill_between(G19.logSFR,G19['log LCII 14th percentile'].values,\\\\\\n G19['log LCII 86th percentile'].values,color='grey',alpha=0.4)\\n\\n\\n # Padilla 2020\\n P20 = pd.read_csv(p.d_data + 'models/DataFig6.csv',skiprows=1,sep=',',\\\\\\n names=['IDSim','GalID','SFR','LCIITotal'])\\n P20['logLCII'] = np.log10(P20['LCIITotal'])\\n P20['logSFR'] = np.log10(P20['SFR'])\\n\\n\\n colors = ['cyan','orange','midnightblue']\\n nbins = 100\\n IDSims = ['Ref25','Recal25','Ref100']\\n for i,IDSim in enumerate(IDSims):\\n # Evaluate a gaussian kde on a regular grid of nbins x nbins over data extents\\n k = kde.gaussian_kde(np.column_stack([P20.logSFR.values[P20.IDSim == IDSim],\\\\\\n P20.logLCII.values[P20.IDSim == IDSim]]).T)\\n\\n xP20, yP20 = np.mgrid[P20.logSFR.min():P20.logSFR.max():nbins*1j, \\\\\\n 4:P20.logLCII.max():nbins*1j]\\n zP20 = k(np.vstack([xP20.flatten(), yP20.flatten()]))\\n # To remove weird contour line:\\n zP20.reshape(xP20.shape)[(xP20 > -1) & (yP20 < 5.5)] = 1e-5\\n zP20.reshape(xP20.shape)[(xP20 < -3)] = 1e-5\\n zP20.reshape(xP20.shape)[(xP20 < -2) & (yP20 > 8)] = 1e-5\\n zP20.reshape(xP20.shape)[(xP20 > 1) & (yP20 < 7)] = 1e-5\\n CS = ax.contour(xP20, yP20, zP20.reshape(xP20.shape),colors=colors[i],levels=5)\\n CS.collections[0].set_label('Ramos Padilla 2020 '+IDSim)\\n\\n\\n ax.set_xlabel('log '+getlabel('SFR'))\\n ax.set_ylabel('log '+getlabel('[CII]158'))\\n handles,labels = ax.get_legend_handles_labels()\\n handles = [handles[_] for _ in [8,9,10,11,12,7,0,1,2,3,4,5,6]]\\n labels = [labels[_] for _ in [8,9,10,11,12,7,0,1,2,3,4,5,6]]\\n plt.legend(handles,labels,fontsize=9,loc='upper left')\\n if p.savefig:\\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \\n plt.savefig(p.d_plot + 'luminosity/CII_SFR_w_models.png', format='png', dpi=300)\",\n \"def velo_inspec(self,ind1 = 1150*2, ind2 = 1185*2):\\n NeA = self.NeA[ind1:ind2]\\n NeB = self.NeB[ind1:ind2]\\n NeC = self.NeC[ind1:ind2]\\n\\n secondsA = self.secondsA[ind1:ind2]\\n secondsB = self.secondsB[ind1:ind2]\\n secondsC = self.secondsC[ind1:ind2]\\n\\n\\n mlatA = self.mlatA[ind1:ind2]\\n mlatB = self.mlatB[ind1:ind2]\\n mlatC = self.mlatC[ind1:ind2]\\n\\n mean_range = 5\\n NeA = self.meanie(NeA, mean_range)\\n NeB = self.meanie(NeB, mean_range)\\n NeC = self.meanie(NeC, mean_range)\\n\\n plt.figure(0)\\n plt.plot(mlatB, NeB, \\\"r\\\")\\n plt.plot(mlatA, NeA, \\\"g\\\")\\n plt.plot(mlatC, NeC, \\\"b\\\")\\n plt.xlabel(\\\"Geomagnetic Latitude [Degrees]\\\")\\n plt.ylabel(\\\"Electron density [cm$^{-3}$]\\\")\\n plt.legend([\\\"sat B\\\", \\\"sat A\\\", \\\"sat C\\\"])\\n plt.title(\\\"An interesting case\\\")\\n plt.grid(\\\"on\\\", axis = \\\"x\\\")\\n # plt.savefig(\\\"Figures/matfigs/interesting_case.pdf\\\")\\n plt.show()\\n \\n #calculate comparison index of data window\\n n = len(NeA)\\n NeA_ = NeA*np.hanning(n)\\n NeB_ = NeB*np.hanning(n)\\n NeC_ = NeC*np.hanning(n)\\n fftA = np.roll(np.fft.fft(NeA)[:int(n/2)], int(n/2))\\n fftB = np.roll(np.fft.fft(NeB)[:int(n/2)], int(n/2))\\n fftC = np.roll(np.fft.fft(NeC)[:int(n/2)], int(n/2))\\n freqs = np.linspace(-1, 1, n)[int(n/2):]\\n df = freqs[1]-freqs[0]\\n f = 0.1\\n i = int(f/df)\\n \\n plt.plot(mlatB, np.hanning(n))\\n plt.xlabel(\\\" \\\")\\n plt.ylabel(\\\"extensions\\\")\\n plt.show()\\n \\n plt.figure(69)\\n plt.plot(np.log10(freqs[1:]), np.log10(np.abs(fftA[1:])**2), \\\"g\\\")\\n plt.plot(np.log10(freqs[1:]), np.log10(np.abs(fftB[1:])**2), \\\"r\\\")\\n plt.plot(np.log10(freqs[1:]), np.log10(np.abs(fftC[1:])**2), \\\"b\\\")\\n plt.xticks([f, 0.2, 0.3])\\n plt.grid(\\\"on\\\")\\n plt.xlabel(\\\"Log10 Frequency [Hz]\\\")\\n plt.ylabel(\\\"Log10 PSD\\\")\\n plt.legend([\\\"Sat B\\\", \\\"Sat A\\\", \\\"Sat C\\\"])\\n plt.show()\\n \\n plt.plot(mlatB, NeB_, \\\"r\\\")\\n plt.plot(mlatA, NeA_, \\\"g\\\")\\n plt.plot(mlatC, NeC_, \\\"b\\\")\\n plt.legend([\\\"Sat B\\\", \\\"Sat A\\\", \\\"Sat C\\\"])\\n plt.show()\\n \\n sumA = np.sum(np.abs(fftA[i:])*df)\\n sumB = np.sum(np.abs(fftB[i:])*df)\\n sumC = np.sum(np.abs(fftC[i:])*df)\\n \\n I_BA = (sumB-sumA)/np.max([sumB, sumA])\\n I_BC = (sumB-sumC)/np.max([sumB, sumC])\\n I_AC = (sumA-sumC)/np.max([sumA, sumC])\\n \\n print(\\\"I_BA = %g\\\" % I_BA)\\n print(\\\"I_BC = %g\\\" % I_BC)\\n print(\\\"I_AC = %g\\\" % I_AC)\\n \\n \\n\\n dx = (secondsB[1] - secondsB[0])*self.velB[ind1]\\n der_NeA = (NeA[1:] - NeA[:-1])/dx\\n der_NeB = (NeB[1:] - NeB[:-1])/dx\\n der_NeC = (NeC[1:] - NeC[:-1])/dx\\n\\n\\n #doing a gaussian fit\\n from scipy.optimize import curve_fit\\n\\n def gaussian(x, amp, cen, wid):\\n \\\"\\\"\\\"1-d gaussian: gaussian(x, amp, cen, wid)\\\"\\\"\\\"\\n return (amp / (np.sqrt(2*np.pi) * wid)) * np.exp(-(x-cen)**2 / (2*wid**2))\\n\\n init_valsA = [4000, 1164, 0.5]\\n init_valsB = [4000, 1162, 0.5]\\n init_valsC = [4000, 1166, 0.5]\\n\\n poptA, pcovA = curve_fit(gaussian, secondsB[:-1],der_NeA , p0=init_valsA)\\n poptB, pcovB = curve_fit(gaussian, secondsB[:-1],der_NeB , p0=init_valsB)\\n poptC, pcovC = curve_fit(gaussian, secondsB[:-1],der_NeC , p0=init_valsC)\\n\\n\\n lats = np.linspace(mlatB[0], mlatB[-1], 100)\\n times = np.linspace(secondsB[0], secondsB[-1], 100)\\n yA = gaussian(times, poptA[0], poptA[1], poptA[2])\\n yB = gaussian(times, poptB[0], poptB[1], poptB[2])\\n yC = gaussian(times, poptC[0], poptC[1], poptC[2])\\n\\n\\n plt.figure(1)\\n plt.plot(lats, yB, \\\"--r\\\")\\n plt.plot(mlatB[:-1], der_NeB, \\\"r\\\")\\n\\n plt.plot(lats, yA, \\\"--g\\\")\\n plt.plot(mlatA[:-1], der_NeA, \\\"g\\\")\\n\\n plt.plot(lats, yC, \\\"--b\\\")\\n plt.plot(mlatC[:-1], der_NeC, \\\"b\\\")\\n plt.legend([\\\"fit B\\\", \\\"sat B\\\", \\\"fit A\\\", \\\"sat A\\\", \\\"fit C\\\", \\\"sat C\\\"])\\n\\n plt.title(\\\"Density gradients\\\")\\n plt.xlabel(\\\"Geomagnetic latitude [Degrees]\\\")\\n plt.ylabel(\\\"Electron density gradient [$cm^{-3}/m$]\\\")\\n plt.grid(\\\"on\\\", axis = \\\"x\\\")\\n # plt.savefig(\\\"Figures/matfigs/interesting_case_deri.pdf\\\")\\n\\n\\n vsat = np.mean(self.velA) #velocity of satellites\\n sBA = self.BA_shift/2 #time delay BA\\n sBC = self.BC_shift/2 #time delay BC\\n sAC = (self.BC_shift - self.BA_shift)/2\\n\\n nBA = poptB[1] - poptA[1] #time between tops in difference plot\\n nBC = poptB[1] - poptC[1] #time between tops in difference plot\\n nAC = poptA[1] - poptC[1]\\n\\n vBA = vsat*(1 - (sBA / (sBA - nBA))) #finding bubble velocity\\n vBC = vsat*(1 - (sBC / (sBC - nBC))) #finding bubble velocity\\n vAC = vsat*(1 - (sAC / (sAC - nAC)))\\n\\n\\n\\n NBA = int(np.abs(nBA)*2)\\n NBC = int(np.abs(nBC)*2)\\n\\n fixed_NeA = self.NeA[ind1 + NBA: ind2 + NBA]\\n fixed_NeB = self.NeB[ind1:ind2]\\n fixed_NeC = self.NeC[ind1 + NBC: ind2 + NBC]\\n\\n fixed_NeA = self.meanie(fixed_NeA, mean_range)\\n fixed_NeB = self.meanie(fixed_NeB, mean_range)\\n fixed_NeC = self.meanie(fixed_NeC, mean_range)\\n\\n plt.figure(2)\\n plt.plot(mlatB, fixed_NeB, \\\"r\\\")\\n plt.plot(mlatB, fixed_NeA, \\\"g\\\")\\n plt.plot(mlatB, fixed_NeC, \\\"b\\\")\\n plt.xlabel(\\\"Geomagnetic Latitude [Degrees]\\\")\\n plt.ylabel(\\\"Electron density [cm$^{-3}$]\\\")\\n plt.legend([\\\"sat B\\\", \\\"sat A\\\", \\\"sat C\\\"])\\n plt.title(\\\"An interesting case, shifted\\\")\\n plt.grid(\\\"on\\\", axis = \\\"x\\\")\\n # plt.savefig(\\\"Figures/matfigs/interesting_case_shifted.pdf\\\")\\n\\n\\n print(\\\"Bubble velocity calculated from BA = %g [m/s]\\\" % vBA)\\n print(\\\"Bubble velocity calculated from BC = %g [m/s]\\\" % vBC)\\n print(\\\"Bubble velocity calculated from AC = %g [m/s]\\\" % vAC)\\n print(nBA)\\n print(nBC)\\n print(nAC)\\n print(sBA)\\n print(sBC)\\n print(sAC)\",\n \"def compare_models(model1,model2):\\n\\n # initialisation:\\n n_radial = 0\\n n_radial_numax = 0\\n n_non_radial = 0\\n n_non_radial_numax = 0\\n result = np.zeros((6+nglb,),dtype=gtype)\\n # define frequency interval around numax:\\n numax = 0.5*(model1.numax/model1.glb[ifreq_ref] \\\\\\n + model2.numax/model2.glb[ifreq_ref])\\n a = 0.8*numax\\n b = 1.2*numax\\n\\n # compare frequency spectra:\\n size1 = len(model1.modes)\\n size2 = len(model2.modes)\\n i1 = i2 = 0\\n while((i1 < size1) and (i2 < size2)):\\n if (model1.modes['l'][i1] < model2.modes['l'][i2]): i1+=1; continue\\n if (model1.modes['l'][i1] > model2.modes['l'][i2]): i2+=1; continue\\n if (model1.modes['n'][i1] < model2.modes['n'][i2]): i1+=1; continue\\n if (model1.modes['n'][i1] > model2.modes['n'][i2]): i2+=1; continue\\n\\n # now the two modes have the same n and l values:\\n diff = abs(model1.modes['freq'][i1] - model2.modes['freq'][i2])\\n avg_freq =(model1.modes['freq'][i1] + model2.modes['freq'][i2])/2.0\\n if (model1.modes['l'][i1] == 0):\\n if (result[0] < diff): result[0] = diff\\n diff *= diff # square diff\\n result[1] += diff\\n n_radial += 1\\n # in python, this is called an interval comparison:\\n if (a <= avg_freq <= b):\\n result[2] += diff\\n n_radial_numax += 1\\n else:\\n if (result[3] < diff): result[3] = diff\\n diff *= diff # square diff\\n result[4] += diff\\n n_non_radial += 1\\n if (a <= avg_freq <= b):\\n result[5] += diff\\n n_non_radial_numax += 1\\n i1+=1\\n i2+=1\\n\\n # avoid divisions by zero:\\n if (n_radial > 0):\\n result[1] = math.sqrt(result[1]/float(n_radial))\\n else:\\n result[1] = np.nan\\n\\n if (n_radial_numax > 0):\\n result[2] = math.sqrt(result[2]/float(n_radial_numax))\\n else:\\n result[2] = np.nan\\n\\n if (n_non_radial > 0):\\n result[4] = math.sqrt(result[4]/float(n_non_radial))\\n else:\\n result[4] = np.nan\\n\\n if (n_non_radial_numax > 0):\\n result[5] = math.sqrt(result[5]/float(n_non_radial_numax))\\n else:\\n result[5] = np.nan\\n\\n # absolute differences on global parameters:\\n result[6:6+nglb] = np.absolute(model1.glb - model2.glb)\\n\\n return result\",\n \"def residmapComparison():\\n srcmap001 = fits.open('dataFiles/6gev_srcmap_001.fits')\\n srcmap03 = fits.open('dataFiles/6gev_srcmap_03.fits')\\n\\n image_data = fits.getdata('dataFiles/6gev_image.fits')\\n filename = get_pkg_data_filename('dataFiles/6gev_image.fits')\\n hdu = fits.open(filename)[0]\\n wcs = WCS(hdu.header)\\n\\n #Given the results of the fit, calculate the model\\n modelData001 = np.zeros(srcmap001[0].shape)\\n modelData03 = np.zeros(srcmap03[0].shape)\\n\\n file = open('plotsData/fitResults001.pk1','rb')\\n fit001 = pickle.load(file)\\n file.close()\\n\\n file = open('plotsData/fitResults03.pk1','rb')\\n fit03 = pickle.load(file)\\n file.close()\\n\\n\\n for source in fit001:\\n the_index = srcmap001.index_of(source)\\n\\n modelData001 += fit001[source][:, None, None]*srcmap001[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap001[the_index].data, axis=2), axis=1)[:-1, None, None]\\n for source in fit03:\\n the_index = srcmap03.index_of(source)\\n modelData03 += fit03[source][:, None, None]*srcmap03[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap03[the_index].data, axis=2), axis=1)[:-1, None, None]\\n\\n fig = plt.figure(figsize=[12, 4.5])\\n\\n vmin = -25.0\\n vmax = 25.0\\n cbStep = 5.0\\n ax = fig.add_subplot(121, projection=wcs)\\n ax=plt.gca()\\n ax.tick_params(direction='in')\\n c = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax.get_transform('galactic'))\\n ax.add_patch(c)\\n mappable=plt.imshow((image_data-np.sum(modelData001,axis=0)),cmap='seismic',origin='lower',vmin=vmin, vmax=vmax, interpolation='gaussian')#\\n plt.xlabel('Galactic Longitude')\\n plt.ylabel('Galactic Latitude')\\n plt.title('GC Point Source ($>6$ GeV)')\\n cb = plt.colorbar(mappable, label='Residual counts per pixel', pad=0.01,ticks=np.arange(vmin, vmax+cbStep, cbStep))\\n cb.ax.tick_params(width=0)\\n\\n\\n ax2=fig.add_subplot(122, projection=wcs)\\n ax2 = plt.gca()\\n c2 = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax2.get_transform('galactic'))\\n ax2.add_patch(c2)\\n mappable2 = plt.imshow((image_data-np.sum(modelData03,axis=0)), cmap='seismic',origin='lower',vmin=vmin, vmax=vmax, interpolation='gaussian')\\n plt.xlabel('Galactic Longitude')\\n plt.ylabel('Galactic Latitude')\\n plt.title('GC Extended Source ($>6$ GeV)')\\n cb2 = plt.colorbar(mappable2, label='Residual counts per pixel', pad=0.01, ticks=np.arange(vmin, vmax+cbStep, cbStep))\\n cb2.ax.tick_params(width=0)\\n fig.tight_layout()\\n plt.subplots_adjust(wspace = 0.13, left=0.04, bottom=0.13, top=0.92)\\n #plt.savefig('plots/residComparison.pdf',bbox_inches='tight')\\n plt.show()\",\n \"def dop_comp(field) :\\n dop = fits.open(field+'/'+field+'_rv.fits')\\n r13 = apload.ApLoad(apred='r13')\\n old = r13.apField(field)\\n\\n i1,i2 = match.match(dop[1].data['APOGEE_ID'],old[1].data['APOGEE_ID'])\\n print(len(dop[1].data),len(old[1].data),len(i1))\\n\\n fig,ax=plots.multi(1,1)\\n plots.plotc(ax,dop[1].data['RV_TEFF'][i1],dop[1].data['VHELIO_AVG'][i1]-old[1].data['VHELIO_AVG'][i2],dop[1].data['VSCATTER'][i1])\\n\\n j=np.argsort(np.abs(dop[1].data['VHELIO_AVG'][i1]-old[1].data['VHELIO_AVG'][i2],dop[1].data['VSCATTER'][i1]))\\n\\n plots._data = dop[1].data\\n plots._id_cols=['APOGEE_ID']\\n plots.event(fig)\\n key=' '\\n sf,sax=plots.multi(1,2,sharex=True,hspace=0.001)\\n while key != 'e' :\\n x,y,key,index = plots.mark(fig,index=True)\\n obj = dop[1].data['APOGEE_ID'][i1[index]]\\n #jv = np.where(dop[2].data['APOGEE_ID'] == dop[1].data['APOGEE_ID'][i1])[0]\\n out=pickle.load(open(field+'/'+obj+'_out.pkl','rb'))\\n print(obj,old[1].data['APOGEE_ID'][i2[index]])\\n print(out[0])\\n sax[0].cla()\\n spec=old[2].data['SPEC'][i2[index]]\\n plots.plotl(sax[0],old[3].data['WAVE'][0,:],spec/convolve(spec,np.ones(500)/500,mode='same'),xr=[15000,17000],yr=[0.5,1.5])\\n for mod,obs in zip(out[2],out[3]) :\\n sax[1].cla()\\n for chip in range(3) :\\n plots.plotl(sax[1],obs.wave[:,chip],obs.flux[:,chip],color='k',yr=[0.5,1.5])\\n gd = np.where(obs.mask[:,chip] == False)[0]\\n plots.plotl(sax[1],obs.wave[gd,chip],obs.flux[gd,chip],color='g')\\n plots.plotl(sax[1],mod.wave[:,chip],mod.flux[:,chip],color='r')\\n plt.draw()\\n input('hit a key: ')\",\n \"def compare_SIGAME_runs(names,**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n d_results = p.d_data + 'results/'\\n\\n lines = ['[NII]205','[NII]122','[OIII]88','[CII]158','[OI]63','CO(1-0)','CO(2-1)','CO(3-2)']\\n\\n # Select parameters\\n GR1 = pd.read_pickle(d_results + names[0])\\n GR2 = pd.read_pickle(d_results + names[1])\\n \\n # Quick check as function of Z\\n fig, ax = plt.subplots(facecolor='w',figsize=(8,6))\\n Zsfr = GR1['Zsfr'].values\\n dex = np.log10(GR1['L_[NII]122_sun'].values) - np.log10(GR2['L_[NII]122_sun'].values)\\n ax.plot(Zsfr,dex,'o')\\n plt.savefig(p.d_plot+'luminosity/test_comp_Z',dpi=250)\\n GR1['dex'] = dex\\n print(GR1.sort_values('Zsfr')[['dex','gal_num','Zsfr']])\\n\\n props = ['M_star','M_gas','SFR','Zsfr']\\n x1 = np.log10(np.column_stack([GR1.M_star,GR1.M_gas,GR1.SFR,GR1.Zsfr]))\\n x2 = np.log10(np.column_stack([GR2.M_star,GR2.M_gas,GR2.SFR,GR2.Zsfr]))\\n n_param = len(props)\\n\\n # Set up plot\\n cmap = plt.get_cmap('gist_rainbow_r')\\n cmap = plt.get_cmap('brg')\\n colors = [cmap(i) for i in np.linspace(0, 1, len(lines))]\\n fig, axs = plt.subplots(nrows=1, ncols=n_param, \\\\\\n figsize=(22,5),facecolor='w',\\\\\\n gridspec_kw={'hspace': 0, 'wspace': 0.35,'left':0.05,'right':0.95})\\n\\n bins = 8\\n\\n # For bins in props, calcualte mean and std of difference between the two model results\\n for iprop,prop in enumerate(props):\\n ax = axs[iprop]\\n data = np.append(GR1[prop].values,GR2[prop].values)\\n grid_points = np.linspace(np.log10(np.min(data)),np.log10(np.max(data)),bins)\\n if prop == 'M_star': grid_points = np.linspace(np.log10(np.min(data)),np.log10(3.5e11),bins)\\n if prop == 'SFR': grid_points = np.linspace(np.log10(np.min(data)),np.log10(30),bins)\\n grid_points_c = grid_points[1::] - (grid_points[1]-grid_points[0])/2.\\n ax.plot([np.min(grid_points_c),np.max(grid_points_c)],[0,0],'--k',lw=1.5)\\n for iline,line in enumerate(lines):\\n meandex = np.zeros([len(grid_points_c)])\\n mediandex = np.zeros([len(grid_points_c)])\\n mindex = np.zeros([len(grid_points_c)])\\n maxdex = np.zeros([len(grid_points_c)])\\n mindex1 = np.zeros([len(grid_points_c)])\\n maxdex1 = np.zeros([len(grid_points_c)])\\n line_GR1 = GR1['L_'+line+'_sun'].values\\n line_GR2 = GR2['L_'+line+'_sun'].values\\n GR1cut = GR1[(line_GR1 > 0) & (line_GR2 > 0)].reset_index(drop=True)\\n GR2cut = GR2[(line_GR1 > 0) & (line_GR2 > 0)].reset_index(drop=True)\\n line_GR1 = GR1cut['L_'+line+'_sun'].values\\n line_GR2 = GR2cut['L_'+line+'_sun'].values\\n devs = np.log10(line_GR1) - np.log10(line_GR2)\\n for i in range(len(grid_points_c)):\\n select = np.argwhere((GR1cut[prop].values >= 10.**grid_points[i]) & (GR1cut[prop].values < 10.**grid_points[i+1]))\\n if iline == 0: print(len(select))\\n if len(select) >= 1:\\n meandex[i] = np.mean(devs[select])\\n mediandex[i] = np.median(devs[select])\\n mindex[i] = np.mean(devs[select]) - np.std(devs[select]) \\n maxdex[i] = np.mean(devs[select]) + np.std(devs[select]) \\n mindex1[i] = np.quantile(devs[select],0.25)\\n maxdex1[i] = np.quantile(devs[select],0.75)\\n grid_points_plot = grid_points_c[meandex != 0]\\n mindex = mindex[meandex != 0]\\n mindex1 = mindex1[meandex != 0]\\n maxdex = maxdex[meandex != 0]\\n maxdex1 = maxdex1[meandex != 0]\\n mediandex = mediandex[meandex != 0]\\n meandex = meandex[meandex != 0]\\n ax.plot(grid_points_plot,mediandex,marker='o',ms=5,lw=2,color=colors[iline],label=line,zorder=10)\\n ax.fill_between(grid_points_plot,mindex1,maxdex1,\\\\\\n color=colors[iline],alpha=0.3)\\n if iline == 0: \\n global_ymin = np.min(mindex)\\n else:\\n if np.min(mindex) < global_ymin: global_ymin = np.min(mindex)\\n\\n ax.set_ylim([-1.5,1.5])\\n if p.ylim: ax.set_ylim([global_ymin-0.2,p.ylim[1]])\\n\\n ax.set_ylabel(r'Median $\\\\Delta$ luminosity [dex]')# + getlabel(line))\\n if prop == 'M_star':\\n ax.set_xlim([ax.get_xlim()[0],ax.get_xlim()[1]+0.3])\\n ax.legend(fontsize=9,loc='upper right')\\n ax.set_xlabel('log '+getlabel(prop))\\n\\n if p.savefig:\\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \\n plt.savefig(p.d_plot + 'luminosity/compare_%s_w_%s.png' % (names[0],names[1]), format='png', dpi=300) # .eps for paper!\",\n \"def test1():\\n\\t\\n\\td = np.arange(-10000,10000,10) # MHz\\n\\t#Voigt\\n\\tp_dict = {'Bfield':300,'rb85frac':1,'Btheta':0,'lcell':75e-3,'T':58,'Dline':'D2','Elem':'Cs'}\\n\\t\\n\\t#timing:\\n\\tst = time.clock()\\n\\tTF = get_spectra(d,[1,0,0],p_dict,outputs=['Iy'])\\n\\tet = time.clock() - st\\n\\tprint(('E-field - Elapsed time (s):', et))\\n\\n\\t'''\\n\\t#check vs old elecsus\\n\\tfrom elecsus_v2.libs import spectra as old_spec\\n\\tst = time.clock()\\n\\tTF_old = old_spec.get_spectra(d,p_dict,outputs=['Iy'])\\n\\tet = time.clock() - st\\n\\tprint 'Old elecsus - Elapsed time (s):', et\\n\\t'''\\n\\t\\n\\tfig = plt.figure(\\\"Faraday comparison\\\")\\n\\tax1 = fig.add_subplot(111)\\n\\tax1.plot(d,TF[0],'r',lw=2,label='Faraday')\\n\\t#ax1.plot(d,TF_old[0],'k--',lw=2,label='Vanilla ElecSus')\\n\\t\\n\\t#ax1.legend(loc=0)\\n\\t\\n\\tax1.set_xlabel('Detuning (MHz)')\\n\\tax1.set_ylabel('Transmission')\\n\\t\\n\\tplt.show()\",\n \"def match_det2cube(self, input_model,\\n x, y, file_slice_no,\\n this_par1, this_par2,\\n spaxel,\\n c1_offset, c2_offset):\\n\\n#________________________________________________________________________________\\n if self.instrument == 'MIRI':\\n\\n det2ab_transform = input_model.meta.wcs.get_transform('detector', 'alpha_beta')\\n detector2v23 = input_model.meta.wcs.get_transform('detector', 'v2v3')\\n v23toworld = input_model.meta.wcs.get_transform(\\\"v2v3\\\", \\\"world\\\")\\n worldtov23 = input_model.meta.wcs.get_transform(\\\"world\\\", \\\"v2v3\\\")\\n v2ab_transform = input_model.meta.wcs.get_transform('v2v3',\\n 'alpha_beta')\\n\\n alpha, beta, wave = det2ab_transform(x, y)\\n v2, v3, lam23 = detector2v23(x, y)\\n ra, dec, lam = v23toworld(v2, v3, lam23)\\n\\n valid1 = np.isfinite(v2)\\n valid2 = np.isfinite(v3)\\n\\n if self.weighting == 'miripsf':\\n wave_resol = self.instrument_info.Get_RP_ave_Wave(this_par1, this_par2)\\n alpha_resol = self.instrument_info.Get_psf_alpha_parameters()\\n beta_resol = self.instrument_info.Get_psf_beta_parameters()\\n\\n # transform Cube Spaxel centers to alpha,beta of exposure\\n # for MIRI weighting parameters are based on distance in\\n # alpha-beta coord system\\n # transform the cube coordinate values to alpha and beta values\\n # xi,eta -> ra,dec\\n # world -> v2,v3\\n # v2,v3 -> local alpha,beta\\n\\n elif self.instrument == 'NIRSPEC':\\n islice = file_slice_no\\n slice_wcs = nirspec.nrs_wcs_set_input(input_model, islice)\\n\\n x, y = wcstools.grid_from_bounding_box(slice_wcs.bounding_box, \\n step=(1, 1), center=True)\\n ra, dec, lam = slice_wcs(x, y) # return v2,v3 are in degrees\\n valid1 = np.isfinite(ra)\\n valid2 = np.isfinite(dec)\\n#________________________________________________________________________________\\n#________________________________________________________________________________\\n# Slices are curved on detector. A slice region is grabbed by corner regions so\\n# the region returned may include pixels not value for slice. There are gaps\\n# between the slices. Pixels not belonging to a slice are assigned NaN values.\\n\\n x = x.astype(np.int)\\n y = y.astype(np.int)\\n\\n flux_all = input_model.data[y, x]\\n# error_all = input_model.err[y, x]\\n dq_all = input_model.dq[y, x]\\n\\n valid3 = np.isfinite(lam)\\n valid4 = np.isfinite(flux_all)\\n valid = valid1 & valid2 & valid3 & valid4\\n#________________________________________________________________________________\\n# using the DQFlags from the input_image find pixels that should be excluded\\n# from the cube mapping\\n all_flags = (dqflags.pixel['DO_NOT_USE'] + dqflags.pixel['DROPOUT'] +\\n dqflags.pixel['NON_SCIENCE'] +\\n dqflags.pixel['DEAD'] + dqflags.pixel['HOT'] +\\n dqflags.pixel['RC'] + dqflags.pixel['NONLINEAR'])\\n\\n # find the location of all the values to reject in cube building\\n good_data = np.where((np.bitwise_and(dq_all, all_flags) == 0) & (valid == True))\\n\\n # good data holds the location of pixels we want to map to cube\\n flux = flux_all[good_data]\\n# error = error_all[good_data]\\n wave = lam[good_data]\\n\\n# xpix = x[good_data] # only used for testing\\n# ypix = y[good_data] # only used for testing\\n\\n ra = ra - c1_offset / 3600.0\\n dec = dec - c2_offset / 3600.0\\n ra_use = ra[good_data]\\n dec_use = dec[good_data]\\n if self.instrument == 'MIRI':\\n # need alpha,beta if weigthing is miripsf or cubes in alpha-beta space\\n alpha_det = alpha[good_data]\\n beta_det = beta[good_data]\\n# MIRI can make cubes in alpha-beta:\\n if self.coord_system == 'alpha-beta':\\n coord1 = alpha[good_data]\\n coord2 = beta[good_data]\\n\\n else:\\n# xi,eta in arc seconds\\n xi, eta = coord.radec2std(self.Crval1, self.Crval2, ra_use, dec_use)\\n coord1 = xi\\n coord2 = eta\\n\\n nplane = self.naxis1 * self.naxis2\\n lower_limit = 0.01\\n\\n# iprint = 0\\n# now loop over the pixel values for this region and find the spaxels that fall\\n# withing the region of interest.\\n nn = coord1.size\\n\\n# print('looping over n points mapping to cloud',nn)\\n#________________________________________________________________________________\\n for ipt in range(0, nn - 1):\\n#________________________________________________________________________________\\n # Cube.Xcenters, ycenters is a flattened 1-D array of the 2 X 2 xy plane\\n # cube coordinates.\\n # find the spaxels that fall withing ROI of point cloud defined by\\n # coord1,coord2,wave\\n# if(ipt > 2): sys.exit('STOP')\\n# print('For point ',coord1[ipt],coord2[ipt],wave[ipt],ipt)\\n\\n# if(ipt == 0):\\n# print('size of Xcenters',self.Xcenters.size)\\n xdistance = (self.Xcenters - coord1[ipt])\\n ydistance = (self.Ycenters - coord2[ipt])\\n radius = np.sqrt(xdistance * xdistance + ydistance * ydistance)\\n indexr = np.where(radius <= self.rois)\\n indexz = np.where(abs(self.zcoord - wave[ipt]) <= self.roiw)\\n\\n# print('indexz',indexz)\\n# print('indexr',indexr)\\n zlam = self.zcoord[indexz] # z Cube values falling in wavelength roi\\n xi_cube = self.Xcenters[indexr] # x Cube values within radius\\n eta_cube = self.Ycenters[indexr] # y cube values with the radius\\n\\n# print('found xi_cube',xi_cube)\\n# print('found eta_cube',eta_cube)\\n\\n#________________________________________________________________________________\\n# loop over the points in the ROI\\n for iz, zz in enumerate(indexz[0]):\\n istart = zz * nplane\\n for ir, rr in enumerate(indexr[0]):\\n# yy_cube = int(rr / self.naxis1)\\n# xx_cube = rr - yy_cube * self.naxis1\\n# print('xx yy cube',rr,self.naxis1,xx_cube,yy_cube)\\n#________________________________________________________________________________\\n if self.weighting == 'msm':\\n d1 = (xi_cube[ir] - coord1[ipt]) / self.Cdelt1\\n d2 = (eta_cube[ir] - coord2[ipt]) / self.Cdelt2\\n d3 = (zlam[iz] - wave[ipt]) / self.Cdelt3\\n\\n weight_distance = math.sqrt(d1 * d1 + d2 * d2 + d3 * d3)\\n weight_distance = math.pow(weight_distance, self.weight_power)\\n#________________________________________________________________________________\\n# if weight is miripsf -distances determined in alpha-beta coordinate system\\n elif self.weighting == 'miripsf':\\n weights = FindNormalizationWeights(wave[ipt],\\n wave_resol,\\n alpha_resol,\\n beta_resol)\\n\\n\\n ra_spaxel, dec_spaxel = coord.std2radec(self.Crval1,\\n self.Crval2,\\n xi_cube[ir],\\n eta_cube[ir])\\n\\n v2_spaxel, v3_spaxel, zl = worldtov23(ra_spaxel,\\n dec_spaxel,\\n zlam[iz])\\n\\n alpha_spaxel, beta_spaxel, wave_spaxel = v2ab_transform(v2_spaxel,\\n v3_spaxel,\\n zlam[iz])\\n alpha_distance = alpha_det[ipt] - alpha_spaxel\\n beta_distance = beta_det[ipt] - beta_spaxel\\n wave_distance = abs(wave[ipt] - wave_spaxel)\\n\\n xn = alpha_distance / weights[0]\\n yn = beta_distance / weights[1]\\n wn = wave_distance / weights[2]\\n\\n # only included the spatial dimensions\\n weight_distance = math.sqrt(xn * xn + yn * yn + wn * wn)\\n weight_distance = math.pow(weight_distance, self.weight_power)\\n#________________________________________________________________________________\\n# We have found the weight_distance based on instrument type\\n\\n if weight_distance < lower_limit: weight_distance = lower_limit\\n weight_distance = 1.0 / weight_distance\\n\\n cube_index = istart + rr\\n spaxel[cube_index].flux = spaxel[cube_index].flux + weight_distance * flux[ipt]\\n spaxel[cube_index].flux_weight = spaxel[cube_index].flux_weight + weight_distance\\n spaxel[cube_index].iflux = spaxel[cube_index].iflux + 1\",\n \"def test_detector1pipeline4(_bigdata):\\n step = Detector1Pipeline()\\n step.save_calibrated_ramp = True\\n step.ipc.skip = True\\n step.persistence.skip = True\\n step.jump.rejection_threshold = 4.0\\n step.ramp_fit.save_opt = False\\n step.output_file = 'jw84600007001_02101_00001_nrs1_rate.fits'\\n step.run(_bigdata+'/pipelines/jw84600007001_02101_00001_nrs1_uncal.fits')\\n\\n # Compare ramp product\\n n_ramp = 'jw84600007001_02101_00001_nrs1_ramp.fits'\\n h = fits.open( n_ramp )\\n n_ref = _bigdata+'/pipelines/jw84600007001_02101_00001_nrs1_ramp_ref.fits'\\n href = fits.open( n_ref )\\n newh = fits.HDUList([h['primary'],h['sci'],h['err'],h['groupdq'],h['pixeldq']])\\n newhref = fits.HDUList([href['primary'],href['sci'],href['err'],href['groupdq'],h['pixeldq']])\\n result = fits.diff.FITSDiff(newh,\\n newhref,\\n ignore_keywords = ['DATE','CAL_VER','CAL_VCS','CRDS_VER','CRDS_CTX'],\\n rtol = 0.00001\\n )\\n assert result.identical, result.report()\\n\\n # Compare countrate image product\\n n_cr = 'jw84600007001_02101_00001_nrs1_rate.fits'\\n h = fits.open( n_cr )\\n n_ref = _bigdata+'/pipelines/jw84600007001_02101_00001_nrs1_rate_ref.fits'\\n href = fits.open( n_ref )\\n newh = fits.HDUList([h['primary'],h['sci'],h['err'],h['dq']])\\n newhref = fits.HDUList([href['primary'],href['sci'],href['err'],href['dq']])\\n result = fits.diff.FITSDiff(newh,\\n newhref,\\n ignore_keywords = ['DATE','CAL_VER','CAL_VCS','CRDS_VER','CRDS_CTX'],\\n rtol = 0.00001\\n )\\n assert result.identical, result.report()\",\n \"def nzErr(xerr, yerr, vxerr, vyerr, year_x, year_y, mag, alnDir = '13_08_21/', chainsDir = 'efit/chains_S0-2_newRV2/'):\\n\\n #Read in values for error in position and velocity of sgr*\\n origin_val = asciidata.open('/g/ghez/align/' + alnDir + chainsDir + 'efit_summary.txt')\\n ori_x0e = origin_val[25][0]\\n ori_y0e = origin_val[26][0]\\n ori_vxe = origin_val[27][0]\\n ori_vye = origin_val[28][0]\\n t_0 = 2000.0 #hard coded t_0 of sgr*\\n\\n # magBins=np.array([9,11,12,13,14,15,16,17,18,19,20,21])\\n # deltaArr=np.array([3.5,71.0,58.0,210.0,300.0,650.0,700.0,1100.0,1900.0,2200.0,3000.0])*1e-6\\n\\n# delta = mag*0.0\\n# for i in range(len(mag)):\\n# for j in range(len(deltaArr)):\\n# if ((mag[i] > magBins[j]) & (mag[i] <= magBins[j+1])):\\n# delta[i]=deltaArr[j]\\n\\n#pdb.set_trace()\\n\\n #Update errors\\n xerr = np.sqrt(xerr**2 + ori_x0e**2 + ((year_x - t_0)*ori_vxe)**2)\\n yerr = np.sqrt(yerr**2 + ori_y0e**2 + ((year_y - t_0)*ori_vye)**2)\\n vxerr = np.sqrt(vxerr**2 + ori_vxe**2)\\n vyerr = np.sqrt(vyerr**2 + ori_vye**2)\\n\\n return xerr, yerr, vxerr, vyerr\",\n \"def test_compare_outputs_surface_form(self):\\n # load models\\n options = [\\n {\\\"surface form\\\": cap} for cap in [\\\"false\\\", \\\"differential\\\", \\\"algebraic\\\"]\\n ]\\n model_combos = [\\n ([pybamm.lead_acid.LOQS(opt) for opt in options]),\\n ([pybamm.lead_acid.Full(opt) for opt in options]),\\n ]\\n\\n for models in model_combos:\\n # load parameter values (same for all models)\\n param = models[0].default_parameter_values\\n param.update({\\\"Current function [A]\\\": 1})\\n for model in models:\\n param.process_model(model)\\n\\n # set mesh\\n var_pts = {\\\"x_n\\\": 5, \\\"x_s\\\": 5, \\\"x_p\\\": 5}\\n\\n # discretise models\\n discs = {}\\n for model in models:\\n geometry = model.default_geometry\\n param.process_geometry(geometry)\\n mesh = pybamm.Mesh(geometry, model.default_submesh_types, var_pts)\\n disc = pybamm.Discretisation(mesh, model.default_spatial_methods)\\n disc.process_model(model)\\n discs[model] = disc\\n\\n # solve model\\n solutions = []\\n t_eval = np.linspace(0, 3600 * 20, 100)\\n for model in models:\\n solution = pybamm.CasadiSolver().solve(model, t_eval)\\n solutions.append(solution)\\n\\n # compare outputs\\n comparison = StandardOutputComparison(solutions)\\n comparison.test_all(skip_first_timestep=True)\",\n \"def dr14comp(a,b,av,bv):\\n load=apload.ApLoad(apred='r11')\\n dr14=apload.ApLoad(dr='dr14')\\n\\n i1,i2=match.match(a['APOGEE_ID'],b['APOGEE_ID'])\\n gd = np.where((a['NVISITS'][i1] == b['NVISITS'][i2]) & (a['SNR'][i1]>75) )[0]\\n a=a[i1[gd]]\\n b=b[i2[gd]]\\n \\n j=np.argsort(a['VHELIO_AVG']-b['VHELIO_AVG'])\\n \\n fig,ax=plots.multi(1,3,hspace=0.3) \\n pfig,pax=plots.multi(1,3,hspace=0.3) \\n wfig,wax=plots.multi(1,3,hspace=0.3) \\n chips=['a','b','c']\\n for jj in j :\\n j1=np.where(av['APOGEE_ID'] == a['APOGEE_ID'][jj])[0]\\n j2=np.where(bv['APOGEE_ID'] == a['APOGEE_ID'][jj])[0]\\n print(a['APOGEE_ID'][jj],a['RV_TEFF'][jj],b['RV_TEFF'][jj],a['SNR'][jj],b['SNR'][jj])\\n for jjj,kkk in zip(j1,j2) : \\n print(av['MJD'][jjj],av['PLATE'][jjj],av['FIELD'][jjj],av['SNR'][jjj],av['FIBERID'][jjj],av['VHELIO'][jjj],av['ESTVHELIO'][jjj])\\n print(bv['MJD'][kkk],bv['PLATE'][kkk],bv['FIELD'][kkk],bv['SNR'][kkk],bv['FIBERID'][kkk],bv['VHELIO'][kkk],bv['ESTVHELIO'][kkk])\\n va=load.apPlate(int(av['PLATE'][jjj]),av['MJD'][jjj])\\n vsum=load.apVisitSum(int(av['PLATE'][jjj]),av['MJD'][jjj])[1].data\\n f=np.where(vsum['FIBERID'] == av['FIBERID'][jjj])[0]\\n print(vsum['RV_TEFF'][f])\\n applot.chip(va,ax=ax,row=300-av['FIBERID'][jjj],color='r')\\n applot.chip(va,ax=pax,row=300-av['FIBERID'][jjj],color='r',pixel=True)\\n vb={}\\n for chip in chips :\\n tmp=fits.open(os.environ['APOGEE_REDUX']+'/r8/apo25m/{:04d}/{:05d}/apPlate-{:s}-{:04d}-{:05d}.fits'.format(\\n int(bv['PLATE'][kkk]),bv['MJD'][kkk],chip,int(bv['PLATE'][kkk]),bv['MJD'][kkk]))\\n vb[chip] = tmp\\n vsum=fits.open(os.environ['APOGEE_REDUX']+'/r8/fields/apo25m/{:04d}/apVisitSum-{:04d}-{:05d}.fits'.format(\\n int(bv['LOCATION_ID'][kkk]),int(bv['PLATE'][kkk]),bv['MJD'][kkk]))[1].data\\n f=np.where(vsum['FIBERID'] == bv['FIBERID'][kkk])[0]\\n print(vsum['RV_TEFF'][f])\\n applot.chip(vb,ax=ax,row=300-bv['FIBERID'][kkk],color='b')\\n applot.chip(vb,ax=pax,row=300-bv['FIBERID'][kkk],color='b',pixel=True)\\n for ichip,chip in enumerate(chips) :\\n wax[ichip].plot(va[chip][4].data[300-av['FIBERID'][jjj],:]-vb[chip][4].data[300-bv['FIBERID'][kkk],:])\\n plt.show()\\n pdb.set_trace()\\n\\n for ichip in range(3) :\\n ax[ichip].cla()\\n pax[ichip].cla()\\n wax[ichip].cla()\",\n \"def read_inversion_info(file_dic):\\n #print_file_test = open('file_test.txt','w')\\n\\n if not ( check_inversion_files(file_dic) ):\\n print 'error(read_inversion_info): problem with lenstool file names'\\n return 0\\n \\n file_generate_arcs = file_dic['file_generate_arcs']\\n info_input_lens = fc.extract_second_identifiers( file_generate_arcs, \\\\\\n 'potential' )\\n#-------------------------------------------------------------------------------\\n\\n file_source = file_dic['file_source']\\n info_src = np.loadtxt(file_source, unpack=False)\\n if len(info_src) == 8 and np.isscalar(info_src[0]):\\n #FIXME - check if the second condition is all we need\\n info_src = [info_src]\\n#-------------------------------------------------------------------------------\\n\\n file_make_inversion = file_dic['file_make_inversion']\\n info_fited_param = fc.extract_second_identifiers( file_make_inversion, \\\\\\n 'limit' )\\n info_forme = fc.extract_parameter(file_make_inversion, 'forme')[0][0]\\n\\n#-------------------------------------------------------------------------------\\n\\n file_best_fit = file_dic['file_best_fit']\\n info_best_fit = fc.extract_second_identifiers( file_best_fit, \\\\\\n 'potentiel' )\\n\\n info_xi2 = fc.extract_parameter(file_best_fit, '#Chi2pos:')\\n\\n#-------------------------------------------------------------------------------\\n file_chires = file_dic['file_chires']\\n\\n info_chires = extract_parameter(file_chires, '0')\\n rmss_mean = [0.0, 0.0]\\n rmsi_mean = [0.0, 0.0]\\n for i in info_chires:\\n if i[0] != 'A':\\n rmss_mean[0] = rmss_mean[0] + float(i[7])\\n rmss_mean[1] = rmss_mean[1] + 1.0\\n \\n rmsi_mean[0] = rmsi_mean[0] + float(i[8])\\n rmsi_mean[1] = rmsi_mean[1] + 1.0\\n\\n rmss_mean = rmss_mean[0]/rmss_mean[1]\\n rmsi_mean = rmsi_mean[0]/rmsi_mean[1]\\n#-------------------------------------------------------------------------------\\n out_dict = { 'xi2' : float(info_xi2[0][0]), \\\\\\n 'best_fit_lens' : info_best_fit, \\\\\\n 'rmsi_mean' : rmsi_mean, \\\\\\n 'rmss_mean' : rmss_mean, \\\\\\n 'fited_parameters' : info_fited_param[0].keys(), \\\\\\n 'input_lens' : info_input_lens[len(info_input_lens) - 1], \\\\\\n 'forme' : info_forme \\\\\\n }\\n #for i in out_dict.keys():\\n # print i, out_dict[i]\\n return out_dict\",\n \"def test_equivalence():\\n\\t\\n\\tfrom . import spectra as sp\\n\\t\\n\\t#analytic\\n\\tp_dict = {'Bfield':15000,'rb85frac':1,'Btheta':0*np.pi/180,'Bphi':0*np.pi/180,'lcell':1e-3,'T':84,'Dline':'D2','Elem':'Rb'}\\n\\tchiL1,chiR1,chiZ1 = sp.calc_chi([-18400],p_dict)\\n\\tRotMat1, n11, n21 = solve_diel(chiL1,chiR1,chiZ1,0,150,force_numeric=False)\\n\\t\\n\\t#numeric\\n\\tchiL2, chiR2, chiZ2 = chiL1, chiR1, chiZ1\\n\\t#chiL2,chiR2,chiZ2 = sp.calc_chi([-18400],p_dict)\\n\\tRotMat2, n12, n22 = solve_diel(chiL2,chiR2,chiZ2,0,150,force_numeric=True)\\n\\t\\n\\tprint('RM 1')\\n\\tprint(RotMat1)\\n\\n\\tprint('RM 2')\\n\\tprint(RotMat2)\\t\\n\\t\\n\\tprint('n1_1 (analytic)')\\n\\tprint(n11)\\n\\tprint('n1_2')\\n\\tprint(n12)\\n\\tprint('n2_1 (analytic)')\\n\\tprint(n21)\\n\\tprint('n2_2')\\n\\tprint(n22)\\n\\t\\n\\tprint('chi1')\\n\\tprint((chiL1, chiR1, chiZ1))\\n\\n\\tprint('chi2')\\n\\tprint((chiL2, chiR2, chiZ2))\",\n \"def fm_versions(fmagg, suffix = \\\"\\\"):\\n dert = np.ones_like(z)[:,None]*truth['b1'] # dert === derivative true\\n for k in range(2,model.K):\\n dert = z[:, None] ** (k - 1) *truth['b'+str(k)]*k +dert\\n adert = np.abs(dert)\\n\\n ederiv =deriv.mean(axis = 1 ) #expectation of derivative\\n\\n def process_figure_of_merit(kind='worst'):\\n if kind=='worst': #looking for minimal true FoM\\n xm = np.argmin(adert,axis=0)\\n ym = np.argmin(np.abs(ederiv),axis = 0)\\n else: #looking for the best FoM\\n kind = ''\\n xm = np.argmax(adert,axis=0)\\n ym = np.argmax(np.abs(ederiv),axis = 0)\\n M = len(xm)\\n x = np.zeros(M)\\n y = np.zeros((fmagg.shape[1],M))\\n for m in range(M):\\n x[m] = adert[xm[m],m]/truth['S'][m]\\n y[:,m] = fmagg[ym[m],:,m]\\n printout('Fm'+kind+''+suffix,y,f,x)\\n plot_verus('Fm'+kind+''+suffix,y,x,suppress_aspect=True)\\n plot_verus('Fm'+kind+''+suffix+' ',y,x,suppress_aspect=False)\\n\\n\\n\\n process_figure_of_merit('worst')\\n process_figure_of_merit('')\",\n \"def run(datadir, outdir, real_data_fnames, MT_green_func_fnames, single_force_green_func_fnames, data_labels, inversion_type, num_samples, comparison_metric, nlloc_hyp_filename, perform_normallised_waveform_inversion=True, compare_all_waveforms_simultaneously=False, cut_phase_start_vals=[], cut_phase_length=0, plot_switch=False, num_processors=1, set_pre_time_shift_values_to_zero_switch=True, only_save_non_zero_solns_switch=False, return_absolute_similarity_values_switch=False, invert_for_ratio_of_multiple_media_greens_func_switch=False, green_func_fnames_split_index=0, green_func_phase_labels=[], invert_for_relative_magnitudes_switch=False, rel_exp_mag_range=[1.0,1.0], auto_shift_for_best_fit=True, manual_indices_time_shift_MT=[], manual_indices_time_shift_SF=[]):\\n # Do some initial checks:\\n if auto_shift_for_best_fit:\\n manual_indices_time_shift_MT = np.zeros(len(real_data_fnames))\\n manual_indices_time_shift_SF = np.zeros(len(real_data_fnames))\\n else:\\n if (len(manual_indices_time_shift_MT)==0) and (len(manual_indices_time_shift_SF)==0):\\n print(\\\"Error. Because <auto_shift_for_best_fit> is set to false, manual_indices_time_shift_MT and or manual_indices_time_shift_SF are not specified. Exiting.\\\")\\n sys.exit()\\n\\n # Run specific multi medium inversion, if specified:\\n if invert_for_ratio_of_multiple_media_greens_func_switch:\\n # For muliple media greens functions:\\n run_multi_medium_inversion(datadir, outdir, real_data_fnames, MT_green_func_fnames, single_force_green_func_fnames, data_labels, inversion_type, perform_normallised_waveform_inversion, compare_all_waveforms_simultaneously, num_samples, comparison_metric, manual_indices_time_shift_MT, manual_indices_time_shift_SF, nlloc_hyp_filename, cut_phase_start_vals=cut_phase_start_vals, cut_phase_length=cut_phase_length, plot_switch=plot_switch, num_processors=num_processors, set_pre_time_shift_values_to_zero_switch=set_pre_time_shift_values_to_zero_switch, only_save_non_zero_solns_switch=only_save_non_zero_solns_switch, return_absolute_similarity_values_switch=return_absolute_similarity_values_switch, invert_for_ratio_of_multiple_media_greens_func_switch=invert_for_ratio_of_multiple_media_greens_func_switch, green_func_fnames_split_index=green_func_fnames_split_index, green_func_phase_labels=green_func_phase_labels, auto_shift_for_best_fit=auto_shift_for_best_fit)\\n else:\\n # Run for normal, single set of greens functions:\\n \\n # Load input data (completely, for specific inversion type):\\n real_data_array, green_func_array = get_overall_real_and_green_func_data(datadir, real_data_fnames, MT_green_func_fnames, single_force_green_func_fnames, inversion_type, manual_indices_time_shift_MT=manual_indices_time_shift_MT, manual_indices_time_shift_SF=manual_indices_time_shift_SF, cut_phase_start_vals=cut_phase_start_vals, cut_phase_length=cut_phase_length, set_pre_time_shift_values_to_zero_switch=set_pre_time_shift_values_to_zero_switch)\\n \\n # Perform the inversion:\\n M = perform_inversion(real_data_array, green_func_array)\\n M_amplitude = ((np.sum(M**2))**0.5)\\n\\n # And get forward model synthetic waveform result:\\n synth_forward_model_result_array = forward_model(green_func_array, M)\\n \\n # And plot the results:\\n if plot_switch:\\n plot_specific_forward_model_result(real_data_array, synth_forward_model_result_array, data_labels, plot_title=\\\"Initial theoretical inversion solution\\\", perform_normallised_waveform_inversion=perform_normallised_waveform_inversion)\\n \\n # And save least squares output:\\n # Set output arrays to equal least squares output: \\n MTs = M\\n similarity_curr_sample, shift_idxs = compare_synth_to_real_waveforms(real_data_array, synth_forward_model_result_array, comparison_metric, perform_normallised_waveform_inversion, compare_all_waveforms_simultaneously, auto_shift_for_best_fit) \\n MTp = np.array([similarity_curr_sample])\\n # And save data to MTFIT style file:\\n outdir_least_squares = outdir+\\\"/least_squares_result\\\"\\n os.system(\\\"mkdir -p \\\"+outdir_least_squares)\\n save_to_MTFIT_style_file(MTs, MTp, nlloc_hyp_filename, inversion_type, outdir_least_squares, shift_idxs=shift_idxs) # Saves pickled dictionary containing data from inversion\\n # And save most likely solution and real data waveforms to file:\\n if inversion_type == \\\"DC_single_force_couple\\\" or inversion_type == \\\"DC_single_force_no_coupling\\\" or inversion_type == \\\"DC_crack_couple\\\" or inversion_type == \\\"single_force_crack_no_coupling\\\":\\n synth_forward_model_most_likely_result_array = forward_model(green_func_array, MTs[:-1, np.where(MTp==np.max(MTp))[0][0]])\\n else:\\n synth_forward_model_most_likely_result_array = forward_model(green_func_array, MTs[:, np.where(MTp==np.max(MTp))[0][0]])\\n # And get shift associated with most likely model:\\n if len(shift_idxs) > 0:\\n shift_idxs_most_likely_result = np.array(shift_idxs)\\n else:\\n shift_idxs_most_likely_result = []\\n # And save:\\n save_specific_waveforms_to_file(real_data_array, synth_forward_model_most_likely_result_array, data_labels, nlloc_hyp_filename, inversion_type, outdir_least_squares, shift_idxs=shift_idxs_most_likely_result, normallise_data=perform_normallised_waveform_inversion)\\n \\n # And do Monte Carlo random sampling to obtain PDF of moment tensor:\\n MTs, MTp, MTp_absolute, shift_idxs_all_samples = perform_monte_carlo_sampled_waveform_inversion(real_data_array, green_func_array, num_samples, M_amplitude=M_amplitude,inversion_type=inversion_type, comparison_metric=comparison_metric, perform_normallised_waveform_inversion=perform_normallised_waveform_inversion, compare_all_waveforms_simultaneously=compare_all_waveforms_simultaneously, num_processors=num_processors, return_absolute_similarity_values_switch=return_absolute_similarity_values_switch, invert_for_relative_magnitudes_switch=invert_for_relative_magnitudes_switch, rel_exp_mag_range=rel_exp_mag_range, auto_shift_for_best_fit=auto_shift_for_best_fit)\\n \\n # Check that probability of output is non-zero:\\n if math.isnan(MTp[0]):\\n print(\\\"Error: Sum of probabilities is equal to zero - therefore no adiquate solution could be found and inversion is terminating.\\\")\\n sys.exit()\\n \\n # Remove zero probability values if specified:\\n if only_save_non_zero_solns_switch:\\n MTp, MTs = remove_zero_prob_results(MTp, MTs)\\n \\n # And plot most likely solution:\\n if plot_switch:\\n if inversion_type == \\\"DC_single_force_couple\\\" or inversion_type == \\\"DC_single_force_no_coupling\\\" or inversion_type == \\\"DC_crack_couple\\\" or inversion_type == \\\"single_force_crack_no_coupling\\\":\\n synth_forward_model_most_likely_result_array = forward_model(green_func_array, MTs[:-1, np.where(MTp==np.max(MTp))[0][0]])\\n else:\\n synth_forward_model_most_likely_result_array = forward_model(green_func_array, MTs[:, np.where(MTp==np.max(MTp))[0][0]])\\n plot_specific_forward_model_result(real_data_array, synth_forward_model_most_likely_result_array, data_labels, plot_title=\\\"Most likely Monte Carlo sampled solution\\\", perform_normallised_waveform_inversion=perform_normallised_waveform_inversion)\\n print(\\\"Most likely solution:\\\", MTs[:,np.where(MTp==np.max(MTp))[0][0]])\\n \\n # And save data to MTFIT style file:\\n save_to_MTFIT_style_file(MTs, MTp, nlloc_hyp_filename, inversion_type, outdir, MTp_absolute=MTp_absolute, shift_idxs=shift_idxs_all_samples) # Saves pickled dictionary containing data from inversion\\n # And save most likely solution and real data waveforms to file:\\n if inversion_type == \\\"DC_single_force_couple\\\" or inversion_type == \\\"DC_single_force_no_coupling\\\" or inversion_type == \\\"DC_crack_couple\\\" or inversion_type == \\\"single_force_crack_no_coupling\\\":\\n synth_forward_model_most_likely_result_array = forward_model(green_func_array, MTs[:-1, np.where(MTp==np.max(MTp))[0][0]])\\n else:\\n synth_forward_model_most_likely_result_array = forward_model(green_func_array, MTs[:, np.where(MTp==np.max(MTp))[0][0]])\\n # And get shift associated with most likely model:\\n if len(shift_idxs_all_samples) > 0:\\n shift_idxs_most_likely_result = np.array(shift_idxs_all_samples)[0, np.where(MTp==np.max(MTp))[0][0]]\\n else:\\n shift_idxs_most_likely_result = []\\n # And save:\\n save_specific_waveforms_to_file(real_data_array, synth_forward_model_most_likely_result_array, data_labels, nlloc_hyp_filename, inversion_type, outdir, shift_idxs=shift_idxs_most_likely_result, normallise_data=perform_normallised_waveform_inversion)\\n\\n print(\\\"Finished\\\")\",\n \"def calc_elv_spectra(self, red, comp, src):\\n if ((src in red.data.keys())\\n & (src in red.data.keys())):\\n # check that the wavelenth grids are identical\\n delt_wave = red.data[src].waves - comp.data[src].waves\\n if np.sum(np.absolute(delt_wave)) > 0.01*u.micron:\\n warnings.warn(\\\"wavelength grids not equal for %s\\\" % src,\\n UserWarning)\\n else:\\n # reference band\\n red_V = red.data['BAND'].get_band_mag('V')\\n comp_V = comp.data['BAND'].get_band_mag('V')\\n\\n # setup the needed variables\\n self.waves[src] = red.data[src].waves\\n n_waves = len(self.waves[src])\\n self.exts[src] = np.zeros(n_waves)\\n self.uncs[src] = np.zeros(n_waves)\\n self.npts[src] = np.zeros(n_waves)\\n\\n # only compute the extinction for good, positive fluxes\\n print(comp.data[src].npts)\\n print(comp.data[src].fluxes)\\n indxs, = np.where((red.data[src].npts > 0)\\n & (comp.data[src].npts > 0)\\n & (red.data[src].fluxes.value > 0)\\n & (comp.data[src].fluxes.value > 0))\\n self.exts[src][indxs] = \\\\\\n (-2.5*np.log10(red.data[src].fluxes[indxs]\\n / comp.data[src].fluxes[indxs])\\n + (comp_V[0] - red_V[0]))\\n self.uncs[src][indxs] = np.sqrt(\\n np.square(_flux_unc_as_mags(red.data[src].fluxes[indxs],\\n red.data[src].uncs[indxs]))\\n + np.square(_flux_unc_as_mags(comp.data[src].fluxes[indxs],\\n comp.data[src].uncs[indxs]))\\n + np.square(red_V[1])\\n + np.square(comp_V[1]))\\n self.npts[src][indxs] = np.full(len(indxs), 1)\",\n \"def test_flim_model(datadir):\\n # ifuslot_063\\n filename = datadir.join(\\\"test_hdf.h5\\\").strpath\\n hdcon1 = SensitivityCubeHDF5Container(filename, flim_model=\\\"hdr1\\\")\\n hdcon2 = SensitivityCubeHDF5Container(filename, flim_model=\\\"hdr2pt1\\\")\\n\\n scube1 = hdcon1.extract_ifu_sensitivity_cube(\\\"ifuslot_063\\\")\\n scube2 = hdcon2.extract_ifu_sensitivity_cube(\\\"ifuslot_063\\\")\\n\\n s1 = scube1.get_f50(161.4201, 50.8822, 3470.0, 5.5)\\n s2 = scube2.get_f50(161.4201, 50.8822, 3470.0, 5.5)\\n\\n print(s1)\\n # if different models passed should be different\\n assert abs(s1 - s2) > 1e-19\",\n \"def plot_source_residuals_comparison(source_truth, source_model_list, name_list, \\n vmin_res=-0.5, vmax_res=-0.5, cmap='cubehelix',\\n fontsize=12):\\n n_model = len(source_model_list)\\n fig, axes = plt.subplots(1+n_model, 2, figsize=(9, (1+n_model)*3.5))\\n axes[0, 1].axis('off')\\n ax = axes[0, 0]\\n #ax.get_xaxis().set_visible(False)\\n #ax.get_yaxis().set_visible(False)\\n ax.set_title(\\\"true source\\\", fontsize=fontsize)\\n im = ax.imshow(source_truth, cmap=cmap, vmin=0)\\n lims = (len(source_truth)/4, 3*len(source_truth)/4) # zoom a bit on the image\\n #ax.set_xlim(*lims)\\n #ax.set_ylim(*lims)\\n plot_util.nice_colorbar(im, label=\\\"flux\\\", fontsize=fontsize)\\n \\n i = 1\\n for source_model, name in zip(source_model_list, name_list):\\n print(\\\"min/max for source model '{}': {}/{}\\\".format(name, source_model.min(), source_model.max()))\\n\\n residuals_source = source_model - source_truth\\n\\n ax = axes[i, 0]\\n ax.set_title(\\\"model '{}'\\\".format(name), fontsize=fontsize)\\n #ax.get_xaxis().set_visible(False)\\n #ax.get_yaxis().set_visible(False)\\n im = ax.imshow(source_model, cmap=cmap)\\n #ax.set_xlim(*lims)\\n #ax.set_ylim(*lims)\\n plot_util.nice_colorbar(im, label=\\\"flux\\\", fontsize=fontsize)\\n \\n ax = axes[i, 1]\\n #ax.get_xaxis().set_visible(False)\\n #ax.get_yaxis().set_visible(False)\\n ax.set_title(\\\"difference\\\", fontsize=fontsize)\\n #ax.set_xlim(*lims)\\n #ax.set_ylim(*lims)\\n im = ax.imshow(residuals_source, cmap='RdBu_r', vmin=vmin_res, vmax=vmax_res)\\n plot_util.nice_colorbar_residuals(im, residuals_source, vmin_res, vmax_res,\\n label=r\\\"f${}_{\\\\rm model}$ - f${}_{\\\\rm truth}$\\\", fontsize=fontsize)\\n \\n print(\\\"SDR for model '{}' = {:.3f}\\\".format(name, metrics_util.SDR(source_truth, source_model)))\\n i += 1\\n\\n return fig\",\n \"def comp(a,b,av=None,bv=None,domatch=True,out=None) :\\n if domatch :\\n i1,i2=match.match(a['APOGEE_ID'],b['APOGEE_ID'])\\n gd = np.where(a['NVISITS'][i1] == b['NVISITS'][i2])[0]\\n a=a[i1[gd]]\\n b=b[i2[gd]]\\n\\n fig = vscat(a)\\n vscat(b,fig=fig,ls=':')\\n if out is not None : \\n fig[0].savefig(out+'_1.png')\\n plt.close()\\n\\n if domatch :\\n fig,ax=plots.multi(1,2)\\n #plots.plotp(ax[0,0],a['SNR'],a['VHELIO_AVG']-b['VHELIO_AVG'],yr=[-3,3],yt=r'$\\\\Delta$ VHELIO_AVG')\\n #plots.plotp(ax[0,1],a['SNR'],a['VHELIO_AVG']-b['VHELIO_AVG'],yr=[-50,50],yt=r'$\\\\Delta$ VHELIO_AVG')\\n #plots.plotp(ax[1,0],a['SNR'],a['VSCATTER']-b['VSCATTER'],yr=[-0.5,0.5],yt=r'$\\\\Delta$ VSCATTER')\\n #plots.plotp(ax[1,1],a['SNR'],a['VSCATTER']-b['VSCATTER'],yr=[-5,5],yt=r'$\\\\Delta$ VSCATTER')\\n ax[0].hist(a['VHELIO_AVG']-b['VHELIO_AVG'],bins=np.arange(-0.5,0.5,0.02),histtype='step')\\n ax[0].set_xlabel(r'$\\\\Delta$ VHELIO_AVG')\\n ax[1].hist(a['VSCATTER']-b['VSCATTER'],bins=np.arange(-0.5,0.5,0.02),histtype='step')\\n ax[1].set_xlabel(r'$\\\\Delta$ VSCATTER')\\n if out is not None : \\n fig.savefig(out+'_2.png')\\n plt.close()\\n\\n return a,b\",\n \"def compare_lgm_river_directions_with_catchments_virna_data_with_vs_without_tarasov_style_orog_corrs(self):\\n tarasov_upscaled_data_datetime=\\\"20170518_193949\\\"\\n ref_filename=os.path.join(self.plots_data_dir,\\n \\\"flowmap_ten_minute_data_from_virna_lgm_ALG4_sinkless\\\"\\n \\\"_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_20170127\\\"\\n \\\"_163957_upscaled_updated.nc\\\")\\n data_filename=os.path.join(self.plots_data_dir,\\n \\\"flowmap_ten_minute_data_from_virna_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask\\\"\\n \\\"_plus_upscale_rdirs_tarasov_orog_corrs_{0}_upscaled_updated.nc\\\".\\\\\\n format(tarasov_upscaled_data_datetime))\\n lsmask_filename=os.path.join(self.plots_data_dir,\\n \\\"ls_mask_ten_minute_data_from_virna_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask\\\"\\n \\\"_plus_upscale_rdirs_tarasov_orog_corrs_{0}_HD_transf.dat\\\".\\\\\\n format(tarasov_upscaled_data_datetime))\\n ref_catchment_filename=(\\\"catchmentmap_ten_minute_data_from_virna_lgm_ALG4_sinkless_no_true_sinks_oceans_\\\"\\n \\\"lsmask_plus_upscale_rdirs_20170127_163957_upscaled_updated.nc\\\")\\n data_catchment_filename=(\\\"catchmentmap_ten_minute_data_from_virna_lgm_ALG4_sinkless_no_true_sinks_oceans_\\\"\\n \\\"lsmask_plus_upscale_rdirs_tarasov_orog_corrs_{0}_upscaled_updated.nc\\\".\\\\\\n format(tarasov_upscaled_data_datetime))\\n ref_rdirs_filename=(\\\"upscaled_rdirs_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true\\\"\\n \\\"_sinks_oceans_lsmask_plus_upscale_rdirs_20170123_165707.nc\\\")\\n reference_rmouth_outflows_filename=(self.plots_data_dir + \\\"/rmouthmap_ten_\\\"\\n \\\"minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus\\\"\\n \\\"_upscale_rdirs_20170123_165707_upscaled_updated.nc\\\")\\n data_rmouth_outflows_filename=(self.plots_data_dir + \\\"/rmouths/rmouthmap_ten_minute_\\\"\\n \\\"data_from_virna_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale\\\"\\n \\\"_rdirs_tarasov_orog_corrs_{0}_upscaled_updated.nc\\\".\\\\\\n format(tarasov_upscaled_data_datetime))\\n glacier_mask_filename=os.path.join(self.orog_data_directory,\\\"ice5g_v1_2_21_0k_10min.nc\\\")\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n ref_catchment_filename,\\n data_catchment_filename=\\\\\\n data_catchment_filename,\\n ref_rdirs_filename=\\\\\\n ref_rdirs_filename,\\n data_rdirs_filename=None,\\n reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=100,\\n flip_data=False,\\n rotate_data=True,\\n flip_ref=False,\\n rotate_ref=True,\\n lsmask_has_same_orientation_as_ref=False,\\n invert_ls_mask=True,\\n first_datasource_name=\\\"Present day\\\",\\n second_datasource_name=\\\"LGM\\\",\\n matching_parameter_set='extensive',\\n catchment_and_outflows_mods_list_filename=\\\\\\n \\\"catch_and_outflow_mods_lgm_vs_present_day.txt\\\",\\n additional_matches_list_filename=\\\\\\n \\\"additional_matches_10min_upscaled_lgm_vs_present.txt\\\",\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n use_title=False,remove_antartica=True,\\n difference_in_catchment_label=\\\"Difference\\\",\\n glacier_mask_filename=glacier_mask_filename,\\n glacier_mask_grid_type='LatLong10min',\\n flip_glacier_mask=True,\\n rotate_glacier_mask=True,\\n grid_type='HD')\",\n \"def do_comparison(found_file, created_file):\\n\\n fh_f, fh_c, data_f, data_c = get_data(found_file, created_file)\\n\\n print('Initial found data shape ', data_f.shape)\\n print(' and created data shape= ', data_c.shape)\\n\\n # Compare slice i of created to slice i+1 in found\\n if (data_f.shape[0] == 1): # NIRCAM\\n data_f = data_f[0, :, :, :]\\n if (data_c.shape[0] == 1): # to accept output of mc_4d\\n data_c = data_c[0, :, :, :]\\n data_c_start = data_c[:-1, :, :]\\n data_f_end = data_f[1:, :, :]\\n elif (fh_f['SCI'].header['NAXIS'] == 3): # NIRSPEC\\n data_c_start = data_c[:-1, :, :]\\n data_f_end = data_f[1:, :, :]\\n elif (data_f.shape[0] > 1 and fh_f['SCI'].header['NAXIS'] == 4): # MIRI\\n # concatenate copies of created data (except for the last frame)\\n num_ints = int(fh_f[1].data.shape[0]) # number of integrations\\n data_c_start = (np.repeat(data_c[:-1, :, :], num_ints, axis=0))\\n data_f_end = data_f[:, 1:, :, :]\\n data_c_start = data_c_start.reshape(data_f_end.shape)\\n else:\\n print(' FATAL ERROR - unsupported instrument')\\n\\n print('Truncated found data shape ', data_f_end.shape)\\n print(' and truncated created data shape= ', data_c_start.shape)\\n try:\\n assert(data_f_end.shape == data_c_start.shape)\\n except AssertionError:\\n print(' FATAL ERROR: adjusted found data shape ', data_f.shape, \\\\\\n ' is not the same as adjusted created data shape= ', data_c.shape)\\n\\n neither = (data_c_start == 0.) & (data_f_end == 0.)\\n both = (data_c_start != 0.) & (data_f_end != 0.) # created CR was found\\n c_only = (data_c_start != 0.) & (data_f_end == 0.) # created CR not found\\n f_only = (data_c_start == 0.) & (data_f_end != 0.) # found CR was not created\\n\\n try:\\n assert(neither.sum() + both.sum() + c_only.sum() + f_only.sum() \\\\\\n == data_c_start.size)\\n except AssertionError:\\n print('FATAL ERROR: sum of components must equal total number of pixels ')\\n\\n print(' Within the input dataset cubes:')\\n print(' Number of created but not found pixels: ', c_only.sum())\\n print(' Number of found but not created pixels: ', f_only.sum())\\n print(' Number of pixels that are both found and created: ', both.sum())\\n print(' Number of pixels that are neither found nor created: ', neither.sum())\\n print(' ')\\n print(' The fraction of all pixels that were found only: ', \\\\\\n float(f_only.sum()) / float(data_c_start.size))\\n print(' The fraction of all pixels that were created only: ', \\\\\\n float(c_only.sum()) / float(data_c_start.size))\\n print(' The fraction of pixels in the created file having cosmic rays:', \\\\\\n float(c_only.sum()) / (data_c_start.shape[-2] * data_c_start.shape[-1]))\\n print(' ')\\n\\n write_files(neither, both, c_only, f_only, fh_c, data_c_start)\",\n \"def all(a,name='DR16',dr='dr14') :\\n grid=[]\\n xtit=[]\\n load=apload.ApLoad(dr=dr)\\n b=load.allStar()[1].data\\n \\n # vscatter of new RVs\\n vscat(a,out='plots/vscat')\\n vscat(a,out='plots/vscat5',nmin=5)\\n grid.append(['vscat.png','vscat5.png'])\\n xtit.append(name+' : VSCATTER')\\n\\n # APO/LCO comparison\\n apolco(a,out='plots/apolco')\\n grid.append(['apolco_1.png','apolco_2.png'])\\n xtit.append(name+' : APO (solid) and LCO (dotted), same stars')\\n #apolco(a,out='plots/apolco_nolowz',minfeh=-0.6)\\n #grid.append(['apolco_nolowz_1.png','apolco_nolowz_2'])\\n #xtit.append(name+', no low [Fe/H]: APO (solid) and LCO (dotted)')\\n\\n # RV standards\\n standards(a,out='plots/rvstan')\\n grid.append(['rvstan.png',''])\\n xtit.append(name+', comparison with literature RVs')\\n\\n # comparison with previous DR\\n comp(a,b,domatch=True,out='plots/drcomp')\\n grid.append(['drcomp_1.png','drcomp_2.png'])\\n xtit.append(name+', comparison with '+dr+' : same stars, same NVISITS, new(solid) '+dr+'(dotted)')\\n\\n html.htmltab(grid,ytitle=xtit,file='plots/rv.html')\",\n \"def HD_input_snfit_data(self):\\n\\n dico = cPickle.load(open(SUGAR_parameter_pkl))\\n self.read_snfit_results()\\n self.read_meta()\\n Filtre = np.array([True]*len(self.sn_name))\\n self.zcmb = []\\n self.z_err = []\\n for j in range(len(self.sn_name)):\\n if self.sn_name[j] in dico.keys() and self.sn_name[j] :\\n\\n for i in range (len(self.meta_sn_name_list)):\\n if self.sn_name[j] == self.meta_sn_name_list[i]:\\n \\n self.z_err.append(self.meta_zhl_err[i])\\n self.zcmb.append(self.meta_zcmb[i])\\n if np.abs(self.x1[j] - self.meta_x1[i]) > 0.001:\\n print 'problem with %s include in sample but difference between snfit and meta'%(self.sn_name[j])\\n else:\\n Filtre[j] = False\\n\\n for p in dico.keys():\\n if p not in self.sn_name:\\n print p\\n \\n self.x1 = self.x1[Filtre]\\n self.x1_err = self.x1_err[Filtre] \\n self.c = self.c[Filtre]\\n self.c_err = self.c_err[Filtre]\\n self.mb = self.mb[Filtre]\\n self.mb_err = self.mb_err[Filtre]\\n self.cov_x0_x1 = self.cov_x0_x1[Filtre]\\n self.cov_x0_c = self.cov_x0_c[Filtre]\\n self.cov_x1_c = self.cov_x1_c[Filtre]\\n self.cov_mb_x1 = self.cov_mb_x1[Filtre]\\n self.cov_mb_c = self.cov_mb_c[Filtre]\\n self.z = self.z[Filtre]\\n self.zcmb = np.array(self.zcmb)\\n self.z_err = np.array(self.z_err)\\n\\n self.cov_y = np.zeros((len(self.mb)*3,len(self.mb)*3))\\n\\n for i in range (len(self.mb)):\\n self.cov_y[i*3,i*3] = self.mb_err[i]**2\\n self.cov_y[i*3+ 1,i*3+ 1] = self.x1_err[i]**2\\n \\n self.cov_y[i*3+ 2,i*3+ 2] = self.c_err[i]**2\\n self.cov_y[i*3+ 0,i*3+ 1] = self.cov_mb_x1[i]\\n self.cov_y[i*3+ 1,i*3+ 0] = self.cov_mb_x1[i]\\n self.cov_y[i*3+ 0,i*3+ 2] = self.cov_mb_c[i]\\n self.cov_y[i*3+ 2,i*3+ 0] = self.cov_mb_c[i]\\n self.cov_y[i*3+ 1,i*3+ 2] = self.cov_x1_c[i] \\n self.cov_y[i*3+ 2,i*3+ 1] = self.cov_x1_c[i] \\n \\n self.salt_parm = np.array([self.mb,self.x1,self.c]).T\\n# print len(self.salt_parm), len(self.cov_y), len(self.z), len(self.zcmb)\\n# return self.salt_parm, self.cov_y, self.z, self.meta_zcmb, self.meta_zhl_err, self.sn_name, self.meta_idr\\n return self.salt_parm, self.cov_y, self.z, self.zcmb, self.z_err\",\n \"def load_nir_alcohol():\\n\\n # loading matlab data set\\n raw_data = sio.loadmat(__data_set_path)\\n\\n # ----------------\\n\\n # getting all variable/features labels\\n var_labels_all = raw_data['var_labels_all'].tolist()\\n\\n # getting spectra labels\\n var_labels_spectra = [int(l) for l in var_labels_all[3:]]\\n\\n # getting properties labels\\n var_labels_properties = var_labels_all[:3]\\n\\n # ----------------\\n\\n # getting all data (train-new-msc)\\n data_all = raw_data['data_all']\\n\\n # getting spectra data\\n data_spectra = data_all[:, 3:]\\n\\n # getting properties data\\n data_properties = data_all[:, :3]\\n\\n # ----------------\\n\\n obj_labels_train = raw_data['obj_labels_train'].tolist()\\n data_train = data_spectra[:27, :]\\n other_cols_train = {p_name: p_data for p_name, p_data in zip(var_labels_properties, data_properties[:27, :].T)}\\n\\n ds_train = utils.build_data_set(data_train, obj_labels_train, var_labels_spectra, extra_cols=other_cols_train)\\n\\n # ----------------\\n\\n obj_labels_new = raw_data['obj_labels_new'].tolist()\\n data_new = data_spectra[27:40, :]\\n other_cols_new = {p_name: p_data for p_name, p_data in zip(var_labels_properties, data_properties[27:40, :].T)}\\n\\n ds_new = utils.build_data_set(data_new, obj_labels_new, var_labels_spectra, extra_cols=other_cols_new)\\n\\n # ----------------\\n\\n obj_labels_msc = raw_data['obj_labels_mscorrected'].tolist()\\n data_msc = data_spectra[40:, :]\\n other_cols_msc = {p_name: p_data for p_name, p_data in zip(var_labels_properties, data_properties[40:, :].T)}\\n\\n ds_msc = utils.build_data_set(data_msc, obj_labels_msc, var_labels_spectra, extra_cols=other_cols_msc)\\n\\n # ----------------\\n\\n # training/validation data sets and labels\\n data_sets = [ds_train, ds_new, ds_msc]\\n labels = ['train', 'new', 'msc']\\n\\n # actually building the joint data set\\n ds = pd.concat(data_sets, keys=labels)\\n\\n # returning the final data set\\n return ds\",\n \"def compare_averages_shell_pspec_dft():\\n\\n select_radius = 5. #degrees\\n\\n Nside=256\\n Npix = 12 * Nside**2\\n Omega = 4*np.pi/float(Npix)\\n\\n Nfreq = 100\\n freqs = np.linspace(167.0, 177.0, Nfreq)\\n dnu = np.diff(freqs)[0]\\n Z = 1420/freqs - 1.\\n\\n sig = 2.0\\n mu = 0.0\\n shell = np.random.normal(mu, sig, (Npix, Nfreq))\\n\\n dV = comoving_voxel_volume(Z[Nfreq/2], dnu, Omega)\\n variances = []\\n means = []\\n pks = []\\n\\n gs = gridspec.GridSpec(2, 3)\\n fig = pl.figure()\\n\\n ax0 = pl.subplot(gs[0, 0:2])\\n ax1 = pl.subplot(gs[1, 0])\\n ax3 = pl.subplot(gs[1, 1])\\n ax2 = pl.subplot(gs[:, 2])\\n\\n steps = range(10,110,10)\\n vmin,vmax = min(steps),max(steps)\\n normalize = mcolors.Normalize(vmin=vmin, vmax=vmax)\\n colormap = cm.viridis\\n\\n for n in steps:\\n Nkbins = 100\\n kbins, pk = pspec_funcs.shell_project_pspec(shell, Nside, select_radius, freqs=freqs, Nkbins=Nkbins, N_sections=n, cosmo=True, method='dft', error=False)\\n variances.append(np.var(pk[0:Nkbins-5]))\\n means.append(np.mean(pk[0:Nkbins-5]))\\n pks.append(pk)\\n ax0.plot(kbins, pk, label=str(n), color=colormap(normalize(n)))\\n\\n ax0.axhline(y=dV*sig**2, color='k', lw=2.0)\\n# ax0.legend()\\n scalarmappable = cm.ScalarMappable(norm=normalize, cmap=colormap)\\n scalarmappable.set_array(steps)\\n fig.colorbar(scalarmappable,label=r'Number of snapshots', ax=ax0)\\n ax0.set_ylabel(r\\\"P(k) [mK$^2$ Mpc$^{3}]$\\\")\\n ax0.set_xlabel(r\\\"k [Mpc$^{-1}]$\\\")\\n ax1.plot(steps, np.array(variances), label=\\\"Variance\\\")\\n ax1.set_ylabel(r\\\"Variance(P(k)) [mK$^4$ Mpc$^{6}]$\\\")\\n ax1.set_xlabel(u\\\"Number of 5° snapshots\\\")\\n ax3.plot(steps, means, label=\\\"Mean\\\")\\n ax3.set_ylabel(r\\\"Mean(P(k)) [mK$^2$ Mpc$^{3}]$\\\")\\n ax3.set_xlabel(u\\\"Number of 5° snapshots\\\")\\n ax1.legend()\\n ax3.legend()\\n im = ax2.imshow(np.array(pks)[:,0:Nkbins-5], aspect='auto')#, norm=mcolors.LogNorm())\\n fig.colorbar(im, ax=ax2)\\n print('Fractional deviation: ', np.mean(np.abs(pk - dV*sig**2)))\\n pl.show()\",\n \"def compare_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2013/output',\\n\\t\\t\\t\\tsteps=['step01','step02'],\\n\\t\\t\\t\\t#labels='',\\n\\t\\t\\t\\tshow=True,\\n\\t\\t\\t\\txscale=1e3,\\n\\t\\t\\t\\tyscale=1e-2):\\n\\tplt.figure()\\n\\t#path = '/Users/scott/Desktop/elastic'\\n\\n\\t# Deep source\\n\\tlabels = ['no APMB', 'APMB']\\n\\tdeep = {}\\n\\tuzmax = 0.824873455364\\n\\t# NOT sure why hardcoded...\\n\\tuzmax = 1\\n\\tfor i,outdir in enumerate(steps):\\n\\t\\tpointsFile = os.path.join(path, outdir, 'points.h5')\\n\\n\\t\\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n\\n\\t\\tX = x / xscale\\n\\t\\tY1 = ux / yscale\\n\\n\\t\\tx_fem = X #/ xscale #double scaling!\\n\\t\\tur_fem = Y1 #/ yscale\\n\\t\\tuz_fem = uz / yscale\\n\\n\\t\\t#print(pointsFile)\\n\\t\\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\\n\\n\\t\\t#normalize\\n\\t\\tuz_fem = uz_fem / uzmax\\n\\t\\tur_fem = ur_fem / uzmax\\n\\t\\tx_fem = x_fem / 30.0\\n\\n\\t\\tl, = plt.plot(x_fem,uz_fem,'o-',ms=4,lw=4,label=labels[i])\\n\\t\\tplt.plot(x_fem,ur_fem,'o--',ms=4,lw=4,color=l.get_color()) #mfc='none' transparent\\n\\t\\tdeep[outdir] = uz_fem/uz_fem\\n\\n\\n\\t# Shallow Source\\n\\tshallow = {}\\n\\tuzmax = 0.949652827795 # Why?\\n\\tfor i,outdir in enumerate(['step11','step12']):\\n\\t\\tpointsFile = os.path.join(path, outdir, 'points.h5')\\n\\n\\t\\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n\\n\\t\\tX = x / xscale\\n\\t\\tY1 = ux / yscale\\n\\n\\t\\tx_fem = X #/ xscale #double scaling!\\n\\t\\tur_fem = Y1 #/ yscale\\n\\t\\tuz_fem = uz / yscale\\n\\n\\t\\t#print(pointsFile)\\n\\t\\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\\n\\n\\t\\t#normalize\\n\\t\\tuz_fem = uz_fem / uzmax\\n\\t\\tur_fem = ur_fem / uzmax\\n\\t\\tx_fem = x_fem / 20.0\\n\\n\\t\\tl, = plt.plot(x_fem,uz_fem,'.-', mfc='w', lw=4,label=labels[i])\\n\\t\\tplt.plot(x_fem,ur_fem,'.--',lw=4, mfc='w',color=l.get_color()) #mfc='none' transparent\\n\\n\\t\\tshallow[outdir] = uz_fem/ur_fem\\n\\n\\t# Annotate\\n\\tplt.axhline(color='k',lw=0.5)\\n\\t#plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n\\t#plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\\n\\tplt.legend()\\n\\tplt.grid()\\n\\t#plt.ylim(-0.5, 3.5)\\n\\t#plt.savefig('deep.png',bbox_inches='tight')\\n\\t#plt.savefig('shallow.png',bbox_inches='tight')\\n\\n\\t# normalized\\n\\tplt.ylim(-0.5, 4)\\n\\tplt.xlim(0,10)\\n\\tplt.xlabel('Normalized Radial Distance [R / D]')\\n\\tplt.ylabel('Normalized Displacement [U / Uz_max]')\\n\\t#plt.savefig('normalized_deep.png',bbox_inches='tight')\\n\\tplt.savefig('normalized_shallow.png',bbox_inches='tight')\\n\\n\\n\\t# Plot ratios of uz versus NOTE: this plot is confusing,,, just keep ratio of uz_max to ur_max\\n\\t'''\\n\\tplt.figure()\\n\\tplt.plot(x_fem, deep['step01'], label='Deep no APMB')\\n\\tplt.plot(x_fem, deep['step02'], label='Deep w/ APMB')\\n\\tplt.plot(x_fem, shallow['step11'], label='Shallow no APMB')\\n\\tplt.plot(x_fem, shallow['step12'], label='Shallow w/ APMB')\\n\\tplt.xlabel('Distance [km]') #NOTE: maybe plot normailzed X-axis (R-d)\\n\\t#plt.xlabel('Normalized Distance [R/d]')\\n\\tplt.ylabel('Ratio [Uz/Ur]')\\n\\tplt.title('Ratio of vertical to radial displacement')\\n\\tplt.legend()\\n\\tplt.show()\\n\\t'''\",\n \"def conditionDecodings(data, rois, ncvs=100, effects=False, motorOutput=False,confusion=False, decoder='similarity', nproc=5):\\n \\n ncond = data.shape[1] # two motor outputs\\n nSubjs = data.shape[2]\\n\\n nsamples = nSubjs * ncond\\n stats = np.zeros((len(rois),nsamples))\\n rmatches = np.zeros((len(rois),))\\n rmismatches = np.zeros((len(rois),))\\n\\n # Label array for supervised learning\\n labels = np.tile(range(ncond),nSubjs)\\n subjarray = np.repeat(range(nSubjs),ncond)\\n\\n # Run SVM classifications on network-level activation patterns across subjects\\n confusion_mats = []\\n roicount = 0\\n for roi in rois:\\n roi_ind = np.where(glasser2==roi+1)[0]\\n nfeatures = len(roi_ind)\\n roi_ind.shape = (len(roi_ind),1) \\n\\n svm_mat = np.zeros((nsamples,roi_ind.shape[0]))\\n samplecount = 0\\n for scount in range(nSubjs):\\n roidata = np.squeeze(data[roi_ind,:,scount])\\n svm_mat[samplecount:(samplecount+ncond),:] = roidata.T\\n\\n samplecount += ncond\\n\\n # Spatially demean matrix across features\\n# samplemean = np.mean(svm_mat,axis=1)\\n# samplemean.shape = (len(samplemean),1)\\n# svm_mat = svm_mat - samplemean\\n \\n scores, rmatch, rmismatch, confusion_mat = randomSplitLOOBaselineCV(ncvs, svm_mat, labels, subjarray, \\n motorOutput=motorOutput, decoder=decoder, nproc=nproc)\\n stats[roicount,:] = scores\\n rmatches[roicount] = np.mean(rmatch)\\n rmismatches[roicount] = np.mean(rmismatch)\\n confusion_mats.append(confusion_mat)\\n roicount += 1\\n \\n if effects and confusion:\\n return stats, rmatch, rmismatch, confusion_mats\\n if effects and not confusion:\\n return stats, rmatch, rmismatch\\n if confusion and not effects:\\n return stats, confusion_mats\\n else:\\n return stats\",\n \"def image_comparison(unaligned_image_ccd_lst,aligned_image_ccd_lst,stacked_img_ccd,outputs_path,obsdate):\\n source_hdu = CCDData(unaligned_image_ccd_lst[0],unit='adu')\\n source_image_hdr = source_hdu.header\\n run_filename = source_image_hdr['RUN'].strip(' ')\\n target_name = source_image_hdr['FIELD'].strip(' ')\\n exptime = source_image_hdr['EXPTIME']\\n chip_num = source_image_hdr['CHIP']\\n \\n # compare unaligned vs aligned images\\n for i, unaligned_img in enumerate(unaligned_image_ccd_lst[1:]):\\n fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(20, 10), tight_layout=True)\\n \\n # source_hdu = CCDData(unaligned_image_ccd_lst[0],unit='adu')\\n image_hdr = unaligned_img.header\\n run_filename = image_hdr['RUN'].strip(' ')\\n target_name = image_hdr['FIELD'].strip(' ')\\n exptime = image_hdr['EXPTIME']\\n chip_num = image_hdr['CHIP']\\n \\n show_image(unaligned_img, cmap='gray', ax=ax1, fig=fig, percl=90)\\n ax1.set_title('Unaligned Image for {}-{}-{}-{}s ({})'.format(run_filename,target_name,chip_num,exptime,obsdate))\\n \\n show_image(aligned_image_ccd_lst[i], cmap='gray', ax=ax2, fig=fig, percl=90)\\n ax2.set_title('Aligned Image for {}-{}-{}-{}s ({})'.format(run_filename,target_name,chip_num,exptime,obsdate))\\n \\n plt.savefig(outputs_path/\\\"unaligned_vs_aligned_{}-{}-{}-{}.jpg\\\".format(run_filename,target_name,chip_num,exptime),dpi=900)\\n plt.show()\\n \\n # compare source image to stacked image\\n fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(20, 10), tight_layout=True)\\n \\n show_image(unaligned_image_ccd_lst[0], cmap='gray', ax=ax1, fig=fig, percl=90)\\n ax1.set_title('Unaligned Source Image for {}-{}-{}s ({})'.format(target_name,chip_num,exptime,obsdate))\\n \\n show_image(stacked_img_ccd, cmap='gray', ax=ax2, fig=fig, percl=90)\\n ax2.set_title('Aligned Stacked Image for {}-{}-{}s ({})'.format(target_name,chip_num,exptime,obsdate))\\n \\n plt.savefig(outputs_path/\\\"source_vs_stacked_{}-{}-{}.jpg\\\".format(target_name,chip_num,exptime),dpi=900)\\n plt.show()\",\n \"def refl_analysis(self,dials_model):\\n Z = self.refl_table\\n indices = Z['miller_index']\\n expts = ExperimentListFactory.from_json_file(dials_model,\\n check_format=False)\\n self.dials_model=expts[0]\\n CRYS = self.dials_model.crystal\\n UC = CRYS.get_unit_cell()\\n strong_resolutions = UC.d(indices)\\n order = flex.sort_permutation(strong_resolutions, reverse=True)\\n Z[\\\"spots_order\\\"] = order\\n self.spots_pixels = flex.size_t()\\n spots_offset = flex.int(len(order),-1)\\n spots_size = flex.int(len(order),-1)\\n\\n P = panels = Z['panel']\\n S = shoeboxes = Z['shoebox']\\n N_visited = 0; N_bad = 0\\n for oidx in range(len(order)): #loop through the shoeboxes in correct order\\n sidx = order[oidx] # index into the Miller indices\\n ipanel = P[sidx]\\n slow_size = 254\\n fast_size = 254\\n panel_size=slow_size*fast_size\\n bbox = S[sidx].bbox\\n first_position = spots_offset[sidx] = self.spots_pixels.size()\\n for islow in range(max(0,bbox[2]-3), min(slow_size,bbox[3]+3)):\\n for ifast in range(max(0,bbox[0]-3), min(fast_size,bbox[1]+3)):\\n value = self.trusted_mask[ipanel][islow*slow_size + ifast]\\n N_visited += 1\\n if value: self.spots_pixels.append(ipanel*panel_size+islow*slow_size+ifast)\\n else: N_bad+=1\\n spot_size = spots_size[sidx] = self.spots_pixels.size() - first_position\\n Z[\\\"spots_offset\\\"] = spots_offset\\n Z[\\\"spots_size\\\"] = spots_size\\n print (N_visited,\\\"pixels were visited in the %d shoeboxes (with borders)\\\"%len(order))\\n print (N_bad,\\\"of these were bad pixels, leaving %d in target\\\"%(len(self.spots_pixels)))\",\n \"def compare_clouds(mr1='waroona_run2', mr2='waroona_run2uc', \\n hour=datetime(2016,1,5,15), \\n cloud_threshold=constants.cloud_threshold,\\n extent=None,\\n subsubdir=None):\\n # x axis for qc-max density\\n colormax=0.5\\n xs = np.linspace(0,colormax,200)\\n ## Colourmap setup for contourf plots\\n # linear between 0 and 0.01\\n # log between 0.01 and 0.3\\n logmax=np.log(colormax)/np.log(10)-0.01\\n cmap=plotting._cmaps_['qc']\\n norm=colors.SymLogNorm(0.01, vmin=0,vmax=colormax,base=2.)\\n clevs=np.union1d(np.union1d(np.logspace(-2,logmax,30),0),colormax) \\n \\n extentname = mr1.split('_')[0]\\n if extent is None:\\n extent = constants.extents[extentname]\\n \\n ## Read a model run\\n cubes1 = fio.read_model_run(mr1, hour, extent=extent)\\n cubes2 = fio.read_model_run(mr2, hour, extent=extent)\\n \\n # pull out clouds\\n qc, = cubes1.extract(['qc'])\\n cqc, = cubes2.extract(['qc'])\\n dates = utils.dates_from_iris(qc)\\n height = utils.height_from_iris(qc)\\n lats = qc.coord('latitude').points\\n lons = qc.coord('longitude').points\\n clats = cqc.coord('latitude').points\\n clons = cqc.coord('longitude').points\\n ff1, = fio.read_fire(mr1,dtimes=dates,extent=extent,firefront=True)\\n ff2, = fio.read_fire(mr2,dtimes=dates,extent=extent,firefront=True)\\n \\n # density plot bandwidth\\n bandwidth=1\\n \\n # make 4 vertical bins\\n row1 = (2000<=height) * (height<3000)\\n row2 = (3000<=height) * (height<5000)\\n row3 = (5000<=height) * (height<8000)\\n row4 = (8000<=height) * (height<15000)\\n titles = ['2km-3km','3km-5km','5km-8km','8km-15km']\\n \\n # loop over datetimes:\\n for di, date in enumerate(dates):\\n \\n qc1, qc2, qc3, qc4 = [np.sum(qc[di,row,:,:].data, axis=0) for row in [row1,row2,row3,row4]]\\n cqc1, cqc2, cqc3, cqc4 = [np.sum(cqc[di,row,:,:].data, axis=0) for row in [row1,row2,row3,row4]]\\n \\n # Plotting\\n plt.close()\\n fig, axes = plt.subplots(3,4,figsize=[12,11])\\n for i, (qci, cqci) in enumerate(zip([qc1, qc2, qc3, qc4],[cqc1, cqc2, cqc3, cqc4])):\\n ## Show contourf of cloud\\n plt.sca(axes[0,i])\\n \\n plotting.map_contourf(extent, qci, lats, lons, cmap=cmap, \\n clabel=\\\"\\\", norm=norm, cbar=False, levels=clevs,\\n cbarform=None, extend='max')\\n \\n # overlaid with cloud thresh line\\n if np.max(qci)>cloud_threshold:\\n with warnings.catch_warnings():\\n warnings.simplefilter('ignore')\\n plt.contour(lons,lats, qci, np.array([cloud_threshold]),\\n colors='teal', linewidths=2)\\n \\n # Add locations and fire\\n plotting.map_add_locations_extent(extentname, hide_text=True)\\n if ff1 is not None:\\n plotting.map_fire(ff1[di].data,lats,lons)\\n # Add ylabel on left most plot\\n if i==0: plt.ylabel(mr1)\\n # add title along top row\\n plt.title(titles[i])\\n \\n ## for comparison model also\\n plt.sca(axes[1,i])\\n img,_ = plotting.map_contourf(extent, cqci, clats, clons, cmap=cmap, \\n norm=norm, clabel=\\\"\\\", levels=clevs, \\n cbar=False, cbarform=None, extend='max')\\n \\n # overlaid with cloud thresh line\\n if np.max(cqci)>cloud_threshold:\\n with warnings.catch_warnings():\\n warnings.simplefilter('ignore')\\n plt.contour(clons, clats, cqci, np.array([cloud_threshold]),\\n colors='teal', linewidths=2)\\n # add fire\\n if ff2 is not None:\\n plotting.map_fire(ff2[di].data,clats,clons)\\n # add label on leftmost\\n if i==0: plt.ylabel(mr2)\\n \\n ## add density plot\\n plt.sca(axes[2,i])\\n \\n # density function:\\n # only if non zero cloud content\\n flag=2\\n if not np.isclose(np.max(qci),0):\\n qcdens = gaussian_kde(qci.flatten(), bw_method=bandwidth)\\n plt.plot(xs,qcdens(xs),linewidth=2,color='k')\\n flag-=1\\n if not np.isclose(np.max(cqci),0):\\n cqcdens = gaussian_kde(cqci.flatten(), bw_method=bandwidth)\\n plt.plot(xs,cqcdens(xs),color='r', linestyle='--')\\n flag-=1\\n plt.yticks([],[])\\n if i==0: plt.ylabel('cloud density')\\n if i==3: \\n # manually add legend\\n lines = [Line2D([0], [0], color='k', linewidth=2, linestyle='-'),\\n Line2D([0], [0], color='r', linewidth=1, linestyle='--')]\\n labels = [mr1,mr2]\\n plt.legend(lines, labels)\\n\\n \\n ## Add colourbar\\n cbar_ax = fig.add_axes([0.35, 0.367, 0.31, 0.01])# X Y Width Height\\n cbar=fig.colorbar(img, cax=cbar_ax, format=ticker.ScalarFormatter(), \\n pad=0, orientation='horizontal')\\n cbar.set_ticks([0,0.01,0.05,0.1,0.2,0.4])\\n cbar.set_ticklabels([0,0.01,0.05,0.1,0.2,0.4])\\n plt.suptitle(date.strftime(\\\"Max cloud content: %Y%m%d %H:%M(UTC)\\\"),\\n fontsize=20)\\n subdir='clouds'\\n if subsubdir is not None:\\n subdir += '/'+subsubdir\\n fio.save_fig(mr2, _sn_, date, plt, subdir=subdir)\",\n \"def main(idrun):\\n int_type = numpy.int32\\n double_type = numpy.float64\\n float_type = numpy.float32\\n complex_type = numpy.complex64\\n\\n ns = 7\\n iudm = 19; iuv = 12\\n dname = numpy.array([\\\"LONGITUDINAL EFIELD \\\",\\\"ELEC CURRENT DENSITY\\\",\\n \\\"VECTOR POTENTIAL \\\",\\\"TRANSVERSE EFIELD \\\",\\n \\\"MAGNETIC FIELD \\\",\\\"RADIATIVE VPOTENTIAL\\\",\\n \\\"ION CURRENT DENSITY \\\"],dtype=str)\\n\\n# create string from idrun\\n if (idrun < 0):\\n cdrun = \\\"Unknown\\\"\\n while (cdrun.isdigit() == False):\\n cdrun = input(\\\"enter integer idrun: \\\")\\n idrun = int(cdrun)\\n cdrun = str(idrun)\\n fname = \\\"diag3.\\\" + cdrun\\n cmfield3.ffopen3(iudm,fname)\\n\\n# nscalars = table of available diagnostics\\n nscalars = numpy.zeros((ns),int_type,'F')\\n\\n# determine which vector diagnostics are available\\n cmfield3.readvdiags3(iudm,nscalars)\\n\\n nts = numpy.zeros((1),int_type,'F')\\n modesx = numpy.zeros((1),int_type,'F')\\n modesy = numpy.zeros((1),int_type,'F')\\n modesz = numpy.zeros((1),int_type,'F')\\n mrec = numpy.zeros((1),int_type,'F')\\n fname = numpy.array([\\\"\\\"],'S32')\\n\\n# select diagnostic\\n m = numpy.sum(nscalars)\\n while True:\\n if (m > 0):\\n n = -1\\n while True:\\n if (n < 0):\\n for i in range(0,ns):\\n if (nscalars[i]==1):\\n print (\\\"enter \\\", i+1,\\\" for\\\", \\n numpy.str.rstrip(dname[i]))\\n print (\\\"enter \\\", 0,\\\" for EXIT\\\")\\n c = input(\\\"\\\")\\n if (c.isdigit()):\\n n = int(c)\\n if (n==0):\\n break\\n if ((n >= 1) and (n <= ns)):\\n if (nscalars[n-1]==0):\\n n = -1\\n else:\\n n = -1\\n if (n > 0):\\n break\\n print (\\\"invalid entry, try again or enter 0 to quit\\\")\\n else:\\n print (\\\"no vector diagnostic files found\\\")\\n n = 0\\n# exit procedure\\n if (n==0):\\n if (\\\"vfield\\\" in globals()):\\n vfield = None\\n cmfield3.closeff3(iudm)\\n return\\n\\n print (numpy.str.rstrip(dname[n-1]), \\\" diagnostic selected\\\")\\n\\n# return parameters for selected vector diagnostic:\\n# nts, modesx, modesy, modesz, nrec, fname\\n cmfield3.vdiagparams3(iudm,n,nts,modesx,modesy,modesz,mrec,fname)\\n nrec = mrec[0]\\n\\n# nx/ny/nz = number of global grid points in x/y/z direction\\n nx = int(math.pow(2,in3.indx)); ny = int(math.pow(2,in3.indy))\\n nz = int(math.pow(2,in3.indz))\\n# kyp/kzp = number of real grids in each field partition in y/z\\n kyp = int((ny - 1)/in3.nvpy) + 1; kzp = int((nz - 1)/in3.nvpz) + 1\\n# kyb/kzb = minimum number of processors in distributed array in y/z\\n kyb = int((ny - 1)/kyp) + 1; kzb = int((nz - 1)/kzp) + 1\\n# nyv = second dimension of scalar field array, >= ny\\n# nzv = third dimension of scalar field array, >= nz\\n nyv = kyp*kyb; nzv = kzp*kzb\\n\\n# allocate vector array\\n if (\\\"vfield\\\" not in globals()):\\n vfield = numpy.empty((in3.ndim,nx,nyv,nzv),float_type,'F')\\n dt = in3.dt*float(nts[0])\\n\\n# open stream file for vector field\\n cmfield3.fsopen3(iuv,fname)\\n\\n# nrec = number of complete records\\n nrec = int(nrec/(kyb*kzb))\\n print (\\\"records found: nrec = \\\", nrec)\\n\\n# read and transpose vector data\\n for ii in range(0,nrec):\\n# read real vector field\\n cmfield3.freadv3(iuv,vfield,in3.ndim,nx,kyp,kyb,kzp,kzb)\\n it = nts[0]*ii\\n time = dt*float(ii)\\n# show time\\n print (\\\"it,time=\\\",it,time)\\n cmfield3.closeff3(iuv)\\n print()\",\n \"def test_ne():\\n # Define some universal gsps\\n gsp = galsim.GSParams(maxk_threshold=1.1e-3, folding_threshold=5.1e-3)\\n\\n # Pixel. Params include scale, flux, gsparams.\\n # gsparams.\\n # The following should all test unequal:\\n gals = [galsim.Pixel(scale=1.0),\\n galsim.Pixel(scale=1.1),\\n galsim.Pixel(scale=1.0, flux=1.1),\\n galsim.Pixel(scale=1.0, gsparams=gsp)]\\n all_obj_diff(gals)\\n\\n # Box. Params include width, height, flux, gsparams.\\n # gsparams.\\n # The following should all test unequal:\\n gals = [galsim.Box(width=1.0, height=1.0),\\n galsim.Box(width=1.1, height=1.0),\\n galsim.Box(width=1.0, height=1.1),\\n galsim.Box(width=1.0, height=1.0, flux=1.1),\\n galsim.Box(width=1.0, height=1.0, gsparams=gsp)]\\n all_obj_diff(gals)\\n\\n # TopHat. Params include radius, flux, gsparams.\\n # gsparams.\\n # The following should all test unequal:\\n gals = [galsim.TopHat(radius=1.0),\\n galsim.TopHat(radius=1.1),\\n galsim.TopHat(radius=1.0, flux=1.1),\\n galsim.TopHat(radius=1.0, gsparams=gsp)]\\n all_obj_diff(gals)\",\n \"def main():\\n regexham = r'\\\\s+\\\\((\\\\d+,\\\\s*\\\\d+)\\\\)\\\\s+([\\\\-+]?\\\\d+\\\\.\\\\d+[eEdD]?[\\\\-+]?\\\\d+)' #to extract the Hamiltonian.\\n root = '.'\\n #fname = 'output_files/'\\n ciffci = CIFlow_Reader('testfci.dat', regexp = regexham , read_ham= True)\\n ciffcipar = CIFlow_Reader( 'psi0_output10outputfci.dat', regexp = regexham , read_ham = True)\\n #print ciffci.calc_overlap(cifdoci)\\n #print e.get_groundstate('00000000000011|00000000000011') \\n\\n psir = rp.PsiReader('psi0_output10.dat', isbig = False, numorbs = -1 , read_ints = False)\\n\\n detlist = dw.cimain(psir.values['nalpha'],psir.values['nbeta'], psir.values['norb'], [range(1,psir.values['nalpha']+psir.values['nbeta']), []], [] , fname = 'determinants.dat' ,ref = [lambda x , y , z : psir.get_hf_orbs()] , add_frozen = 0, write = False) #CISDDOCI\\n count = 0\\n for det in detlist:\\n for det2 in detlist:\\n #+ because the eigenvectors have already a different phasefactor of 1.\\n if abs(ciffci.get_mat_element(det[0]+'|'+det[1], det2[0]+'|'+det2[1]) - ciffcipar.get_mat_element(det[0]+'|'+det[1], det2[0]+'|'+det2[1]) ) > 1e-10 :\\n print 'difference in hamiltonian row: ' , det[0]+'|'+det[1] , \\\" col: \\\" , det2[0]+'|'+det2[1] , 'fci: ', ciffci.get_mat_element(det[0]+'|'+det[1], det2[0]+'|'+det2[1]) , 'fciaddres: ' , ciffcipar.get_mat_element(det[0]+'|'+det[1],det2[0]+'|'+det2[1]) \\n count += 1\\n print 'There were ' , count , ' different elements'\",\n \"def compare_present_day_river_directions_with_catchments_virna_data_with_vs_without_tarasov_style_orog_corrs(self):\\n ref_filename=os.path.join(self.plots_data_dir,\\n \\\"flowmap_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans\\\"\\n \\\"_lsmask_plus_upscale_rdirs_tarasov_orog_corrs_20170422_195301_upscaled_updated.nc\\\")\\n data_filename=os.path.join(self.plots_data_dir,\\n \\\"flowmap_ten_minute_data_from_virna_0k_ALG4_sinkless\\\"\\n \\\"_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_20170123\\\"\\n \\\"_165707_upscaled_updated.nc\\\")\\n lsmask_filename=os.path.join(self.plots_data_dir,\\n \\\"ls_mask_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask\\\"\\n \\\"_plus_upscale_rdirs_tarasov_orog_corrs_20170422_195301_HD_transf.nc\\\")\\n ref_catchment_filename=(\\\"catchmentmap_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask\\\"\\n \\\"_plus_upscale_rdirs_tarasov_orog_corrs_20170422_195301_upscaled_updated.nc\\\")\\n data_catchment_filename=(\\\"catchmentmap_ten_minute_data_from_virna_0k_ALG4_sinkless\\\"\\n \\\"_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_20170123_165707_upscaled_updated.nc\\\")\\n ref_rdirs_filename=(\\\"upscaled_rdirs_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_\\\"\\n \\\"sinks_oceans_lsmask_plus_upscale_rdirs_tarasov_orog_corrs_20170422_195301_upscaled_\\\"\\n \\\"updated_transf.dat\\\")\\n reference_rmouth_outflows_filename=(self.plots_data_dir + \\\"/rmouthmap_ten_minute_\\\"\\n \\\"data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale\\\"\\n \\\"_rdirs_tarasov_orog_corrs_20170422_195301_upscaled_updated.nc\\\")\\n data_rmouth_outflows_filename=(self.plots_data_dir + \\\"/rmouths/rmouthmap_ten_\\\"\\n \\\"minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus\\\"\\n \\\"_upscale_rdirs_20170123_165707_upscaled_updated.nc\\\")\\n glacier_mask_filename=os.path.join(self.orog_data_directory,\\\"ice5g_v1_2_21_0k_10min.nc\\\")\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n ref_catchment_filename,\\n data_catchment_filename=\\\\\\n data_catchment_filename,\\n ref_rdirs_filename=\\\\\\n ref_rdirs_filename,\\n data_rdirs_filename=None,\\n reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=100,\\n flip_data=False,\\n rotate_data=True,\\n flip_ref=False,\\n rotate_ref=True,\\n lsmask_has_same_orientation_as_ref=False,\\n invert_ls_mask=True,\\n first_datasource_name=\\\"Present day\\\",\\n second_datasource_name=\\\"LGM\\\",\\n matching_parameter_set='extensive',\\n catchment_and_outflows_mods_list_filename=\\\\\\n \\\"catch_and_outflow_mods_lgm_vs_present_day.txt\\\",\\n additional_matches_list_filename=\\\\\\n \\\"additional_matches_10min_upscaled_lgm_vs_present.txt\\\",\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n use_title=False,remove_antartica=True,\\n difference_in_catchment_label=\\\"Difference\\\",\\n glacier_mask_filename=glacier_mask_filename,\\n glacier_mask_grid_type='LatLong10min',\\n flip_glacier_mask=True,\\n rotate_glacier_mask=True,\\n grid_type='HD')\",\n \"def compare_predictions():\\n validation_labels = np.array(pd.read_csv(val_true_labels_dir + dataset_version + 'validation_labels.csv', index_col=0))\\n validation_labels = np.reshape(validation_labels, (-1))\\n\\n diff_between_files = []\\n also1s = []\\n also2s = []\\n for filename1 in os.listdir(val_predictions_dir):\\n if filename1.endswith(\\\".csv\\\"):\\n for filename2 in os.listdir(val_predictions_dir):\\n if filename2.endswith(\\\".csv\\\"):\\n if filename1 < filename2:\\n wrong1 = 0\\n wrong2 = 0\\n diff_between = 0\\n also1 = 0\\n also2 = 0\\n diff_corr1 = 0\\n diff_corr2 = 0\\n f1 = np.array(pd.read_csv(val_predictions_dir + filename1, index_col=0))\\n f1 = np.reshape(f1, (-1))\\n f2 = np.array(pd.read_csv(val_predictions_dir + filename2, index_col=0))\\n f2 = np.reshape(f2, (-1))\\n for line in range(f1.shape[0]):\\n if f1[line] != validation_labels[line]:\\n wrong1 += 1\\n if f2[line] != validation_labels[line]:\\n wrong2 += 1\\n if f1[line] != f2[line]:\\n diff_between += 1\\n if f1[line] == validation_labels[line]:\\n diff_corr1 += 1\\n if f2[line] == validation_labels[line]:\\n diff_corr2 += 1\\n if f1[line] != validation_labels[line]:\\n if f2[line] != validation_labels[line]:\\n also2 += 1\\n if f2[line] != validation_labels[line]:\\n if f1[line] != validation_labels[line]:\\n also1 += 1\\n\\n diff_between_files.append(diff_between)\\n print(filename1)\\n print('Wrongly predicted by 1: ' + str(100 * wrong1 / f1.shape[0]) + '%')\\n print(filename2)\\n print('Wrongly predicted by 2: ' + str(100 * wrong2 / f1.shape[0]) + '%')\\n print()\\n print('Differences between files: ' + str(100 * diff_between / f1.shape[0]) + '%')\\n print(f'\\\\t of which correct by 1 {100 * diff_corr1 / diff_between}%, by 2 {100 * diff_corr2 / diff_between}%')\\n also1s.append(also1 / wrong2)\\n also2s.append(also2 / wrong1)\\n print('Wrongly predicted by other among wrong ones: ' + str(100 * also2 / wrong1) + '%, ' + str(\\n 100 * also1 / wrong2) + '%\\\\n\\\\n\\\\n')\\n\\n print('Max, min and avg differences between files:')\\n print(str(100 * max(diff_between_files) / validation_labels.shape[0]) + '%')\\n print(str(100 * min(diff_between_files) / validation_labels.shape[0]) + '%')\\n print(str(100 * np.mean(diff_between_files) / validation_labels.shape[0]) + '%')\\n\\n print('\\\\nWrongly predicted by first that were also wrongly predicted by second:')\\n print('Max: ' + str(100 * max(also2s)) + '%')\\n print('Min: ' + str(100 * min(also2s)) + '%')\\n print('Avg: ' + str(100 * np.mean(also2s)) + '%')\\n\\n print('\\\\nWrongly predicted by second that were also wrongly predicted by first:')\\n print('Max: ' + str(100 * max(also1s)) + '%')\\n print('Min: ' + str(100 * min(also1s)) + '%')\\n print('Avg: ' + str(100 * np.mean(also1s)) + '%')\",\n \"def compare_present_day_and_lgm_river_directions_with_catchments_virna_data_plus_tarasov_style_orog_corrs_for_both(self):\\n ref_filename=os.path.join(self.plots_data_dir,\\n \\\"flowmap_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans\\\"\\n \\\"_lsmask_plus_upscale_rdirs_tarasov_orog_corrs_20170422_195301_upscaled_updated.nc\\\")\\n data_filename=os.path.join(self.plots_data_dir,\\n \\\"flowmap_ten_minute_data_from_virna_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask\\\"\\n \\\"_plus_upscale_rdirs_tarasov_orog_corrs_20170422_195436_upscaled_updated.nc\\\")\\n lsmask_filename=os.path.join(self.plots_data_dir,\\n \\\"ls_mask_ten_minute_data_from_virna_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask\\\"\\n \\\"_plus_upscale_rdirs_tarasov_orog_corrs_20170422_195436_HD_transf.dat\\\")\\n ref_catchment_filename=(\\\"catchmentmap_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask\\\"\\n \\\"_plus_upscale_rdirs_tarasov_orog_corrs_20170422_195301_upscaled_updated.nc\\\")\\n data_catchment_filename=(\\\"catchmentmap_ten_minute_data_from_virna_lgm_ALG4_sinkless_no_true_sinks_oceans_\\\"\\n \\\"lsmask_plus_upscale_rdirs_tarasov_orog_corrs_20170422_195436_upscaled_updated.nc\\\")\\n ref_rdirs_filename=(\\\"upscaled_rdirs_ten_minute_data_from_virna_0k_ALG4_sinkless_no_true_\\\"\\n \\\"sinks_oceans_lsmask_plus_upscale_rdirs_tarasov_orog_corrs_20170422_195301_upscaled_\\\"\\n \\\"updated_transf.dat\\\")\\n reference_rmouth_outflows_filename=(self.plots_data_dir + \\\"/rmouthmap_ten_minute_\\\"\\n \\\"data_from_virna_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale\\\"\\n \\\"_rdirs_tarasov_orog_corrs_20170422_195301_upscaled_updated.nc\\\")\\n data_rmouth_outflows_filename=(self.plots_data_dir + \\\"/rmouthmap_ten_minute_\\\"\\n \\\"data_from_virna_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale\\\"\\n \\\"_rdirs_tarasov_orog_corrs_20170422_195436_upscaled_updated.nc\\\")\\n glacier_mask_filename=os.path.join(self.orog_data_directory,\\\"ice5g_v1_2_21_0k_10min.nc\\\")\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n ref_catchment_filename,\\n data_catchment_filename=\\\\\\n data_catchment_filename,\\n ref_rdirs_filename=\\\\\\n ref_rdirs_filename,\\n data_rdirs_filename=None,\\n reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=100,\\n flip_data=False,\\n rotate_data=True,\\n flip_ref=False,\\n rotate_ref=True,\\n lsmask_has_same_orientation_as_ref=False,\\n invert_ls_mask=True,\\n first_datasource_name=\\\"Present day\\\",\\n second_datasource_name=\\\"LGM\\\",\\n matching_parameter_set='extensive',\\n catchment_and_outflows_mods_list_filename=\\\\\\n \\\"catch_and_outflow_mods_lgm_vs_present_day.txt\\\",\\n additional_matches_list_filename=\\\\\\n \\\"additional_matches_10min_upscaled_lgm_vs_present.txt\\\",\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n use_title=False,remove_antartica=True,\\n difference_in_catchment_label=\\\"Difference\\\",\\n glacier_mask_filename=glacier_mask_filename,\\n glacier_mask_grid_type='LatLong10min',\\n flip_glacier_mask=True,\\n rotate_glacier_mask=True,\\n grid_type='HD')\",\n \"def AdvancedOutFlowComparisonPlotHelpers(self,\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename,\\n ref_flowmaps_filename,\\n data_flowmaps_filename,\\n ref_rdirs_filename,\\n data_rdirs_filename,\\n ref_catchment_filename,\\n data_catchment_filename,\\n ref_orog_filename,\\n data_orog_filename,\\n super_fine_orog_filename=None,\\n super_fine_data_flowmap_filename=None,\\n external_ls_mask_filename=None,\\n additional_matches_list_filename=None,\\n catchment_and_outflows_mods_list_filename=None,\\n rivers_to_plot=None,\\n matching_parameter_set='default',\\n select_only_rivers_in=None,\\n allow_new_true_sinks=False,\\n alternative_catchment_bounds=None,\\n use_simplified_catchment_colorscheme=False,\\n use_simplified_flowmap_colorscheme=False,\\n use_upscaling_labels=False,\\n swap_ref_and_data_when_finding_labels=False,\\n super_fine_orog_grid_type='LatLong1min',\\n grid_type='HD',\\n super_fine_orog_grid_kwargs={},\\n **grid_kwargs):\\n ref_catchment_field = advanced_field_loader(ref_catchment_filename,\\n time_slice=None,\\n fieldname=\\\"catch\\\",\\n adjust_orientation=True)\\n data_catchment_field = advanced_field_loader(data_catchment_filename,\\n time_slice=None,\\n fieldname=\\\"catch\\\",\\n adjust_orientation=True)\\n ref_flowtocellfield = advanced_field_loader(ref_flowmaps_filename,\\n time_slice=None,\\n fieldname=\\\"acc\\\",\\n adjust_orientation=True)\\n data_flowtocellfield = advanced_field_loader(data_flowmaps_filename,\\n time_slice=None,\\n fieldname=\\\"acc\\\",\\n adjust_orientation=True)\\n ref_rdirs_field = advanced_field_loader(ref_rdirs_filename,\\n time_slice=None,\\n fieldname=\\\"rdir\\\",\\n adjust_orientation=True)\\n data_rdirs_field = advanced_field_loader(data_rdirs_filename,\\n time_slice=None,\\n fieldname=\\\"rdir\\\",\\n adjust_orientation=True)\\n ref_orog_field = advanced_field_loader(ref_orog_filename,\\n time_slice=None,\\n fieldname=\\\"z\\\",\\n adjust_orientation=True)\\n data_orog_field = advanced_field_loader(data_orog_filename,\\n time_slice=None,\\n fieldname=\\\"z\\\",\\n adjust_orientation=True)\\n super_fine_orog_field = advanced_field_loader(super_fine_orog_filename,\\n time_slice=None,\\n fieldname=\\\"z\\\",\\n adjust_orientation=True)\\n\\n super_fine_flowtocellfield = None\\n if external_ls_mask_filename is not None:\\n external_ls_mask = advanced_field_loader(external_ls_mask_filename,\\n time_slice=None,\\n fieldname=\\\"lsmask\\\",\\n adjust_orientation=True)\\n else:\\n external_ls_mask = None\\n scale_factor = 1.0\\n catchment_grid_changed = False\\n temp_file_list = []\\n if catchment_and_outflows_mods_list_filename:\\n ref_outflow_field = advanced_field_loader(reference_rmouth_outflows_filename,\\n time_slice=None,\\n fieldname=\\\"acc\\\",\\n adjust_orientation=True)\\n data_outflow_field = advanced_field_loader(data_rmouth_outflows_filename,\\n time_slice=None,\\n fieldname=\\\"acc\\\",\\n adjust_orientation=True)\\n ref_catchment_field, ref_outflow_field, data_catchment_field, data_outflow_field =\\\\\\n rc_pts.modify_catchments_and_outflows(ref_catchments=ref_catchment_field,\\n ref_outflows=ref_outflow_field,\\n ref_flowmap=ref_flowtocellfield,\\n ref_rdirs = ref_rdirs_field,\\n data_catchments=data_catchment_field,\\n data_outflows=data_outflow_field,\\n catchment_and_outflows_modifications_list_filename=\\\\\\n catchment_and_outflows_mods_list_filename,\\n original_scale_catchment=\\\\\\n None,\\n original_scale_flowmap=\\\\\\n None,\\n catchment_grid_changed=False,\\n swap_ref_and_data_when_finding_labels=\\\\\\n swap_ref_and_data_when_finding_labels,\\n original_scale_grid_type=\\\\\\n None,\\n original_scale_grid_kwargs=\\\\\\n None,\\n grid_type=grid_type,**grid_kwargs)\\n reference_rmouth_outflows_filename=os.path.join(self.scratch_dir,\\n self.temp_label + os.path.\\\\\\n basename(reference_rmouth_outflows_filename))\\n data_rmouth_outflows_filename=os.path.join(self.scratch_dir,\\n self.temp_label + os.path.\\\\\\n basename(reference_rmouth_outflows_filename))\\n temp_file_list.append(reference_rmouth_outflows_filename)\\n temp_file_list.append(data_rmouth_outflows_filename)\\n iodriver.advanced_field_writer(reference_rmouth_outflows_filename,\\n ref_outflow_field,\\n fieldname=\\\"acc\\\")\\n iodriver.advanced_field_writer(data_rmouth_outflows_filename,\\n data_outflow_field,\\n fieldname=\\\"acc\\\")\\n matchedpairs, unresolved_conflicts = mtch_rm.advanced_main(reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename,\\n 'acc',\\\"acc\\\",\\n param_set=matching_parameter_set)\\n if additional_matches_list_filename:\\n additional_matches = mtch_rm.load_additional_manual_matches(additional_matches_list_filename,\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename,\\n grid_type=grid_type,\\n **grid_kwargs)\\n matchedpairs.extend(additional_matches)\\n interactive_plots = Interactive_Plots()\\n super_fine_grid = grid.makeGrid(super_fine_orog_grid_type,\\n **super_fine_orog_grid_kwargs)\\n ref_grid = grid.makeGrid(grid_type,**grid_kwargs)\\n fine_grid = grid.makeGrid(grid_type,**grid_kwargs)\\n river_names = []\\n for pair in matchedpairs:\\n if pair[0].get_lat() > 310*3:\\n continue\\n if select_only_rivers_in == \\\"North America\\\":\\n if(pair[0].get_lat() > 156*3 or pair[0].get_lon() > 260*3):\\n continue\\n print(\\\"Ref Point: \\\" + str(pair[0]) + \\\"Matches: \\\" + str(pair[1]))\\n if rivers_to_plot is not None:\\n if not (pair[0].get_lat(),pair[0].get_lon()) in rivers_to_plot:\\n continue\\n formatted_river_name = pts.generate_label_for_river(pair,scale_factor=6,\\n river_names=river_names)\\n fig = plt.figure(formatted_river_name + \\\" - Overview\\\",figsize=(25,12.5))\\n fig.suptitle(formatted_river_name)\\n ax = plt.subplot(222)\\n rc_pts.plot_river_rmouth_flowmap(ax=ax,\\n ref_flowtocellfield=ref_flowtocellfield.get_data(),\\n data_flowtocellfield=data_flowtocellfield.get_data(),\\n rdirs_field=ref_rdirs_field.get_data(),\\n pair=pair,colors=self.colors,\\n point_label_coords_scaling=3)\\n ax_hist = plt.subplot(221)\\n ax_catch = plt.subplot(223)\\n catchment_section,catchment_bounds,scale_factor = \\\\\\n rc_pts.plot_catchment_and_histogram_for_river(ax_hist=ax_hist,ax_catch=ax_catch,\\n ref_catchment_field=ref_catchment_field.get_data(),\\n data_catchment_field=data_catchment_field.get_data(),\\n data_catchment_field_original_scale=\\\\\\n data_catchment_field.get_data(),\\n data_original_scale_flowtocellfield=\\\\\\n data_flowtocellfield.get_data(),\\n rdirs_field=ref_rdirs_field.get_data(),\\n data_rdirs_field=data_rdirs_field.get_data(),\\n pair=pair,\\n catchment_grid_changed=catchment_grid_changed,\\n swap_ref_and_data_when_finding_labels=\\\\\\n swap_ref_and_data_when_finding_labels,\\n colors=self.colors,\\n ref_grid=ref_grid,\\n grid_type=grid_type,\\n alternative_catchment_bounds=\\\\\\n alternative_catchment_bounds,\\n use_simplified_catchment_colorscheme=\\\\\\n use_simplified_catchment_colorscheme,\\n use_upscaling_labels=\\\\\\n use_upscaling_labels,\\n allow_new_sink_points=\\\\\\n allow_new_true_sinks,\\n external_landsea_mask=\\\\\\n external_ls_mask,\\n ref_original_scale_flowtocellfield=\\\\\\n ref_flowtocellfield,\\n ref_catchment_field_original_scale=\\\\\\n ref_catchment_field,\\n use_original_scale_field_for_determining_data_and_ref_labels=\\\\\\n False,\\n return_catchment_plotter=\\\\\\n False,\\n data_original_scale_grid_type=\\\\\\n grid_type,\\n ref_original_scale_grid_type=\\\\\\n grid_type,\\n data_original_scale_grid_kwargs=\\\\\\n grid_kwargs,\\n ref_original_scale_grid_kwargs=\\\\\\n grid_kwargs,\\n **grid_kwargs)\\n ax = plt.subplot(224)\\n rc_pts.plot_whole_river_flowmap(ax=ax,pair=pair,\\n ref_flowtocellfield=ref_flowtocellfield.get_data(),\\n data_flowtocellfield=data_flowtocellfield.get_data(),\\n rdirs_field=ref_rdirs_field.get_data(),\\n data_rdirs_field=data_rdirs_field.get_data(),\\n catchment_bounds=catchment_bounds,colors=self.colors,\\n simplified_flowmap_plot=use_simplified_flowmap_colorscheme,\\n allow_new_sink_points=allow_new_true_sinks)\\n if super_fine_orog_filename:\\n ref_to_super_fine_scale_factor = \\\\\\n pts.calculate_scale_factor(coarse_grid_type=grid_type,\\n coarse_grid_kwargs=grid_kwargs,\\n fine_grid_type=super_fine_orog_grid_type,\\n fine_grid_kwargs=super_fine_orog_grid_kwargs)\\n else:\\n ref_to_super_fine_scale_factor=None\\n interactive_plots.setup_plots(catchment_section,\\n ref_orog_field.get_data(),\\n data_orog_field.get_data(),\\n ref_flowtocellfield.get_data(),\\n data_flowtocellfield.get_data(),\\n ref_rdirs_field.get_data(),\\n super_fine_orog_field.get_data(),\\n super_fine_flowtocellfield.get_data()\\n if super_fine_flowtocellfield is not None else None,\\n pair, catchment_bounds,\\n scale_factor,\\n ref_to_super_fine_scale_factor,\\n ref_grid_offset_adjustment=ref_grid.\\\\\\n get_longitude_offset_adjustment(),\\n fine_grid_offset_adjustment=fine_grid.\\\\\\n get_longitude_offset_adjustment(),\\n super_fine_grid_offset_adjustment=super_fine_grid.\\\\\\n get_longitude_offset_adjustment(),\\n point_label_coords_scaling=3,\\n river_name=formatted_river_name)\\n print(\\\"Unresolved Conflicts: \\\")\\n for conflict in unresolved_conflicts:\\n print(\\\" Conflict:\\\")\\n for pair in conflict:\\n print(\\\" Ref Point\\\" + str(pair[0]) + \\\"Matches\\\" + str(pair[1]))\\n for temp_file in temp_file_list:\\n if os.path.basename(temp_file).startswith(\\\"temp_\\\"):\\n print(\\\"Deleting File: {0}\\\".format(temp_file))\\n os.remove(temp_file)\",\n \"def test_hsmcatalog():\\n if __name__ == '__main__':\\n logger = piff.config.setup_logger(verbose=2)\\n else:\\n logger = piff.config.setup_logger(log_file='output/test_hsmcatalog.log')\\n\\n image_file = os.path.join('output','test_stats_image.fits')\\n cat_file = os.path.join('output','test_stats_cat.fits')\\n psf_file = os.path.join('output','test_starstats.fits')\\n hsm_file = os.path.join('output', 'test_hsmcatalog.fits')\\n config = {\\n 'input' : {\\n 'image_file_name' : image_file,\\n 'cat_file_name' : cat_file,\\n 'stamp_size' : 48,\\n },\\n 'select' : {\\n 'reserve_frac' : 0.2,\\n 'seed' : 123\\n },\\n 'psf' : {\\n 'model' : { 'type' : 'Gaussian',\\n 'fastfit': True,\\n 'include_pixel': False },\\n 'interp' : { 'type' : 'Mean' },\\n },\\n 'output' : {\\n 'file_name' : psf_file,\\n 'stats' : [\\n {\\n 'type': 'HSMCatalog',\\n 'file_name': hsm_file,\\n }\\n ]\\n }\\n }\\n piff.piffify(config, logger)\\n assert os.path.isfile(hsm_file)\\n\\n data, header = fitsio.read(hsm_file, header=True)\\n for col in ['ra', 'dec', 'x', 'y', 'u', 'v',\\n 'T_data', 'g1_data', 'g2_data',\\n 'T_model', 'g1_model', 'g2_model',\\n 'flux', 'reserve', 'flag_data', 'flag_model']:\\n assert len(data[col]) == 10\\n true_data = fitsio.read(cat_file)\\n\\n assert header['PIFF_VERSION'] == piff.__version__\\n\\n np.testing.assert_allclose(data['x'], true_data['x'])\\n np.testing.assert_allclose(data['y'], true_data['y'])\\n np.testing.assert_allclose(data['flux'], 123.45, atol=0.001)\\n print('reserve = ',data['reserve'])\\n print('nreserve = ',np.sum(data['reserve']))\\n print('ntot = ',len(data['reserve']))\\n assert np.sum(data['reserve']) == int(0.2 * len(data['reserve']))\\n np.testing.assert_allclose(data['T_model'], data['T_data'], rtol=1.e-4)\\n np.testing.assert_allclose(data['g1_model'], data['g1_data'], rtol=1.e-4)\\n np.testing.assert_allclose(data['g2_model'], data['g2_data'], rtol=1.e-4)\\n\\n # On this file, no hsm errors\\n np.testing.assert_array_equal(data['flag_data'], 0)\\n np.testing.assert_array_equal(data['flag_model'], 0)\\n\\n image = galsim.fits.read(image_file)\\n world = [image.wcs.toWorld(galsim.PositionD(x,y)) for x,y in zip(data['x'],data['y'])]\\n np.testing.assert_allclose(data['ra'], [w.ra.deg for w in world], rtol=1.e-4)\\n np.testing.assert_allclose(data['dec'], [w.dec.deg for w in world], rtol=1.e-4)\\n\\n # Repeat with non-Celestial WCS\\n wcs = galsim.AffineTransform(0.26, 0.05, -0.08, -0.24, galsim.PositionD(1024,1024))\\n config['input']['wcs'] = wcs\\n piff.piffify(config, logger)\\n data = fitsio.read(hsm_file)\\n np.testing.assert_array_equal(data['ra'], 0.)\\n np.testing.assert_array_equal(data['dec'], 0.)\\n world = [wcs.toWorld(galsim.PositionD(x,y)) for x,y in zip(data['x'],data['y'])]\\n np.testing.assert_allclose(data['u'], [w.x for w in world], rtol=1.e-4)\\n np.testing.assert_allclose(data['v'], [w.y for w in world], rtol=1.e-4)\\n\\n # Use class directly, rather than through config.\\n psf = piff.PSF.read(psf_file)\\n stars, _, _ = piff.Input.process(config['input'])\\n stars = piff.Select.process(config['select'], stars)\\n hsmcat = piff.stats.HSMCatalogStats()\\n with np.testing.assert_raises(RuntimeError):\\n hsmcat.write('dummy') # Cannot write before compute\\n hsmcat.compute(psf, stars)\\n hsm_file2 = os.path.join('output', 'test_hsmcatalog2.fits')\\n with np.testing.assert_raises(ValueError):\\n hsmcat.write() # Must supply file_name if not given in constructor\\n hsmcat.write(hsm_file2)\\n data2 = fitsio.read(hsm_file2)\\n for key in data.dtype.names:\\n np.testing.assert_allclose(data2[key], data[key], rtol=1.e-5)\",\n \"def compare_displacements(ds1,ds2):\\n # Obteniendo los datos para BP\\n t1 = ds1['t']\\n t1 = t1[:n_im-1]\\n t1 = mplt.dates.date2num(t1)\\n d1 = ds1['d_t']\\n # Obteniendo los datos para RMA\\n t2 = ds2['t']\\n t2 = t2[:n_im-1]\\n t2 = mplt.dates.date2num(t2)\\n d2 = ds2['d_t']\\n\\n # Graficando las 2 curvas juntas\\n formatter = DateFormatter(\\\"%d/%m - %H:%M\\\")\\n for i in range(len(d1)):\\n # Hallando el valor promedio final x zona\\n mean_bp = d1[i].mean()\\n mean_rma = d2[i].mean()\\n print(\\\"Valor promedio BP_zona\\\"+str(i)+\\\": \\\",mean_bp)\\n print(\\\"Valor promedio RMA_zona\\\"+str(i)+\\\": \\\",mean_rma)\\n print(\\\"\\\")\\n # Graficando\\n direction = 'desplazamientosPromedios_dset'+str(i_o)+'-'+str(i_o+n_im-1)+'_zona'+str(i)\\n\\n fig, ax= plt.subplots(figsize=(10,7))\\n ax.plot_date(t1,d1[i],'b',marker='',markerfacecolor='b',markeredgecolor='b',label='Back Projection')\\n ax.plot_date(t2,d2[i],'r',marker='',markerfacecolor='r',markeredgecolor='r',label='RMA')\\n ax.set(xlabel='Tiempo',ylabel='Desplazamiento(mm)',title=\\\"Desplazamientos promedios\\\\n(Zona \\\"+str(i)+')')\\n ax.xaxis.set_major_formatter(formatter)\\n ax.xaxis.set_tick_params(rotation=20)\\n #ax.set_xlim([R.min(),R.max()])\\n ax.set_ylim([-c*1000*4/(4*fc),c*1000*4/(4*fc)])\\n ax.grid(linestyle='dashed')\\n ax.legend()\\n plt.show()\\n fig.savefig(os.getcwd()+\\\"/Results/Desplazamientos/\\\"+direction,orientation='landscape')\\n\\n return 'Ok'\",\n \"def compare_brain_and_stimulus_input_data(self):\\t\\n\\n\\t\\t# first check which (unique) patches are presented\\n\\t\\tstim_info = np.loadtxt(self.runFile(stage = 'processed/behavior', extension = '.txt', postFix = ['stim_info_all']))\\n\\t\\tunique_stim = np.unique(stim_info[:,2])\\n\\t\\tstimuli = np.array(self.rescale_images(patches = list(np.array(unique_stim, dtype = int))))\\n\\n\\t\\t# select patches that are similar and patches that are dissimilar\\n\\t\\tmask = self.create_stim_mask(stim_shape = stimuli.shape[1], radius_inner = 0.04, outer = False)\\n\\t\\t\\n\\t\\t# create correlation matrix for all presented stimuli\\n\\t\\tstim_correlations = np.zeros((stimuli.shape[0], stimuli.shape[0]))\\n\\t\\t\\t\\n\\t\\tfor i, stim in enumerate(stimuli): # all stimuli\\n\\t\\t\\tstim_correlations[i, :] = np.array([pearsonr(stim.ravel()[mask], stim_2.ravel()[mask])[0] for stim_2 in stimuli])\\n\\n\\t\\t# store similarity info per individual stimuli [stimuli, less similar, most, similar]\\t\\t\\n\\t\\tstim_similarity = np.array([[unique_stim[i], unique_stim[np.argsort(stim_correlations[i])[0]], unique_stim[np.argsort(stim_correlations[i])[-2]]] for i in range(stim_correlations.shape[0])])\\t\\t\\n\\n\\n\\t\\tstim_correlations[i][np.argsort(stim_correlations[i])[0]], stim_correlations[i][np.argsort(stim_correlations[i])[-2]]\",\n \"def run_multi_medium_inversion(datadir, outdir, real_data_fnames, MT_green_func_fnames, single_force_green_func_fnames, data_labels, inversion_type, perform_normallised_waveform_inversion, compare_all_waveforms_simultaneously, num_samples, comparison_metric, manual_indices_time_shift_MT, manual_indices_time_shift_SF, nlloc_hyp_filename, cut_phase_start_vals=[], cut_phase_length=0, plot_switch=False, num_processors=1, set_pre_time_shift_values_to_zero_switch=True, only_save_non_zero_solns_switch=False, return_absolute_similarity_values_switch=False, invert_for_ratio_of_multiple_media_greens_func_switch=False, green_func_fnames_split_index=0, green_func_phase_labels=[], invert_for_relative_magnitudes_switch=False, rel_exp_mag_range=[1.,1.], auto_shift_for_best_fit=True):\\n \\n # Load input data (completely, for specific inversion type):\\n real_data_array, green_func_array = get_overall_real_and_green_func_data(datadir, real_data_fnames, MT_green_func_fnames, single_force_green_func_fnames, inversion_type, manual_indices_time_shift_MT=manual_indices_time_shift_MT, manual_indices_time_shift_SF=manual_indices_time_shift_SF, cut_phase_start_vals=cut_phase_start_vals, cut_phase_length=cut_phase_length, set_pre_time_shift_values_to_zero_switch=set_pre_time_shift_values_to_zero_switch, invert_for_ratio_of_multiple_media_greens_func_switch=invert_for_ratio_of_multiple_media_greens_func_switch, green_func_fnames_split_index=green_func_fnames_split_index)\\n \\n # Do initial check/s:\\n if len(green_func_phase_labels)>0:\\n if not len(green_func_array[:,0,0,0]) == len(green_func_phase_labels):\\n print(\\\"Error: Greens functions filename array (for medium 1), does not match length of green_func_phase_labels array.\\\")\\n sys.exit()\\n \\n # Get number of different phases, if specified:\\n num_phase_types_for_media_ratios = 0\\n if green_func_phase_labels.count(\\\"P\\\")>0:\\n num_phase_types_for_media_ratios += 1\\n if green_func_phase_labels.count(\\\"S\\\")>0:\\n num_phase_types_for_media_ratios += 1\\n if green_func_phase_labels.count(\\\"surface\\\")>0:\\n num_phase_types_for_media_ratios += 1\\n \\n # Define a fraction of the second medium to use for the simple least squares inversion:\\n frac_medium_2 = 0.5\\n green_func_array_for_lsq_inv = (1. - frac_medium_2)*green_func_array[:,:,:,0] + frac_medium_2*green_func_array[:,:,:,1]\\n \\n # Perform the inversion:\\n M = perform_inversion(real_data_array, green_func_array_for_lsq_inv)\\n M_amplitude = ((np.sum(M**2))**0.5)\\n\\n # And get forward model synthetic waveform result:\\n synth_forward_model_result_array = forward_model(green_func_array_for_lsq_inv, M)\\n\\n # And plot the results:\\n if plot_switch:\\n plot_specific_forward_model_result(real_data_array, synth_forward_model_result_array, data_labels, plot_title=\\\"Initial theoretical inversion solution\\\", perform_normallised_waveform_inversion=perform_normallised_waveform_inversion)\\n\\n # And save least squares output:\\n # Set output arrays to equal least squares output: \\n MTs = M\\n similarity_curr_sample, shift_idxs = compare_synth_to_real_waveforms(real_data_array, synth_forward_model_result_array, comparison_metric, perform_normallised_waveform_inversion, compare_all_waveforms_simultaneously, auto_shift_for_best_fit) \\n MTp = np.array([similarity_curr_sample])\\n # And save data to MTFIT style file:\\n outdir_least_squares = outdir+\\\"/least_squares_result\\\"\\n os.system(\\\"mkdir -p \\\"+outdir_least_squares)\\n save_to_MTFIT_style_file(MTs, MTp, nlloc_hyp_filename, inversion_type, outdir_least_squares, shift_idxs=shift_idxs) # Saves pickled dictionary containing data from inversion\\n # And save most likely solution and real data waveforms to file:\\n if inversion_type == \\\"DC_single_force_couple\\\" or inversion_type == \\\"DC_single_force_no_coupling\\\" or inversion_type == \\\"DC_crack_couple\\\" or inversion_type == \\\"single_force_crack_no_coupling\\\":\\n synth_forward_model_most_likely_result_array = forward_model(green_func_array, MTs[:-1, np.where(MTp==np.max(MTp))[0][0]])\\n else:\\n synth_forward_model_most_likely_result_array = forward_model(green_func_array, MTs[:, np.where(MTp==np.max(MTp))[0][0]])\\n # And get shift associated with most likely model:\\n if len(shift_idxs) > 0:\\n shift_idxs_most_likely_result = np.array(shift_idxs)\\n else:\\n shift_idxs_most_likely_result = []\\n # And save:\\n save_specific_waveforms_to_file(real_data_array, synth_forward_model_most_likely_result_array, data_labels, nlloc_hyp_filename, inversion_type, outdir_least_squares, shift_idxs=shift_idxs_most_likely_result, normallise_data=perform_normallised_waveform_inversion)\\n\\n # And do Monte Carlo random sampling to obtain PDF of moment tensor:\\n MTs, MTp, MTp_absolute, shift_idxs_all_samples = perform_monte_carlo_sampled_waveform_inversion(real_data_array, green_func_array, num_samples, M_amplitude=M_amplitude,inversion_type=inversion_type, comparison_metric=comparison_metric, perform_normallised_waveform_inversion=perform_normallised_waveform_inversion, compare_all_waveforms_simultaneously=compare_all_waveforms_simultaneously, num_processors=num_processors, return_absolute_similarity_values_switch=return_absolute_similarity_values_switch, invert_for_ratio_of_multiple_media_greens_func_switch=invert_for_ratio_of_multiple_media_greens_func_switch, green_func_phase_labels=green_func_phase_labels, num_phase_types_for_media_ratios=num_phase_types_for_media_ratios, invert_for_relative_magnitudes_switch=invert_for_relative_magnitudes_switch, rel_exp_mag_range=rel_exp_mag_range, auto_shift_for_best_fit=auto_shift_for_best_fit)\\n\\n # Check that probability of output is non-zero:\\n if math.isnan(MTp[0]):\\n print(\\\"Error: Sum of probabilities is equal to zero - therefore no adiquate solution could be found and inversion is terminating.\\\")\\n sys.exit()\\n \\n # Remove zero probability values if specified:\\n if only_save_non_zero_solns_switch:\\n MTp, MTs = remove_zero_prob_results(MTp, MTs)\\n\\n # And plot most likely solution:\\n if plot_switch:\\n if inversion_type == \\\"DC_single_force_couple\\\" or inversion_type == \\\"DC_single_force_no_coupling\\\" or inversion_type == \\\"DC_crack_couple\\\" or inversion_type == \\\"single_force_crack_no_coupling\\\":\\n if invert_for_ratio_of_multiple_media_greens_func_switch:\\n if num_phase_types_for_media_ratios>0:\\n # Generate different phase fractions:\\n tmp_frac_medium_1_diff_phases_dict={}\\n tmp_frac_medium_1_diff_phases_dict[\\\"P\\\"] = MTs[-3, np.where(MTp==np.max(MTp))[0][0]]\\n tmp_frac_medium_1_diff_phases_dict[\\\"S\\\"] = MTs[-2, np.where(MTp==np.max(MTp))[0][0]]\\n tmp_frac_medium_1_diff_phases_dict[\\\"surface\\\"] = MTs[-1, np.where(MTp==np.max(MTp))[0][0]]\\n # Create actual greens functions for this solution:\\n green_func_array_for_most_likely_amp_ratio = np.zeros(np.shape(green_func_array[:,:,:,0]), dtype=float)\\n for j in range(len(green_func_phase_labels)):\\n tmp_frac_medium_1 = tmp_frac_medium_1_diff_phases_dict[green_func_phase_labels[j]] # Get fraction for specific phase, for specific greens functions for specific station-phase\\n green_func_array_for_most_likely_amp_ratio[j, :, :] = (1. - tmp_frac_medium_1)*green_func_array[j,:,:,0] + tmp_frac_medium_1*green_func_array[j,:,:,1]\\n # And get result:\\n synth_forward_model_most_likely_result_array = forward_model(green_func_array_for_most_likely_amp_ratio, MTs[:-4, np.where(MTp==np.max(MTp))[0][0]])\\n else:\\n frac_medium_1 = MTs[-1, np.where(MTp==np.max(MTp))[0][0]]\\n green_func_array_for_most_likely_amp_ratio = (1. - frac_medium_1)*green_func_array[:,:,:,0] + frac_medium_1*green_func_array[:,:,:,1]\\n synth_forward_model_most_likely_result_array = forward_model(green_func_array_for_most_likely_amp_ratio, MTs[:-2, np.where(MTp==np.max(MTp))[0][0]])\\n else:\\n synth_forward_model_most_likely_result_array = forward_model(green_func_array, MTs[:-1, np.where(MTp==np.max(MTp))[0][0]])\\n else:\\n if invert_for_ratio_of_multiple_media_greens_func_switch:\\n if num_phase_types_for_media_ratios>0:\\n # Generate different phase fractions:\\n tmp_frac_medium_1_diff_phases_dict={}\\n tmp_frac_medium_1_diff_phases_dict[\\\"P\\\"] = MTs[-3, np.where(MTp==np.max(MTp))[0][0]]\\n tmp_frac_medium_1_diff_phases_dict[\\\"S\\\"] = MTs[-2, np.where(MTp==np.max(MTp))[0][0]]\\n tmp_frac_medium_1_diff_phases_dict[\\\"surface\\\"] = MTs[-1, np.where(MTp==np.max(MTp))[0][0]]\\n # Create actual greens functions for this solution:\\n green_func_array_for_most_likely_amp_ratio = np.zeros(np.shape(green_func_array[:,:,:,0]), dtype=float)\\n for j in range(len(green_func_phase_labels)):\\n tmp_frac_medium_1 = tmp_frac_medium_1_diff_phases_dict[green_func_phase_labels[j]] # Get fraction for specific phase, for specific greens functions for specific station-phase\\n green_func_array_for_most_likely_amp_ratio[j, :, :] = (1. - tmp_frac_medium_1)*green_func_array[j,:,:,0] + tmp_frac_medium_1*green_func_array[j,:,:,1]\\n # And get result:\\n synth_forward_model_most_likely_result_array = forward_model(green_func_array_for_most_likely_amp_ratio, MTs[:-3, np.where(MTp==np.max(MTp))[0][0]])\\n else:\\n frac_medium_1 = MTs[-1, np.where(MTp==np.max(MTp))[0][0]]\\n green_func_array_for_most_likely_amp_ratio = (1. - frac_medium_1)*green_func_array[:,:,:,0] + frac_medium_1*green_func_array[:,:,:,1]\\n synth_forward_model_most_likely_result_array = forward_model(green_func_array_for_most_likely_amp_ratio, MTs[:-1, np.where(MTp==np.max(MTp))[0][0]])\\n else:\\n synth_forward_model_most_likely_result_array = forward_model(green_func_array, MTs[:, np.where(MTp==np.max(MTp))[0][0]])\\n plot_specific_forward_model_result(real_data_array, synth_forward_model_most_likely_result_array, data_labels, plot_title=\\\"Most likely Monte Carlo sampled solution\\\", perform_normallised_waveform_inversion=perform_normallised_waveform_inversion)\\n print(\\\"Most likely solution:\\\", MTs[:,np.where(MTp==np.max(MTp))[0][0]])\\n\\n # And save data to MTFIT style file:\\n save_to_MTFIT_style_file(MTs, MTp, nlloc_hyp_filename, inversion_type, outdir, MTp_absolute=MTp_absolute, shift_idxs=shift_idxs_all_samples) # Saves pickled dictionary containing data from inversion\\n # And save most likely solution and real data waveforms to file:\\n synth_forward_model_most_likely_result_array = get_synth_forward_model_most_likely_result(MTs, MTp, green_func_array, inversion_type, invert_for_ratio_of_multiple_media_greens_func_switch=invert_for_ratio_of_multiple_media_greens_func_switch, green_func_phase_labels=green_func_phase_labels, num_phase_types_for_media_ratios=num_phase_types_for_media_ratios)\\n # And get shift associated with most likely model:\\n if len(shift_idxs_all_samples) > 0:\\n shift_idxs_most_likely_result = np.array(shift_idxs_all_samples)[0, np.where(MTp==np.max(MTp))[0][0]]\\n else:\\n shift_idxs_most_likely_result = []\\n # And save:\\n save_specific_waveforms_to_file(real_data_array, synth_forward_model_most_likely_result_array, data_labels, nlloc_hyp_filename, inversion_type, outdir, shift_idxs=shift_idxs_most_likely_result, normallise_data=perform_normallised_waveform_inversion)\\n \\n print(\\\"Finished\\\")\",\n \"def spectral_check(self, ):\\r\\n a, b = self.dfa, self.dfm.copy()\\r\\n b['ts_a']=a.ts\\r\\n b['flux_a'] = a.flux\\r\\n b['dflux'] = (b.flux-b.flux_a)/b.flux_unc\\r\\n b['eflux100_a'] = a.eflux100\\r\\n b['deflux'] = (b.eflux100-b.eflux100_a)/b.eflux100_unc\\r\\n b['pindex_a'] = a.pindex\\r\\n b['gdelta'] = (b.pindex-b.pindex_a)/b.pindex_unc\\r\\n self.dfm = b # since copy\\r\\n\\r\\n fig,axx = plt.subplots(1,2, figsize=(10,5), sharey=True)\\r\\n hkw = dict(bins=np.linspace(-5,5,51), histtype='step', lw=2, density=True)\\r\\n\\r\\n cut = (b.ts>50) & ~pd.isnull(b.deflux) & ~pd.isnull(b.gdelta) &\\\\\\r\\n (b.modelname==\\\"LogParabola\\\") & (b.pindex<3) & (b.pindex>0.5) &\\\\\\r\\n (b.e0>500) &(b.eflux100_unc>0) &(b.pindex_unc>0)\\r\\n self.check_total = sum(cut)\\r\\n for ax, title, val in zip(axx.flatten(), ['Energy Flux', 'Spectral index'], [b.deflux, b.gdelta]): \\r\\n\\r\\n df=val[cut]\\r\\n ax.hist(df.clip(-5,5), label='mean {:5.2f}\\\\nstd {:5.2f}'.format(df.mean(),df.std()), **hkw);\\r\\n ax.grid(alpha=0.5); \\r\\n x=np.linspace(-4,4)\\r\\n ax.plot(x, stats.norm.pdf(x), '--g' );\\r\\n ax.set(xlabel='normalized fit deviation', title=title, )\\r\\n ax.legend(loc='upper left',prop=dict(family='monospace'))\\r\\n fig.suptitle('Normalized devations of fit from model', fontsize=16);\\r\\n\\r\\n return fig\",\n \"def compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs(self):\\n ref_base_dir = (\\\"/Users/thomasriddick/Documents/data/lake_analysis_runs\\\"\\n \\\"/lake_analysis_one_21_Jun_2021\\\")\\n data_base_dir = (\\\"/Users/thomasriddick/Documents/data/lake_analysis_runs/\\\"\\n \\\"lake_analysis_two_26_Mar_2022\\\")\\n ref_filename=os.path.join(ref_base_dir,\\n \\\"rivers/results/diag_version_29_date_0\\\",\\n \\\"30min_flowtocell.nc\\\")\\n data_filename=os.path.join(data_base_dir,\\n \\\"rivers/results/diag_version_0_date_0\\\",\\n \\\"30min_flowtocell.nc\\\")\\n lsmask_filename=os.path.join(self.plots_data_dir,\\n \\\"ls_mask_extract_ls_mask_from_corrected_HD_rdirs_20160504_142435.nc\\\")\\n ref_catchment_filename=os.path.join(ref_base_dir,\\n \\\"rivers/results/diag_version_29_date_0\\\",\\n \\\"30min_catchments.nc\\\")\\n data_catchment_filename=os.path.join(data_base_dir,\\n \\\"rivers/results/diag_version_0_date_0\\\",\\n \\\"30min_catchments.nc\\\")\\n ref_rdirs_filename=os.path.join(ref_base_dir,\\n \\\"rivers/results/diag_version_29_date_0\\\",\\n \\\"30min_rdirs.nc\\\")\\n reference_rmouth_outflows_filename=os.path.join(ref_base_dir,\\n \\\"rivers/results/diag_version_29_date_0\\\",\\n \\\"30min_flowtorivermouths.nc\\\")\\n data_rmouth_outflows_filename=os.path.join(data_base_dir,\\n \\\"rivers/results/diag_version_0_date_0\\\",\\n \\\"30min_flowtorivermouths.nc\\\")\\n #glacier_mask_filename=os.path.join(self.orog_data_directory,\\\"ice5g_v1_2_21_0k_10min.nc\\\")\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n ref_catchment_filename,\\n data_catchment_filename=\\\\\\n data_catchment_filename,\\n ref_rdirs_filename=\\\\\\n ref_rdirs_filename,\\n data_rdirs_filename=None,\\n reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=80,\\n flip_data=False,\\n rotate_data=False,\\n flip_ref=False,\\n rotate_ref=False,\\n lsmask_has_same_orientation_as_ref=False,\\n flip_lsmask=False,rotate_lsmask=False,\\n invert_ls_mask=False,\\n first_datasource_name=\\\"old\\\",\\n second_datasource_name=\\\"MERIT derived\\\",\\n matching_parameter_set='extensive',\\n catchment_and_outflows_mods_list_filename=\\\\\\n None,\\n #\\\"catch_and_outflow_mods_ice6g_vs_ice5g_lgm.txt\\\",\\n #additional_matches_list_filename=\\\\\\n #\\\"additional_matches_ice6g_vs_ice5g_lgm.txt\\\",\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n use_title=False,remove_antartica=True,\\n difference_in_catchment_label=\\\"Difference\\\",\\n grid_type='HD')\",\n \"def test_lrp_svm(self, syn_genomic_data, syn_fm, syn_idx, rep, tmp_path, syn_true_pvalues): \\n rep_to_plot = 0\\n ttbrs = [0.5, 1,1.5]\\n idx = syn_idx[str(rep_to_plot)]\\n fig, axes = plt.subplots(len(ttbrs), 5, figsize=[30,15])\\n x_3d = syn_fm(\\\"3d\\\")[str(rep_to_plot)][:]\\n x_2d = syn_fm(\\\"2d\\\")[str(rep_to_plot)][:]\\n indices_true= [inds_true for inds_true, x in enumerate(syn_true_pvalues[0].flatten()) if x]\\n\\n for i, ttbr in enumerate(ttbrs):\\n print('Using tbrr={}'.format(ttbr))\\n labels = generate_syn_phenotypes(tower_to_base_ratio=ttbr, quantity=rep)\\n labels_cat = {}\\n for key, l in labels.items():\\n labels_cat[key] = tensorflow.keras.utils.to_categorical((l+1)/2)\\n \\n best_params_montaez['n_snps']= x_3d.shape[1]\\n \\n l_0b=labels_cat[str(rep_to_plot)]\\n\\n model = create_montaez_dense_model(best_params_montaez)\\n y_integers = np.argmax(l_0b[idx.train], axis=1)\\n class_weights = class_weight.compute_class_weight('balanced', np.unique(y_integers), y_integers)\\n d_class_weights = dict(enumerate(class_weights))\\n\\n model.fit(x=x_3d[idx.train], y=l_0b[idx.train], validation_data=(x_3d[idx.test], l_0b[idx.test]), epochs=best_params_montaez['epochs'], class_weight=d_class_weights, callbacks=[ ReduceLROnPlateau(monitor='val_loss', factor=best_params_montaez['factor'], patience=best_params_montaez['patience'], mode='min'),],)\\n\\n model = iutils.keras.graph.model_wo_softmax(model)\\n analyzer = innvestigate.analyzer.LRPAlpha1Beta0(model)\\n weights = analyzer.analyze(x_3d).sum(0)\\n\\n top_indices_sorted, filtered_weights = postprocess_weights(weights, top_k, filter_window_size, p_svm, p_pnorm_filter)\\n\\n complete_pvalues = chi_square(syn_genomic_data[str(rep_to_plot)][:], labels[str(rep_to_plot)])\\n \\n pvalues_filled_deep = np.ones(n_total_snps)\\n pvalues_filled_deep[top_indices_sorted] = complete_pvalues[top_indices_sorted]\\n\\n # Plot RPVT\\n plot_pvalues(complete_pvalues, indices_true, axes[i][0])\\n if i==0:\\n axes[i][0].set_title('RPVT $-log_{10}$(p-values)', fontsize=22)\\n axes[i][0].set_ylabel('$-log_{10}$(p-value)', fontsize=18)\\n plt.setp(axes[i][0].get_yticklabels(), fontsize=16)\\n plt.setp(axes[i][0].get_xticklabels(), fontsize=16)\\n\\n # Plot svm weights \\n clf = LinearSVC(penalty='l2', loss='hinge', C=0.0022, dual=True, tol=1e-3, verbose=0, class_weight='balanced')\\n idx_now, pvalues, raw_weights = combi_method(clf, syn_genomic_data[str(rep_to_plot)][:],x_2d, labels[str(rep_to_plot)], 35, 2, 2, 30)\\n #filtered_svm_weights = postprocess_weights_without_avg(raw_weights, p_svm)\\n pvalues_filled_combi = np.ones(len(complete_pvalues))\\n pvalues_filled_combi[idx_now] = pvalues\\n #svm_weights = toy_classifier.fit(x_2d, labels[str(rep_to_plot)]).coef_\\n axes[i][1].scatter(range(len(np.absolute(raw_weights).sum(1))), 1000*np.absolute(raw_weights).sum(1), marker='.', color='darkblue')\\n axes[i][1].scatter(indices_true,1000*np.absolute(raw_weights).sum(1)[indices_true], color='fuchsia')\\n axes[i][1].set_ylim(0,1000*(np.max(np.absolute(raw_weights).sum(1))+0.001))\\n if i==0:\\n axes[i][1].set_title('Absolute SVM weights * 1000', fontsize=22)\\n plt.setp(axes[i][1].get_yticklabels(), fontsize=16)\\n plt.setp(axes[i][1].get_xticklabels(), fontsize=16)\\n\\t\\t\\t\\n # Plot COMBI\\n plot_pvalues(pvalues_filled_combi, indices_true, axes[i][2])\\n if i==0:\\n axes[i][2].set_title('COMBI $-log_{10}$(p-values)', fontsize=22)\\n if i==2:\\n axes[i][2].set_xlabel('SNP position', fontsize=18)\\n plt.setp(axes[i][2].get_yticklabels(), fontsize=16)\\n plt.setp(axes[i][2].get_xticklabels(), fontsize=16)\\n\\t\\t\\t\\n # Plot LRP relevance scores\\n axes[i][3].scatter(range(len(np.absolute(weights).reshape(-1, 3).sum(1))), np.absolute(weights).reshape(-1, 3).sum(1), marker='.', color='darkblue')\\n axes[i][3].scatter(indices_true,np.absolute(weights).reshape(-1, 3).sum(1)[indices_true], color='fuchsia')\\n #axes[i][1].legend()\\n axes[i][3].set_ylim(0,np.max(np.absolute(weights).reshape(-1, 3).sum(1))+1)\\n if i==0:\\n axes[i][3].set_title('LRP relevance scores', fontsize=22)\\n plt.setp(axes[i][3].get_yticklabels(), fontsize=16)\\n plt.setp(axes[i][3].get_xticklabels(), fontsize=16)\\n\\t\\t\\t\\n # Plot DeepCOMBI\\n plot_pvalues(pvalues_filled_deep, indices_true, axes[i][4])\\n if i==0:\\n axes[i][4].set_title('DeepCOMBI $-log_{10}$(p-value)', fontsize=22)\\n plt.setp(axes[i][4].get_yticklabels(), fontsize=16)\\n plt.setp(axes[i][4].get_xticklabels(), fontsize=16)\\n\\t\\t\\t\\n ## Plot distribution of postprocessed vectors\\n #axes[i][2].plot(postprocessed_weights)\\n #axes[i][2].set_title('Postprocessed relevance')\\n\\n fig.savefig(os.path.join(IMG_DIR, 'manhattan-example-toy-NAR.png'), bbox_inches='tight')\",\n \"def nominalSensitivities():\\n #Scan ranges\\n ang = np.linspace(-5*.3e-3,5*.3e-3,100)\\n tx = np.linspace(-.3,.3,100)\\n\\n #Mirror Pair Sensitivities\\n pitch2 = [mirrorPair(1000,primalign=[0,0,0,0,a,0]) for a in ang]\\n yaw2 = [mirrorPair(1000,primalign=[0,0,0,a,0,0]) for a in ang]\\n plt.figure('Pair')\\n plt.plot(ang*180/pi*60,pitch2,label='Pitch')\\n plt.plot(ang*180/pi*60,yaw2,label='Yaw')\\n plt.title('SLF Mirror Pair Alignment Sensitivities')\\n plt.grid()\\n plt.legend(loc='upper center')\\n plt.xlabel('Angular Error (arcmin)')\\n plt.ylabel('HPD (arcsec)')\\n\\n #Secondary Sensitivities\\n pitch = [mirrorPair(1000,secalign=[0,0,0,0,a,0]) for a in ang/20]\\n yaw = [mirrorPair(1000,secalign=[0,0,0,a,0,0]) for a in ang/20]\\n roll = [mirrorPair(1000,secalign=[0,0,0,0,0,a]) for a in ang/20]\\n plt.figure('SecondaryAng')\\n plt.semilogy(ang/20.*180/pi*60**2,pitch,label='Pitch')\\n plt.plot(ang/20.*180/pi*60**2,yaw,label='Yaw')\\n plt.plot(ang/20.*180/pi*60**2,roll,label='Roll')\\n plt.grid()\\n plt.legend(loc='upper center')\\n plt.xlabel('Angular Error (arcsec)')\\n plt.ylabel('HPD (arcsec)')\\n plt.xlim([-5,5])\\n plt.ylim([0,3])\\n plt.title('SLF Secondary Alignment Sensitivities')\\n decenter = [mirrorPair(1000,secalign=[t,0,0,0,0,0]) for t in tx]\\n lateral = [mirrorPair(1000,secalign=[0,t,0,0,0,0]) for t in tx]\\n despace = [mirrorPair(1000,secalign=[0,0,t,0,0,0]) for t in tx]\\n plt.figure('SecondaryTx')\\n plt.semilogy(tx,decenter,label='Decenter')\\n plt.plot(tx,despace,label='Despace')\\n plt.plot(tx,lateral,label='Lateral')\\n plt.grid()\\n plt.legend(loc='upper center')\\n plt.xlabel('Translation Error (mm)')\\n plt.ylabel('HPD (arcsec)')\\n plt.title('SLF Secondary Translation Sensitivities')\\n \\n \\n #Compensating behavior...\\n \\n\\n return [pitch2,yaw2,pitch,yaw,decenter,lateral,despace]\",\n \"def compare_ICE5G_and_ICE6G_with_catchments_tarasov_style_orog_corrs_for_both(self):\\n ice5g_datetime = \\\"20170615_174943\\\"\\n ice6g_datetime = \\\"20170612_202559\\\"\\n ref_filename=os.path.join(self.plots_data_dir,\\n \\\"flowmap_ICE5G_21k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_tarasov\\\"\\n \\\"_orog_corrs_generation_and_upscaling_{0}_upscaled_updated.nc\\\".\\\\\\n format(ice5g_datetime))\\n data_filename=os.path.join(self.plots_data_dir,\\n \\\"flowmap_ICE6g_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_\\\"\\n \\\"tarasov_orog_corrs_{0}_upscaled_updated.nc\\\".\\\\\\n format(ice6g_datetime))\\n lsmask_filename=os.path.join(self.plots_data_dir,\\n \\\"ls_mask_ICE6g_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs\\\"\\n \\\"_tarasov_orog_corrs_{0}_HD_transf.nc\\\".\\\\\\n format(ice6g_datetime))\\n ref_catchment_filename=(\\\"catchmentmap_ICE5G_21k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_\\\"\\n \\\"tarasov_orog_corrs_generation_and_upscaling_{0}_upscaled_updated.nc\\\".\\\\\\n format(ice5g_datetime))\\n data_catchment_filename=(\\\"catchmentmap_ICE6g_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs\\\"\\n \\\"_tarasov_orog_corrs_{0}_upscaled_updated.nc\\\".\\\\\\n format(ice6g_datetime))\\n ref_rdirs_filename=(\\\"upscaled_rdirs_ICE5G_21k_ALG4_sinkless_no_true_sinks_oceans_lsmask_\\\"\\n \\\"plus_upscale_rdirs_tarasov_orog_corrs_generation_and_upscaling_{0}_upscaled_\\\"\\n \\\"updated.nc\\\".format(ice5g_datetime))\\n reference_rmouth_outflows_filename=os.path.join(self.plots_data_dir,\\n \\\"rmouthflows_ICE5G_21k_ALG4_sinkless_no_true_sinks_oceans_\\\"\\n \\\"lsmask_plus_upscale_rdirs_tarasov_orog_corrs\\\"\\n \\\"_generation_and_upscaling_{0}_upscaled_updated.nc\\\".\\\\\\n format(ice5g_datetime))\\n data_rmouth_outflows_filename=os.path.join(self.plots_data_dir,\\n \\\"rmouthflows_ICE6g_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask_\\\"\\n \\\"plus_upscale_rdirs_tarasov_orog_corrs_{0}_upscaled_updated.nc\\\".\\\\\\n format(ice6g_datetime))\\n #glacier_mask_filename=os.path.join(self.orog_data_directory,\\\"ice5g_v1_2_21_0k_10min.nc\\\")\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n ref_catchment_filename,\\n data_catchment_filename=\\\\\\n data_catchment_filename,\\n ref_rdirs_filename=\\\\\\n ref_rdirs_filename,\\n data_rdirs_filename=None,\\n reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=100,\\n flip_data=False,\\n rotate_data=True,\\n flip_ref=False,\\n rotate_ref=True,\\n lsmask_has_same_orientation_as_ref=False,\\n flip_lsmask=False,rotate_lsmask=False,\\n invert_ls_mask=True,\\n first_datasource_name=\\\"ICE5G\\\",\\n second_datasource_name=\\\"ICE6G\\\",\\n matching_parameter_set='extensive',\\n catchment_and_outflows_mods_list_filename=\\\\\\n \\\"catch_and_outflow_mods_ice6g_vs_ice5g_lgm.txt\\\",\\n #additional_matches_list_filename=\\\\\\n #\\\"additional_matches_ice6g_vs_ice5g_lgm.txt\\\",\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n use_title=False,remove_antartica=True,\\n difference_in_catchment_label=\\\"Difference\\\",\\n rivers_to_plot=[(216,434),(116,426),(111,385),\\n (127,473),(71,641),(123,175),\\n (147,327),(146,554),(194,590),\\n (25,605),(26,691),(69,31),\\n (178,267),(88,455),(67,369),\\n (253,637),(204,609),(270,238),\\n (39,315),(42,252),\\n (16,444),(56,232)],\\n rivers_to_plot_alt_color=[(193,383),(237,392),(170,369),\\n (118,398),(24,591),(114,612),\\n (126,167),(87,111),(88,246),\\n (160,240),(249,255),(91,421),\\n (197,626),(217,598),(135,496),\\n (31,112),(14,263),(54,2)],\\n rivers_to_plot_secondary_alt_color=[(230,428),(171,377),\\n (154,446),(100,467),\\n (142,327),(180,445),\\n (170,578),(117,131),\\n (24,622),(34,8),\\n (75,99),(201,287),\\n (90,433),(250,632),\\n (82,349),(138,536),\\n (29,392),(32,200),\\n (35,104),(261,246),\\n (14,320)],\\n grid_type='HD')\",\n \"def main(folder, quiet=0):\\n\\n if quiet:\\n output_stream = StringIO()\\n else:\\n output_stream = sys.stdout\\n\\n\\n\\n color1 = \\\"I4\\\" #filter system for first color of CMD\\n color2 = \\\"M1\\\" #filter system for second color of CMD\\n zeromagc1 = zero.zero_mag[color1]\\n zeromagc2 = zero.zero_mag[color2]\\n min_mag = 8. #minimal observation limit\\n max_mag = 0. #maximal observation limit\\n\\n#getting file list\\n files = sorted(os.listdir('%s/%s' % (os.getcwdu(), folder))) \\n out = []\\n\\n for fil in files:\\n#only using files created by the automated simulation\\n if fil.startswith('sim_') and not 'settings' in fil.encode(\\\"ascii\\\"):\\n print(\\\"%s/%s\\\" % (folder,fil.encode(\\\"ascii\\\")), file=output_stream)\\n \\n\\n # Read in\\n hdulist = fits.open('%s/%s' %(folder,fil))\\n data = hdulist[1].data\\n\\n #calculating magnitudes from fluxes and converting to CMD-data\\n x = -2.5*(np.log10(data['c%s' % color1]/zeromagc1) - np.log10(data['c%s' % color2]/zeromagc2))\\n y = -2.5*(np.log10(data['c%s' % color2]/zeromagc2))\\n\\n \\n sel = np.logical_and( (y > -10./3. * (x-1.) + 10.), np.logical_and(max_mag < y, y < min_mag))\\n sel = np.logical_and(sel, y < -x + 12.)\\n n = sum(sel)\\n t = Table(hdulist[1].data)\\n if 'sel' in t.columns:\\n t.remove_column('sel')\\n t.add_column(Column(name='sel', data=sel.astype('int')))\\n \\n hdulist[1].data = np.array(t)\\n tmp, av, apera, age = fil.split('_')\\n fits.update('%s/%s' %(folder,fil), np.array(t), ext = 1, clobber=True)\\n out.append([av, apera, age, n])\\n\\n #writing obtained data to \\\"folder/__expected_number\\\"\\n head = ['#', 'AV', 'Aperature_size', 'Age', 'Expected_number']\\n f = open('%s/__expected_number' % folder, 'w')\\n f.write(','.join(head)+'\\\\n' )\\n np.savetxt(f, np.asarray(out).astype(int))\\n f.close()\\n \\n print (\\\"Analysed %s files and saved output to %s\\\" % (len(out),'%s/__expected_number' % folder), file=output_stream)\",\n \"def HD_input_sncosmo_data(self, sn_list):\\n\\n dico = cPickle.load(open(SUGAR_parameter_pkl))\\n self.read_sncosmo(path='../sugar_analysis_data/results/res_salt2_SNF_5_nomodelcov.txt')\\n self.read_meta()\\n self.read_snfit_results()\\n Filtre = np.array([True]*len(self.sncosmo_sn_name))\\n self.zcmb = []\\n self.z_err = []\\n for j, sn_name in enumerate(self.sncosmo_sn_name):\\n# if self.sncosmo_sn_name[j] in dico.keys():\\n#\\n# for i in range (len(self.meta_sn_name_list)):\\n# if self.sncosmo_sn_name[j] == self.meta_sn_name_list[i]:\\n# \\n# self.z_err.append(self.meta_zhl_err[i])\\n# self.zcmb.append(self.meta_zcmb[i])\\n# if np.abs(self.sncosmo_x1[j] - self.x1[i]) > 0.01:\\n# i print 'problem with %s include in sample but big difference between sncosmo and snfit'%(self.sncosmo_sn_name[j])\\n# else:\\n# Filtre[j] = False\\n if sn_name in sn_list:\\n Filtre[j] = True\\n else:\\n Filtre[j] = False\\n\\n for p in dico.keys():\\n if p not in self.sncosmo_sn_name:\\n print p\\n\\n self.sncosmo_x1 = self.sncosmo_x1[Filtre]\\n self.sncosmo_x1_err = self.sncosmo_x1_err[Filtre] \\n self.sncosmo_c = self.sncosmo_c[Filtre]\\n self.sncosmo_c_err = self.sncosmo_c_err[Filtre]\\n self.sncosmo_mb = self.sncosmo_mb[Filtre]\\n self.sncosmo_mb_err = self.sncosmo_mb_err[Filtre]\\n self.sncosmo_cov_x1_c = self.sncosmo_cov_x1_c[Filtre]\\n self.sncosmo_cov_mb_x1 = self.sncosmo_cov_mb_x1[Filtre]\\n self.sncosmo_cov_mb_c = self.sncosmo_cov_mb_c[Filtre]\\n self.sncosmo_z = self.sncosmo_z[Filtre]\\n self.zcmb = np.array(self.zcmb)\\n self.z_err = np.array(self.z_err)\\n\\n self.sncosmo_cov_y = np.zeros((len(self.sncosmo_mb)*3,len(self.sncosmo_mb)*3))\\n \\n for i in range (len(self.sncosmo_mb)):\\n self.sncosmo_cov_y[i*3,i*3] = self.sncosmo_mb_err[i]**2\\n self.sncosmo_cov_y[i*3+ 1,i*3+ 1] = self.sncosmo_x1_err[i]**2\\n \\n self.sncosmo_cov_y[i*3+ 2,i*3+ 2] = self.sncosmo_c_err[i]**2\\n self.sncosmo_cov_y[i*3+ 0,i*3+ 1] = self.sncosmo_cov_mb_x1[i]\\n self.sncosmo_cov_y[i*3+ 1,i*3+ 0] = self.sncosmo_cov_mb_x1[i]\\n self.sncosmo_cov_y[i*3+ 0,i*3+ 2] = self.sncosmo_cov_mb_c[i]\\n self.sncosmo_cov_y[i*3+ 2,i*3+ 0] = self.sncosmo_cov_mb_c[i]\\n self.sncosmo_cov_y[i*3+ 1,i*3+ 2] = self.sncosmo_cov_x1_c[i] \\n self.sncosmo_cov_y[i*3+ 2,i*3+ 1] = self.sncosmo_cov_x1_c[i] \\n \\n self.salt_parm = np.array([self.sncosmo_mb,self.sncosmo_x1,self.sncosmo_c]).T\\n print len(self.salt_parm), len(self.sncosmo_cov_y), len(self.sncosmo_z), len(self.zcmb)\\n return self.salt_parm, self.sncosmo_cov_y, self.sncosmo_z, self.zcmb, self.z_err\",\n \"def visitcomp(plate,mjd,indiv=False,apred='test') :\\n #plt.close('all')\\n load=apload.ApLoad(apred=apred)\\n a=load.apVisitSum(plate,mjd)[1].data\\n\\n #dr14=apload.ApLoad(dr='dr14')\\n p=yanny.yanny(os.environ['PLATELIST_DIR']+'/platePlans.par',np=True)\\n j=np.where(p['PLATEPLANS']['plateid'] == plate)[0][0]\\n locid=p['PLATEPLANS']['locationid'][j]\\n b=fits.open(os.environ['APOGEE_REDUX']+'/r8/fields/apo25m/{:04d}/apVisitSum-{:04d}-{:05d}.fits'.format(\\n locid,plate,mjd))[1].data\\n\\n fig,ax=plots.multi(2,2)\\n i1,i2=match.match(a['FIBERID'],b['FIBERID'])\\n plots.plotc(ax[0,0],a['FIBERID'][i1],a['VHELIO'][i1]-b['VHELIO'][i2],a['RV_TEFF'][i1],zr=[3500,5500],xt='Fiber',yt=r'$\\\\Delta$ VHELIO')\\n plots.plotc(ax[0,1],a['FIBERID'][i1],a['VHELIO'][i1]-b['VHELIO'][i2],a['RV_TEFF'][i1],zr=[3500,5500],yr=[-2.,2.],xt='Fiber',yt=r'$\\\\Delta$ VHELIO')\\n plots.plotc(ax[1,0],a['FIBERID'][i1],a['RV_TEFF'][i1]-b['RV_TEFF'][i2],a['RV_TEFF'][i1],zr=[3500,5500],xt='Fiber',yt=r'$\\\\Delta$ RV_TEFF')\\n plots.plotc(ax[1,1],a['RV_TEFF'][i1]-b['RV_TEFF'][i2],a['VHELIO'][i1]-b['VHELIO'][i2],a['RV_TEFF'][i1],zr=[3500,5500],xt=r'$\\\\Delta$ RV_TEFF',yt=r'$\\\\Delta$ VHELIO')\\n out=load.filename('Plate',chips=True,plate=plate,mjd=mjd)\\n outdir=os.path.dirname(out)\\n outname=os.path.basename(out).replace('-a','').replace('.fits','_dr14comp.png')\\n fig.tight_layout()\\n pdb.set_trace()\\n print(outdir+'/plots/'+outname)\\n fig.savefig(outdir+'/plots/'+outname)\\n\\n if indiv :\\n va=load.apPlate(plate,mjd)\\n vb={}\\n for chip in chips :\\n tmp=fits.open(os.environ['APOGEE_REDUX']+'/r8/apo25m/{:04d}/{:05d}/apPlate-{:s}-{:04d}-{:05d}.fits'.format(\\n plate,mjd,chip,plate,mjd))\\n vb[chip] = tmp\\n\\n fig,ax=plots.multi(1,3,hspace=0.3) \\n pfig,pax=plots.multi(1,3,hspace=0.3) \\n wfig,wax=plots.multi(1,3,hspace=0.3) \\n for i in range(len(i1)) :\\n fiber = a['FIBERID'][i1[i]]\\n if (a['VHELIO'][i1[i]]-b['VHELIO'][i2[i]]) > 0.5 :\\n print(fiber,a['VHELIO'][i1[i]],b['VHELIO'][i2[i]],a['RV_TEFF'][i1[i]],b['RV_TEFF'][i2[i]])\\n applot.chip(va,ax=ax,row=300-fiber,color='r')\\n #applot.chip(va,ax=pax,row=300-fiber,color='r',pixel=True)\\n applot.chip(vb,ax=ax,row=300-fiber,color='b')\\n #applot.chip(vb,ax=pax,row=300-fiber,color='b',pixel=True)\\n for ichip,chip in enumerate(chips) :\\n pax[ichip].plot(va[chip][1].data[300-fiber,:]/vb[chip][1].data[300-fiber,:])\\n wax[ichip].plot(va[chip][4].data[300-fiber,:]-vb[chip][4].data[300-fiber,:])\\n plt.show()\\n\\n pdb.set_trace()\\n for ichip in range(3) :\\n ax[ichip].cla()\\n pax[ichip].cla()\\n wax[ichip].cla()\\n plt.close()\",\n \"def main():\\n Nrep = 8 # number of repetition of EM steps\\n nm = 3 # number of mixed gaussians.\\n ns = 300 # number of samples.\\n \\n mu, sg, lm, lm_ind, smp, L_true = generate_synthetic_data(nm, ns)\\n plt.figure(1, figsize=(5,4))\\n plt.clf()\\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\\n \\n mue, sge, lme = generate_initial_state(nm, ns)\\n axi = 0 # subplot number\\n plt.figure(2, figsize=(12,9))\\n plt.clf()\\n for rep in range(Nrep):\\n # E-step\\n r, L_infer = e_step(smp, mue, sge, lme, nm, ns)\\n axi += 1 \\n ax = plt.subplot(Nrep/2, 6, axi)\\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\\n ax.set_title('E-step : %d' % (rep + 1))\\n ax.set_yticklabels([])\\n ax.set_xticklabels([])\\n ax.set_ylim((-0.1, 0.3))\\n\\n # M-step\\n mue, sge, lme = m_step(smp, r, nm, ns)\\n axi += 1 \\n ax = plt.subplot(Nrep/2, 6, axi)\\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\\n ax.set_title('M-step : %d' % (rep + 1))\\n ax.set_yticklabels([])\\n ax.set_xticklabels([])\\n ax.set_ylim((-0.1, 0.3))\\n\\n # plot the ground truth for comparison\\n axi += 1 \\n ax = plt.subplot(Nrep/2, 6, axi)\\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\\n ax.set_title('grn_truth')\\n ax.set_yticklabels([])\\n ax.set_xticklabels([])\\n ax.set_ylim((-0.1, 0.3))\\n\\n print('L_infer = %2.6f , L_true = %2.6f' % (L_infer, L_true))\",\n \"def compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_new_ts_10min(self):\\n ref_base_dir = (\\\"/Users/thomasriddick/Documents/data/lake_analysis_runs/\\\"\\n \\\"lake_analysis_one_21_Jun_2021/rivers/results/\\\"\\n \\\"default_orog_corrs/\\\"\\n \\\"diag_version_29_date_0_original_truesinks\\\")\\n data_base_dir = (\\\"/Users/thomasriddick/Documents/data/lake_analysis_runs/\\\"\\n \\\"lake_analysis_two_26_Mar_2022/\\\"\\n \\\"rivers/results/diag_version_32_date_0_with_truesinks\\\")\\n ref_filename=os.path.join(ref_base_dir,\\\"10min_flowtocell.nc\\\")\\n data_filename=os.path.join(data_base_dir,\\\"10min_flowtocell.nc\\\")\\n #lsmask_filename=os.path.join(self.plots_data_dir,\\n # \\\"ls_mask_extract_ls_mask_from_corrected_HD_rdirs_20160504_142435.nc\\\")\\n lsmask_filename=None\\n ref_catchment_filename=os.path.join(ref_base_dir,\\n \\\"10min_catchments_ext.nc\\\")\\n data_catchment_filename=os.path.join(data_base_dir,\\n \\\"10min_catchments_ext.nc\\\")\\n ref_rdirs_filename=os.path.join(ref_base_dir,\\n \\\"10min_rdirs.nc\\\")\\n data_rdirs_filename=os.path.join(data_base_dir,\\n \\\"10min_rdirs.nc\\\")\\n reference_rmouth_outflows_filename=os.path.join(ref_base_dir,\\n \\\"10min_rmouth_flowtocell.nc\\\")\\n data_rmouth_outflows_filename=os.path.join(data_base_dir,\\n \\\"10min_rmouth_flowtocell.nc\\\")\\n #glacier_mask_filename=os.path.join(self.orog_data_directory,\\\"ice5g_v1_2_21_0k_10min.nc\\\")\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n ref_catchment_filename,\\n data_catchment_filename=\\\\\\n data_catchment_filename,\\n ref_rdirs_filename=\\\\\\n ref_rdirs_filename,\\n data_rdirs_filename=None,\\n reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=80*9/3,\\n flip_data=False,\\n rotate_data=False,\\n flip_ref=False,\\n rotate_ref=False,\\n lsmask_has_same_orientation_as_ref=False,\\n flip_lsmask=False,rotate_lsmask=False,\\n invert_ls_mask=False,\\n first_datasource_name=\\\"old\\\",\\n second_datasource_name=\\\"MERIT derived\\\",\\n matching_parameter_set='minimal',\\n additional_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/additional_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day_ext.txt\\\",\\n additional_truesink_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/addmatches_truesinks/\\\"\\n \\\"additional_truesinks_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day.txt\\\",\\n catchment_and_outflows_mods_list_filename=\\\\\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\\\",\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n use_title=False,remove_antartica=False,\\n difference_in_catchment_label=\\\"Difference\\\",\\n grid_type='LatLong10min')\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n ref_catchment_filename,\\n data_catchment_filename=\\\\\\n data_catchment_filename,\\n ref_rdirs_filename=\\\\\\n ref_rdirs_filename,\\n data_rdirs_filename=None,\\n reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=20*9/3,\\n flip_data=False,\\n rotate_data=False,\\n flip_ref=False,\\n rotate_ref=False,\\n lsmask_has_same_orientation_as_ref=False,\\n flip_lsmask=False,rotate_lsmask=False,\\n invert_ls_mask=False,\\n first_datasource_name=\\\"old\\\",\\n second_datasource_name=\\\"MERIT derived\\\",\\n matching_parameter_set='minimal',\\n additional_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/additional_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day_ext.txt\\\",\\n additional_truesink_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/addmatches_truesinks/\\\"\\n \\\"additional_truesinks_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day.txt\\\",\\n catchment_and_outflows_mods_list_filename=\\\\\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\\\",\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n use_title=False,remove_antartica=False,\\n difference_in_catchment_label=\\\"Difference\\\",\\n grid_type='LatLong10min')\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n ref_catchment_filename,\\n data_catchment_filename=\\\\\\n data_catchment_filename,\\n ref_rdirs_filename=\\\\\\n ref_rdirs_filename,\\n data_rdirs_filename=\\\\\\n data_rdirs_filename,\\n reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=20*9/3,\\n flip_data=False,\\n rotate_data=False,\\n flip_ref=False,\\n rotate_ref=False,\\n lsmask_has_same_orientation_as_ref=False,\\n flip_lsmask=False,rotate_lsmask=False,\\n invert_ls_mask=False,\\n first_datasource_name=\\\"old\\\",\\n second_datasource_name=\\\"MERIT derived\\\",\\n matching_parameter_set='minimal',\\n additional_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/additional_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day_ext.txt\\\",\\n additional_truesink_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/addmatches_truesinks/\\\"\\n \\\"additional_truesinks_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day.txt\\\",\\n catchment_and_outflows_mods_list_filename=\\\\\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\\\",\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n use_title=False,remove_antartica=False,\\n show_true_sinks=True,\\n difference_in_catchment_label=\\\"Difference\\\",\\n grid_type='LatLong10min')\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n ref_catchment_filename,\\n data_catchment_filename=\\\\\\n data_catchment_filename,\\n ref_rdirs_filename=\\\\\\n ref_rdirs_filename,\\n data_rdirs_filename=\\\\\\n None,\\n reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=5*9/3,\\n flip_data=False,\\n rotate_data=False,\\n flip_ref=False,\\n rotate_ref=False,\\n lsmask_has_same_orientation_as_ref=False,\\n flip_lsmask=False,rotate_lsmask=False,\\n invert_ls_mask=False,\\n first_datasource_name=\\\"old\\\",\\n second_datasource_name=\\\"MERIT derived\\\",\\n matching_parameter_set='minimal',\\n additional_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/additional_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day_ext.txt\\\",\\n additional_truesink_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/addmatches_truesinks/\\\"\\n \\\"additional_truesinks_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day.txt\\\",\\n catchment_and_outflows_mods_list_filename=\\\\\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\\\",\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n use_title=False,remove_antartica=False,\\n show_true_sinks=False,\\n difference_in_catchment_label=\\\"Difference\\\",\\n grid_type='LatLong10min')\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n ref_catchment_filename,\\n data_catchment_filename=\\\\\\n data_catchment_filename,\\n ref_rdirs_filename=\\\\\\n ref_rdirs_filename,\\n data_rdirs_filename=\\\\\\n data_rdirs_filename,\\n reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=5*9/3,\\n flip_data=False,\\n rotate_data=False,\\n flip_ref=False,\\n rotate_ref=False,\\n lsmask_has_same_orientation_as_ref=False,\\n flip_lsmask=False,rotate_lsmask=False,\\n invert_ls_mask=False,\\n first_datasource_name=\\\"old\\\",\\n second_datasource_name=\\\"MERIT derived\\\",\\n matching_parameter_set='minimal',\\n additional_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/additional_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day_ext.txt\\\",\\n additional_truesink_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/addmatches_truesinks/\\\"\\n \\\"additional_truesinks_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day.txt\\\",\\n catchment_and_outflows_mods_list_filename=\\\\\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\\\",\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n use_title=False,remove_antartica=False,\\n show_true_sinks=True,\\n difference_in_catchment_label=\\\"Difference\\\",\\n grid_type='LatLong10min')\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n ref_catchment_filename,\\n data_catchment_filename=\\\\\\n data_catchment_filename,\\n ref_rdirs_filename=\\\\\\n ref_rdirs_filename,\\n data_rdirs_filename=\\\\\\n data_rdirs_filename,\\n reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=2*9/3,\\n flip_data=False,\\n rotate_data=False,\\n flip_ref=False,\\n rotate_ref=False,\\n lsmask_has_same_orientation_as_ref=False,\\n flip_lsmask=False,rotate_lsmask=False,\\n invert_ls_mask=False,\\n first_datasource_name=\\\"old\\\",\\n second_datasource_name=\\\"MERIT derived\\\",\\n matching_parameter_set='minimal',\\n additional_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/additional_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day_ext.txt\\\",\\n additional_truesink_matches_list_filename=\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"addmatches/addmatches_truesinks/\\\"\\n \\\"additional_truesinks_matches_10min_upscaled_\\\"\\n \\\"MERIT_rdirs_vs_modern_day.txt\\\",\\n catchment_and_outflows_mods_list_filename=\\\\\\n \\\"/Users/thomasriddick/Documents/data/HDdata/\\\"\\n \\\"catchmods/catch_and_outflow_mods_10min_upscaled_MERIT_rdirs_vs_modern_day.txt\\\",\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n use_title=False,remove_antartica=False,\\n show_true_sinks=True,\\n difference_in_catchment_label=\\\"Difference\\\",\\n grid_type='LatLong10min')\",\n \"def comparison():\\n path = \\\"Data/data_fronts/\\\"\\n path1 = \\\"Results/labelled_images1010/fronts/\\\"\\n\\n #computes the areas for the first frame in order to normalize the other areas\\n pol0 = pd.DataFrame(pd.read_csv(path1 + \\\"fronts_labelled.m.0.png.txt\\\",sep =' '))\\n #makes an object polygon in order to compute the area\\n pol0 = np.array(pol0)\\n pol0 = Polygon(pol0)\\n\\n polsx = pd.DataFrame(pd.read_csv(path + \\\"Sham_8-2-18_Field 5_1_sx.txt\\\",sep ='\\\\t'))\\n polsx.columns = [\\\"y\\\",\\\"x\\\"]\\n poldx = pd.DataFrame(pd.read_csv(path + \\\"Sham_8-2-18_Field 5_1_dx.txt\\\",sep ='\\\\t'))\\n poldx.columns = [\\\"y\\\",\\\"x\\\"]\\n #makes an object polygon in order to compute the area\\n polsx = polsx.append(poldx)\\n polsx = np.array(polsx)\\n pol1 = Polygon(polsx)\\n\\n\\n areas = []\\n areas_hand = []\\n #computes the areas for all the frames\\n for i in range(42):\\n pol = pd.DataFrame(pd.read_csv(path1 + \\\"fronts_labelled.m.\\\"+str(i)+\\\".png.txt\\\",sep =' '))\\n pol = np.array(pol)\\n pol = Polygon(pol)\\n #normalize the areas with respect to the area of the first frame\\n areas.append(pol.area/pol0.area)\\n\\n polsx = pd.DataFrame(pd.read_csv(path + \\\"Sham_8-2-18_Field 5_\\\"+str(i+1)+\\\"_sx.txt\\\",sep ='\\\\t'))\\n polsx.columns = [\\\"y\\\",\\\"x\\\"]\\n poldx = pd.DataFrame(pd.read_csv(path + \\\"Sham_8-2-18_Field 5_\\\"+str(i+1)+\\\"_dx.txt\\\",sep ='\\\\t'))\\n poldx.columns = [\\\"y\\\",\\\"x\\\"]\\n if poldx[\\\"x\\\"][0]>100:\\n poldx = poldx.reindex(index=poldx.index[::-1])\\n if polsx[\\\"x\\\"][0]<100:\\n polsx = polsx.reindex(index=polsx.index[::-1])\\n polsx = polsx.append(poldx)\\n polsx = np.array(polsx)\\n\\n pol2 = Polygon(polsx)\\n #normalize the areas with respect to the area of the first frame\\n areas_hand.append(pol2.area/pol1.area)\\n #returns the two arrays with the normalized areas\\n return np.array(areas) , np.array(areas_hand)\",\n \"def OutFlowComparisonPlotHelpers(self,reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename,\\n ref_flowmaps_filename,data_flowmaps_filename,\\n rdirs_filename,flip_data_field=False,rotate_data_field=False,\\n flip_ref_field=False,rotate_ref_field=False,\\n ref_catchment_filename=None,data_catchment_filename=None,\\n data_catchment_original_scale_filename=None,\\n data_rdirs_filename=None,\\n data_original_scale_flow_map_filename=None,\\n ref_orog_filename=None,\\n data_orog_original_scale_filename=None,\\n flip_orog_original_scale_relative_to_data=False,\\n super_fine_orog_filename=None,\\n super_fine_data_flowmap_filename=None,\\n flip_super_fine_orog=False,\\n rotate_super_fine_orog=False,\\n additional_matches_list_filename=None,\\n catchment_and_outflows_mods_list_filename=None,\\n plot_simple_catchment_and_flowmap_plots=False,\\n return_simple_catchment_and_flowmap_plotters=False,\\n return_catchment_plotters=False,\\n swap_ref_and_data_when_finding_labels=False,\\n rivers_to_plot=None,\\n alternative_catchment_bounds=None,\\n matching_parameter_set='default',\\n split_comparison_plots_across_multiple_canvases=False,\\n use_simplified_catchment_colorscheme=False,\\n use_simplified_flowmap_colorscheme=False,\\n use_upscaling_labels=False,\\n select_only_rivers_in=None,\\n allow_new_true_sinks=False,\\n ref_original_scale_flow_map_filename=None,\\n ref_catchment_original_scale_filename=None,\\n use_original_scale_field_for_determining_data_and_ref_labels=False,\\n external_ls_mask_filename=None,\\n flip_external_ls_mask=False,\\n rotate_external_ls_mask=False,\\n ref_original_scale_grid_type='HD',\\n grid_type='HD',data_original_scale_grid_type='HD',\\n super_fine_orog_grid_type='HD',\\n no_data_path_prefixes=False,\\n data_original_scale_grid_kwargs={},\\n ref_original_scale_grid_kwargs={},\\n super_fine_orog_grid_kwargs={},\\n **grid_kwargs):\\n ref_flowmaps_filepath = os.path.join(self.plots_data_dir,ref_flowmaps_filename)\\n data_flowmaps_filepath = os.path.join(self.plots_data_dir,data_flowmaps_filename)\\n rdirs_filepath = os.path.join(self.plots_data_dir,rdirs_filename)\\n if ref_catchment_filename:\\n ref_catchments_filepath = os.path.join(self.plots_data_dir,\\n ref_catchment_filename)\\n if data_catchment_filename:\\n if no_data_path_prefixes:\\n data_catchment_filepath = data_catchment_filename\\n else:\\n data_catchment_filepath = os.path.join(self.plots_data_dir,\\n data_catchment_filename)\\n if data_rdirs_filename:\\n if no_data_path_prefixes:\\n data_rdirs_filepath = data_rdirs_filename\\n else:\\n data_rdirs_filepath = os.path.join(self.plots_data_dir,\\n data_rdirs_filename)\\n if ref_orog_filename:\\n ref_orog_filepath = os.path.join(self.orog_data_directory,\\n ref_orog_filename)\\n if data_orog_original_scale_filename:\\n if no_data_path_prefixes:\\n data_orog_original_scale_filepath = data_orog_original_scale_filename\\n else:\\n data_orog_original_scale_filepath = os.path.join(self.orog_data_directory,\\n data_orog_original_scale_filename)\\n if data_catchment_original_scale_filename:\\n if no_data_path_prefixes:\\n data_catchment_original_scale_filepath = data_catchment_original_scale_filename\\n else:\\n data_catchment_original_scale_filepath = os.path.join(self.plots_data_dir,\\n data_catchment_original_scale_filename)\\n if ref_catchment_original_scale_filename:\\n ref_catchment_original_scale_filepath = os.path.join(self.plots_data_dir,\\n ref_catchment_original_scale_filename)\\n if catchment_and_outflows_mods_list_filename:\\n catchment_and_outflows_mods_list_filepath = os.path.join(self.catchment_and_outflows_mods_list_directory,\\n catchment_and_outflows_mods_list_filename)\\n if additional_matches_list_filename:\\n additional_matches_list_filepath = os.path.join(self.additional_matches_list_directory,\\n additional_matches_list_filename)\\n if external_ls_mask_filename:\\n external_ls_mask_filepath = os.path.join(self.plots_data_dir,\\n external_ls_mask_filename)\\n if super_fine_orog_filename:\\n super_fine_orog_filepath = os.path.join(self.orog_data_directory,\\n super_fine_orog_filename)\\n if super_fine_data_flowmap_filename:\\n super_fine_data_flowmap_filepath = os.path.join(self.plots_data_dir,\\n super_fine_data_flowmap_filename)\\n if ref_catchment_filename:\\n ref_catchment_field = iohlpr.NetCDF4FileIOHelper.load_field(ref_catchments_filepath,\\n grid_type,**grid_kwargs)\\n if data_catchment_filename:\\n data_catchment_field =\\\\\\n iohlpr.NetCDF4FileIOHelper.load_field(data_catchment_filepath,\\n grid_type,**grid_kwargs)\\n if grid_type == data_original_scale_grid_type and grid_kwargs == data_original_scale_grid_kwargs:\\n catchment_grid_changed = False\\n data_catchment_field_original_scale = data_catchment_field\\n else:\\n catchment_grid_changed = True\\n if data_catchment_original_scale_filepath is None:\\n raise RuntimeError('require original scale catchment to use upscaled catchments')\\n data_catchment_field_original_scale =\\\\\\n iohlpr.NetCDF4FileIOHelper.load_field(data_catchment_original_scale_filepath,\\n grid_type=data_original_scale_grid_type,\\n **data_original_scale_grid_kwargs)\\n if data_original_scale_flow_map_filename is None:\\n raise RuntimeError('require original flow to cell data to use upscaled catchments')\\n else:\\n data_original_scale_flow_map_filepath = os.path.join(self.plots_data_dir,\\n data_original_scale_flow_map_filename)\\n data_original_scale_flowtocellfield = iohlpr.NetCDF4FileIOHelper.\\\\\\n load_field(data_original_scale_flow_map_filepath,grid_type=data_original_scale_grid_type,\\n **data_original_scale_grid_kwargs)\\n if use_original_scale_field_for_determining_data_and_ref_labels:\\n if ref_original_scale_flow_map_filename is None:\\n raise RuntimeError('require original flow to cell field to use upscaled catchments for ref')\\n elif ref_catchment_original_scale_filename is None:\\n raise RuntimeError('require original scale catchment to use upscaled catchments for ref')\\n else:\\n ref_original_scale_flow_map_filepath = os.path.join(self.plots_data_dir,\\n ref_original_scale_flow_map_filename)\\n ref_original_scale_flowtocellfield = iohlpr.NetCDF4FileIOHelper.\\\\\\n load_field(ref_original_scale_flow_map_filepath,grid_type=data_original_scale_grid_type,\\n **data_original_scale_grid_kwargs)\\n ref_catchment_field_original_scale =\\\\\\n iohlpr.NetCDF4FileIOHelper.load_field(ref_catchment_original_scale_filepath,\\n grid_type=ref_original_scale_grid_type,\\n **ref_original_scale_grid_kwargs)\\n else:\\n ref_original_scale_flowtocellfield = None\\n ref_catchment_field_original_scale = None\\n ref_flowtocellfield = iohlpr.NetCDF4FileIOHelper.load_field(ref_flowmaps_filepath,grid_type,**grid_kwargs)\\n data_flowtocellfield = iohlpr.NetCDF4FileIOHelper.load_field(data_flowmaps_filepath,grid_type,**grid_kwargs)\\n rdirs_field = iohlpr.NetCDF4FileIOHelper.load_field(rdirs_filepath,grid_type,**grid_kwargs)\\n ref_grid = grid.makeGrid(grid_type,**grid_kwargs)\\n if data_rdirs_filename:\\n if catchment_grid_changed:\\n data_rdirs_field = iohlpr.NetCDF4FileIOHelper.load_field(data_rdirs_filepath,\\n grid_type=data_original_scale_grid_type,\\n **data_original_scale_grid_kwargs)\\n data_rdirs_field = utilities.upscale_field(input_field=field.\\\\\\n Field(data_rdirs_field,\\n grid=data_original_scale_grid_type,\\n **data_original_scale_grid_kwargs),\\n output_grid_type=grid_type,\\n method='CheckValue',\\n output_grid_kwargs=grid_kwargs,\\n scalenumbers=False).get_data()\\n else:\\n data_rdirs_field = iohlpr.NetCDF4FileIOHelper.load_field(data_rdirs_filepath,grid_type,\\n **grid_kwargs)\\n else:\\n data_rdirs_field = None\\n if ref_orog_filename:\\n ref_orog_field = iohlpr.NetCDF4FileIOHelper.load_field(ref_orog_filepath,grid_type,\\n **grid_kwargs)\\n ref_orog_field = np.ma.array(ref_orog_field)\\n\\n if data_orog_original_scale_filename:\\n data_orog_original_scale_field = iohlpr.NetCDF4FileIOHelper.\\\\\\n load_field(data_orog_original_scale_filepath,\\n grid_type=data_original_scale_grid_type,\\n **data_original_scale_grid_kwargs)\\n fine_grid = grid.makeGrid(data_original_scale_grid_type,\\n **data_original_scale_grid_kwargs)\\n if flip_orog_original_scale_relative_to_data:\\n #This is an extra flip along with the flip applied below\\n data_orog_original_scale_field = np.flipud(data_orog_original_scale_field)\\n else:\\n fine_grid = ref_grid\\n if super_fine_orog_filename:\\n super_fine_orog_field = iohlpr.NetCDF4FileIOHelper.\\\\\\n load_field(super_fine_orog_filepath,\\n grid_type=super_fine_orog_grid_type,\\n **super_fine_orog_grid_kwargs)\\n super_fine_grid = grid.makeGrid(super_fine_orog_grid_type,\\n **super_fine_orog_grid_kwargs)\\n if super_fine_data_flowmap_filename:\\n super_fine_data_flowmap = iohlpr.NetCDF4FileIOHelper.\\\\\\n load_field(super_fine_data_flowmap_filepath,\\n grid_type=super_fine_orog_grid_type,\\n **super_fine_orog_grid_kwargs)\\n else:\\n super_fine_data_flowmap = None\\n if flip_super_fine_orog:\\n super_fine_orog_field = np.flipud(super_fine_orog_field)\\n if super_fine_data_flowmap is not None:\\n super_fine_data_flowmap = np.flipud(super_fine_data_flowmap)\\n if rotate_super_fine_orog:\\n super_fine_orog_field = np.roll(super_fine_orog_field,\\n np.size(super_fine_orog_field,\\n axis=1)//2,\\n axis=1)\\n if super_fine_data_flowmap is not None:\\n super_fine_data_flowmap = np.roll(super_fine_data_flowmap,\\n np.size(super_fine_data_flowmap,\\n axis=1)//2,\\n axis=1)\\n else:\\n super_fine_orog_field = None\\n super_fine_data_flowmap = None\\n super_fine_grid = ref_grid\\n if external_ls_mask_filename:\\n external_ls_mask = iohlpr.NetCDF4FileIOHelper.\\\\\\n load_field(external_ls_mask_filepath,\\n grid_type=grid_type,\\n **grid_kwargs)\\n else:\\n external_ls_mask = None\\n if flip_ref_field:\\n ref_flowtocellfield = np.flipud(ref_flowtocellfield)\\n rdirs_field = np.flipud(rdirs_field)\\n if ref_catchment_filename:\\n ref_catchment_field = np.flipud(ref_catchment_field)\\n if use_original_scale_field_for_determining_data_and_ref_labels:\\n ref_original_scale_flowtocellfield = np.flipud(ref_original_scale_flowtocellfield)\\n ref_catchment_field_original_scale = np.flipud(ref_catchment_field_original_scale)\\n if flip_data_field:\\n data_flowtocellfield = np.flipud(data_flowtocellfield)\\n if data_rdirs_filename:\\n data_rdirs_field = np.flipud(data_rdirs_field)\\n if data_catchment_filename:\\n data_catchment_field = np.flipud(data_catchment_field)\\n if catchment_grid_changed:\\n data_original_scale_flowtocellfield = np.flipud(data_original_scale_flowtocellfield)\\n data_catchment_field_original_scale = np.flipud(data_catchment_field_original_scale)\\n if data_orog_original_scale_filename:\\n data_orog_original_scale_field = np.flipud(data_orog_original_scale_field)\\n if rotate_ref_field:\\n ref_flowtocellfield = np.roll(ref_flowtocellfield,\\n np.size(ref_flowtocellfield,axis=1)//2,\\n axis=1)\\n rdirs_field = np.roll(rdirs_field,\\n np.size(rdirs_field,axis=1)//2,\\n axis=1)\\n if ref_catchment_filename:\\n ref_catchment_field = np.roll(ref_catchment_field,\\n np.size(ref_catchment_field,axis=1)//2,\\n axis=1)\\n if use_original_scale_field_for_determining_data_and_ref_labels:\\n ref_original_scale_flowtocellfield = np.roll(ref_original_scale_flowtocellfield,\\n np.size(ref_original_scale_flowtocellfield,\\n axis=1)//2,\\n axis=1)\\n ref_catchment_field_original_scale = np.roll(ref_catchment_field_original_scale,\\n np.size(ref_catchment_field_original_scale,\\n axis=1)//2,\\n axis=1)\\n if rotate_data_field:\\n data_flowtocellfield = np.roll(data_flowtocellfield,\\n np.size(data_flowtocellfield,axis=1)//2,\\n axis=1)\\n if data_rdirs_filename:\\n data_rdirs_field = np.roll(data_rdirs_field,\\n np.size(data_rdirs_field,axis=1)//2,\\n axis=1)\\n if data_catchment_filename:\\n data_catchment_field = np.roll(data_catchment_field,\\n np.size(data_catchment_field,axis=1)//2,\\n axis=1)\\n if catchment_grid_changed:\\n data_original_scale_flowtocellfield = np.roll(data_original_scale_flowtocellfield,\\n np.size(data_original_scale_flowtocellfield,\\n axis=1)//2,\\n axis=1)\\n data_catchment_field_original_scale = np.roll(data_catchment_field_original_scale,\\n np.size(data_catchment_field_original_scale,\\n axis=1)//2,\\n axis=1)\\n if data_orog_original_scale_filename:\\n data_orog_original_scale_field = np.roll(data_orog_original_scale_field,\\n np.size(data_orog_original_scale_field,\\n axis=1)//2,\\n axis=1)\\n else:\\n data_orog_original_scale_field = None\\n if flip_external_ls_mask:\\n external_ls_mask = np.flipud(external_ls_mask)\\n if rotate_external_ls_mask:\\n external_ls_mask = np.roll(external_ls_mask,\\n np.size(external_ls_mask,\\n axis=1)//2,\\n axis=1)\\n temp_file_list = []\\n if catchment_and_outflows_mods_list_filename:\\n ref_outflow_field = iodriver.load_field(reference_rmouth_outflows_filename,\\n file_type=iodriver.\\\\\\n get_file_extension(reference_rmouth_outflows_filename),\\n field_type='Generic', grid_type=grid_type,**grid_kwargs)\\n data_outflow_field = iodriver.load_field(data_rmouth_outflows_filename,\\n file_type=iodriver.\\\\\\n get_file_extension(data_rmouth_outflows_filename),\\n field_type='Generic', grid_type=grid_type,**grid_kwargs)\\n if flip_ref_field:\\n ref_outflow_field.flip_data_ud()\\n if rotate_ref_field:\\n ref_outflow_field.rotate_field_by_a_hundred_and_eighty_degrees()\\n if flip_data_field:\\n data_outflow_field.flip_data_ud()\\n if rotate_data_field:\\n data_outflow_field.rotate_field_by_a_hundred_and_eighty_degrees()\\n ref_catchment_field, ref_outflow_field, data_catchment_field, data_outflow_field =\\\\\\n rc_pts.modify_catchments_and_outflows(ref_catchments=ref_catchment_field,\\n ref_outflows=ref_outflow_field,\\n ref_flowmap=ref_flowtocellfield,\\n ref_rdirs = rdirs_field,\\n data_catchments=data_catchment_field,\\n data_outflows=data_outflow_field,\\n catchment_and_outflows_modifications_list_filename=\\\\\\n catchment_and_outflows_mods_list_filepath,\\n original_scale_catchment=\\\\\\n data_catchment_field_original_scale.get_data(),\\n original_scale_flowmap=\\\\\\n data_original_scale_flowtocellfield.get_data(),\\n catchment_grid_changed=catchment_grid_changed,\\n swap_ref_and_data_when_finding_labels=\\\\\\n swap_ref_and_data_when_finding_labels,\\n original_scale_grid_type=\\\\\\n data_original_scale_grid_type,\\n original_scale_grid_kwargs=\\\\\\n data_original_scale_grid_kwargs,\\n grid_type=grid_type,**grid_kwargs)\\n if flip_data_field:\\n data_outflow_field.flip_data_ud()\\n if rotate_data_field:\\n data_outflow_field.rotate_field_by_a_hundred_and_eighty_degrees()\\n if flip_ref_field:\\n ref_outflow_field.flip_data_ud()\\n if rotate_ref_field:\\n ref_outflow_field.rotate_field_by_a_hundred_and_eighty_degrees()\\n reference_rmouth_outflows_filename=os.path.join(self.scratch_dir,\\n self.temp_label + os.path.\\\\\\n basename(reference_rmouth_outflows_filename))\\n data_rmouth_outflows_filename=os.path.join(self.scratch_dir,\\n self.temp_label + os.path.\\\\\\n basename(reference_rmouth_outflows_filename))\\n temp_file_list.append(reference_rmouth_outflows_filename)\\n temp_file_list.append(data_rmouth_outflows_filename)\\n iodriver.write_field(reference_rmouth_outflows_filename,\\n field=ref_outflow_field,\\n file_type=iodriver.\\\\\\n get_file_extension(reference_rmouth_outflows_filename))\\n iodriver.write_field(data_rmouth_outflows_filename,\\n field=data_outflow_field,\\n file_type=iodriver.\\\\\\n get_file_extension(data_rmouth_outflows_filename))\\n matchedpairs, unresolved_conflicts = mtch_rm.main(reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n grid_type=grid_type,\\n flip_data_field=flip_data_field,\\n rotate_data_field=rotate_data_field,\\n flip_ref_field=flip_ref_field,\\n rotate_ref_field=rotate_ref_field,\\n param_set=matching_parameter_set,\\n **grid_kwargs)\\n if additional_matches_list_filename:\\n additional_matches = mtch_rm.load_additional_manual_matches(additional_matches_list_filepath,\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename,\\n flip_data_field=flip_data_field,\\n rotate_data_field=rotate_data_field,\\n grid_type='HD',**grid_kwargs)\\n matchedpairs.extend(additional_matches)\\n if ref_orog_filename:\\n ref_orog_field[rdirs_field <= 0] = np.ma.masked\\n interactive_plots = Interactive_Plots()\\n if return_simple_catchment_and_flowmap_plotters and plot_simple_catchment_and_flowmap_plots:\\n simple_catchment_and_flowmap_plotters = []\\n if return_catchment_plotters:\\n catchment_plotters = []\\n for pair in matchedpairs:\\n if pair[0].get_lat() > 310:\\n continue\\n if select_only_rivers_in == \\\"North America\\\":\\n if(pair[0].get_lat() > 156 or pair[0].get_lon() > 260):\\n continue\\n print(\\\"Ref Point: \\\" + str(pair[0]) + \\\"Matches: \\\" + str(pair[1]))\\n if rivers_to_plot is not None:\\n if not (pair[0].get_lat(),pair[0].get_lon()) in rivers_to_plot:\\n continue\\n if split_comparison_plots_across_multiple_canvases:\\n plt.figure(figsize=(25,6.25))\\n ax = plt.subplot(121)\\n plt.tight_layout()\\n else:\\n plt.figure(figsize=(25,12.5))\\n ax = plt.subplot(222)\\n rc_pts.plot_river_rmouth_flowmap(ax=ax,\\n ref_flowtocellfield=ref_flowtocellfield,\\n data_flowtocellfield=data_flowtocellfield,\\n rdirs_field=rdirs_field,\\n pair=pair,colors=self.colors)\\n if split_comparison_plots_across_multiple_canvases:\\n ax_hist = plt.subplot(122)\\n plt.figure(figsize=(12.5,12.5))\\n ax_catch = plt.subplot(111)\\n plt.tight_layout(rect=(0,0,0.9,1))\\n else:\\n ax_hist = plt.subplot(221)\\n ax_catch = plt.subplot(223)\\n plot_catchment_and_histogram_output = \\\\\\n rc_pts.plot_catchment_and_histogram_for_river(ax_hist=ax_hist,ax_catch=ax_catch,\\n ref_catchment_field=ref_catchment_field,\\n data_catchment_field=data_catchment_field,\\n data_catchment_field_original_scale=\\\\\\n data_catchment_field_original_scale,\\n data_original_scale_flowtocellfield=\\\\\\n data_original_scale_flowtocellfield,\\n rdirs_field=rdirs_field,\\n data_rdirs_field=data_rdirs_field,pair=pair,\\n catchment_grid_changed=catchment_grid_changed,\\n swap_ref_and_data_when_finding_labels=\\\\\\n swap_ref_and_data_when_finding_labels,\\n colors=self.colors,\\n ref_grid=ref_grid,\\n grid_type=grid_type,\\n alternative_catchment_bounds=\\\\\\n alternative_catchment_bounds,\\n use_simplified_catchment_colorscheme=\\\\\\n use_simplified_catchment_colorscheme,\\n use_upscaling_labels=\\\\\\n use_upscaling_labels,\\n allow_new_sink_points=\\\\\\n allow_new_true_sinks,\\n external_landsea_mask=\\\\\\n external_ls_mask,\\n ref_original_scale_flowtocellfield=\\\\\\n ref_original_scale_flowtocellfield,\\n ref_catchment_field_original_scale=\\\\\\n ref_catchment_field_original_scale,\\n use_original_scale_field_for_determining_data_and_ref_labels=\\\\\\n use_original_scale_field_for_determining_data_and_ref_labels,\\n return_catchment_plotter=\\\\\\n return_catchment_plotters,\\n data_original_scale_grid_type=\\\\\\n data_original_scale_grid_type,\\n ref_original_scale_grid_type=\\\\\\n ref_original_scale_grid_type,\\n data_original_scale_grid_kwargs=\\\\\\n data_original_scale_grid_kwargs,\\n ref_original_scale_grid_kwargs=\\\\\\n ref_original_scale_grid_kwargs,\\n **grid_kwargs)\\n if return_catchment_plotters:\\n catchment_section,catchment_bounds,scale_factor,catchment_plotter =\\\\\\n plot_catchment_and_histogram_output\\n catchment_plotters.append(catchment_plotter)\\n else:\\n catchment_section,catchment_bounds,scale_factor = plot_catchment_and_histogram_output\\n if split_comparison_plots_across_multiple_canvases:\\n plt.figure(figsize=(12.5,12.5))\\n ax = plt.subplot(111)\\n plt.tight_layout(rect=(0,0,0.9,1))\\n else:\\n ax = plt.subplot(224)\\n rc_pts.plot_whole_river_flowmap(ax=ax,pair=pair,ref_flowtocellfield=ref_flowtocellfield,\\n data_flowtocellfield=data_flowtocellfield,\\n rdirs_field=rdirs_field,data_rdirs_field=data_rdirs_field,\\n catchment_bounds=catchment_bounds,colors=self.colors,\\n simplified_flowmap_plot=use_simplified_flowmap_colorscheme,\\n allow_new_sink_points=allow_new_true_sinks)\\n if plot_simple_catchment_and_flowmap_plots:\\n simple_candf_plt = plt.figure(figsize=(10,6))\\n simple_ref_ax = plt.subplot(121)\\n simple_data_ax = plt.subplot(122)\\n flowtocell_threshold = 75\\n plotters = rc_pts.simple_catchment_and_flowmap_plots(fig=simple_candf_plt,\\n ref_ax=simple_ref_ax,\\n data_ax=simple_data_ax,\\n ref_catchment_field=ref_catchment_field,\\n data_catchment_field=data_catchment_field,\\n data_catchment_field_original_scale=\\\\\\n data_catchment_field_original_scale,\\n ref_flowtocellfield=ref_flowtocellfield,\\n data_flowtocellfield=data_flowtocellfield,\\n data_original_scale_flowtocellfield=\\\\\\n data_original_scale_flowtocellfield,\\n pair=pair,catchment_bounds=catchment_bounds,\\n flowtocell_threshold=flowtocell_threshold,\\n catchment_grid_changed=catchment_grid_changed,\\n colors=self.colors,\\n external_ls_mask=external_ls_mask,\\n grid_type=grid_type,\\n data_original_scale_grid_type=\\\\\\n data_original_scale_grid_type,\\n data_original_scale_grid_kwargs=\\\\\\n data_original_scale_grid_kwargs,**grid_kwargs)\\n if return_simple_catchment_and_flowmap_plotters:\\n simple_catchment_and_flowmap_plotters.append(plotters)\\n if ref_orog_filename and data_orog_original_scale_filename:\\n if super_fine_orog_filename:\\n data_to_super_fine_scale_factor = \\\\\\n pts.calculate_scale_factor(coarse_grid_type=data_original_scale_grid_type,\\n coarse_grid_kwargs=data_original_scale_grid_kwargs,\\n fine_grid_type=super_fine_orog_grid_type,\\n fine_grid_kwargs=super_fine_orog_grid_kwargs)\\n ref_to_super_fine_scale_factor = data_to_super_fine_scale_factor*scale_factor\\n else:\\n ref_to_super_fine_scale_factor=None\\n interactive_plots.setup_plots(catchment_section,\\n ref_orog_field,\\n data_orog_original_scale_field,\\n ref_flowtocellfield,\\n data_flowtocellfield,\\n rdirs_field,\\n super_fine_orog_field,\\n super_fine_data_flowmap,\\n pair, catchment_bounds,\\n scale_factor,\\n ref_to_super_fine_scale_factor,\\n ref_grid_offset_adjustment=ref_grid.\\\\\\n get_longitude_offset_adjustment(),\\n fine_grid_offset_adjustment=fine_grid.\\\\\\n get_longitude_offset_adjustment(),\\n super_fine_grid_offset_adjustment=super_fine_grid.\\\\\\n get_longitude_offset_adjustment())\\n elif ref_orog_filename or data_orog_original_scale_filename:\\n warnings.warn(\\\"No orography plot generated, require both a reference orography\\\"\\n \\\" and a data orography to generate an orography plot\\\")\\n print(\\\"Unresolved Conflicts: \\\")\\n for conflict in unresolved_conflicts:\\n print(\\\" Conflict:\\\")\\n for pair in conflict:\\n print(\\\" Ref Point\\\" + str(pair[0]) + \\\"Matches\\\" + str(pair[1]))\\n for temp_file in temp_file_list:\\n if os.path.basename(temp_file).startswith(\\\"temp_\\\"):\\n print(\\\"Deleting File: {0}\\\".format(temp_file))\\n os.remove(temp_file)\\n if return_simple_catchment_and_flowmap_plotters and plot_simple_catchment_and_flowmap_plots:\\n return simple_catchment_and_flowmap_plotters\\n if return_catchment_plotters:\\n return catchment_plotters\",\n \"def investigate4DRepeatability():\\n parentdir = '/home/rallured/Dropbox/Interferometer/SolarBFlat/Repeatability/'\\n avgs = [1,2,4,8,16,32]\\n\\n #Temporal with fringes tilted\\n fn = glob.glob(parentdir+'Tilt/17*RepeatabilityTiltTemporal*.bin')\\n fn.sort()\\n dx = met.readFlatScript(fn[0].split('.')[0])[1]\\n d = np.array([met.readFlatScript(fi.split('.')[0])[0] for fi in fn])\\n #Make progressive averaging plot\\n plt.figure('TemporalTiltedFigure')\\n for i in np.arange(6)*2:\\n f,p = fourier.meanPSD(d[i],win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label=str(avgs[i/2]))\\n plt.legend(loc='lower left')\\n plt.title('Solar B PSD - Temporal,Tilted')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n #Get repeatability\\n reptemptilt = d[-1]-d[-2]\\n figtemptilt = d[-1]\\n\\n #Dynamic with fringes tilted\\n fn = glob.glob(parentdir+'Tilt/17*RepeatabilityTilt_*.bin')\\n fn.sort()\\n dx = met.readFlatScript(fn[0].split('.')[0])[1]\\n d = [met.readFlatScript(fi.split('.')[0])[0] for fi in fn]\\n #Make progressive averaging plot\\n plt.figure('DynamicTiltedFigure')\\n for i in np.arange(6)*2:\\n f,p = fourier.meanPSD(d[i],win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label=str(avgs[i/2]))\\n plt.legend(loc='lower left')\\n plt.title('Solar B PSD - Dynamic,Tilted')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n #Get repeatability\\n repdyntilt = d[-1]-d[-2]\\n figdyntilt = d[-1]\\n \\n #Temporal with fringes nulled\\n fn = glob.glob(parentdir+'Nulled/17*.bin')\\n fn.sort()\\n dx = met.readFlatScript(fn[0].split('.')[0])[1]\\n d = np.array([met.readFlatScript(fi.split('.')[0])[0] for fi in fn])\\n #Make progressive averaging plot\\n plt.figure('TemporalNulledFigure')\\n for i in np.arange(6)*2:\\n f,p = fourier.meanPSD(d[i],win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label=str(avgs[i/2]))\\n plt.legend(loc='lower left')\\n plt.title('Solar B PSD - Temporal,Nulled')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n #Get repeatability\\n reptempnull = d[-1]-d[-2]\\n figtempnull = d[-1]\\n \\n #Dynamic with fringes nulled\\n d = pyfits.getdata('/home/rallured/Dropbox/Interferometer/'\\n 'SolarBFlat/Repeatability/'\\n 'Nulled/170103_Processed.fits')\\n rep = np.array([d[i,0]-d[i,1] for i in range(32)])\\n #Make progressive averaging plot\\n plt.figure('DynamicNulledFigure')\\n for i in [0,1,3,7,15,31]:\\n f,p = fourier.meanPSD(d[i,0],win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label=str(i+1))\\n plt.legend(loc='lower left')\\n plt.title('Solar B PSD - Dynamic,Nulled')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n #Get repeatability\\n repdynnull = d[-1][0]-d[-1][1]\\n figdynnull = d[-1][0]\\n\\n #Make comparative repeatability plots with 32 averages\\n plt.figure('CompareRepeatability')\\n f,p = fourier.meanPSD(repdynnull,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Dynamic,Nulled')\\n f,p = fourier.meanPSD(repdyntilt,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Dynamic,Tilted')\\n f,p = fourier.meanPSD(reptemptilt,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Temporal,Tilted')\\n f,p = fourier.meanPSD(reptempnull,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Temporal,Nulled')\\n plt.legend(loc='lower left')\\n plt.title('Solar B Repeatability - 32 Averages')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n\\n #Make comparative figure plots with 32 averages\\n plt.figure('CompareFigure')\\n f,p = fourier.meanPSD(figdynnull,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Dynamic,Nulled')\\n f,p = fourier.meanPSD(figdyntilt,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Dynamic,Tilted')\\n f,p = fourier.meanPSD(figtemptilt,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Temporal,Tilted')\\n f,p = fourier.meanPSD(figtempnull,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Temporal,Nulled')\\n plt.legend(loc='lower left')\\n plt.title('Solar B Figure - 32 Averages')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n\\n #Make parroting repeatability plots\\n fig = plt.figure('Parroting')\\n fig.add_subplot(2,2,1)\\n plt.imshow(repdyntilt)\\n plt.title('Dynamic Repeatability')\\n plt.colorbar()\\n fig.add_subplot(2,2,2)\\n plt.imshow(reptemptilt)\\n plt.title('Temporal Repeatability')\\n plt.colorbar()\\n fig.add_subplot(2,2,3)\\n res = legendre2d(repdyntilt,xo=3,yo=3)[0]\\n plt.imshow(repdyntilt-res)\\n plt.title('Dynamic Repeatability Filtered')\\n plt.colorbar()\\n fig.add_subplot(2,2,4)\\n res = legendre2d(reptemptilt,xo=3,yo=3)[0]\\n plt.imshow(reptemptilt-res)\\n plt.title('Temporal Repeatability Filtered')\\n plt.colorbar()\",\n \"def apolco(a,minfeh=-3,out=None) :\\n apo=np.where((a['TELESCOPE'] == 'apo25m') & (a['RV_FEH']>minfeh) )[0]\\n fig=vscat(a[apo],marker='o',density=True)\\n lco=np.where((a['TELESCOPE'] == 'lco25m') & (a['RV_FEH']>minfeh) )[0]\\n vscat(a[lco],fig=fig,ls=':',marker='+',density=True)\\n if out is not None : \\n fig[0].savefig(out+'_1.png')\\n plt.close()\\n i1,i2=match.match(a['APOGEE_ID'][apo],a['APOGEE_ID'][lco])\\n print('matched {:d} stars'.format(len(i1)))\\n fig,ax=plots.multi(1,2)\\n #plots.plotp(ax[0,0],a['SNR'][apo[i1]],a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],yr=[-3,3],yt=r'$\\\\Delta$ VHELIO_AVG',xt='S/N')\\n #plots.plotp(ax[0,1],a['SNR'][apo[i1]],a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],yr=[-50,50],yt=r'$\\\\Delta$ VHELIO_AVG',xt='S/N')\\n #plots.plotp(ax[1,0],a['SNR'][apo[i1]],a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],yr=[-0.5,0.5],yt=r'$\\\\Delta$ VSCATTER',xt='S/N')\\n #plots.plotp(ax[1,1],a['SNR'][apo[i1]],a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],yr=[-5,5],yt=r'$\\\\Delta$ VSCATTER',xt='S/N')\\n ax[0].hist(a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],bins=np.arange(-0.5,0.5,0.02),histtype='step')\\n ax[0].set_xlabel(r'$\\\\Delta$ VHELIO_AVG')\\n ax[1].hist(a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],bins=np.arange(-0.25,0.25,0.01),histtype='step')\\n ax[1].set_xlabel(r'$\\\\Delta$ VSCATTER')\\n if out is not None : \\n fig.savefig(out+'_2.png')\\n plt.close()\",\n \"def MatchMatrixs (self,Node1,Node2):\\n\\n T1Native_Node = Node1\\n T1Native_Matrix = slicer.util.arrayFromVolume(T1Native_Node)\\n DimN = T1Native_Matrix.shape\\n T1Enhanced_Node = Node2\\n T1Enhanced_Matrix = slicer.util.arrayFromVolume(T1Enhanced_Node)\\n DimE = T1Enhanced_Matrix.shape\\n\\n NMatrix = self.GetIJKToRASnpArray(T1Native_Node)\\n NVector = NMatrix[:-1,-1]\\n EMatrix = self.GetIJKToRASnpArray(T1Enhanced_Node)\\n EVector = EMatrix[:-1,-1]\\n NPixelSize = [np.linalg.norm(NMatrix[:-1,0]), np.linalg.norm(NMatrix[:-1,1])]\\n EPixelSize = [np.linalg.norm(EMatrix[:-1,0]), np.linalg.norm(EMatrix[:-1,1])]\\n\\n Niversor = NMatrix[:-1,0]/NPixelSize[0]\\n Njversor = NMatrix[:-1,1]/NPixelSize[1]\\n Nkversor = np.round(np.cross(Niversor,Njversor),3)\\n Nkstep = round(np.linalg.norm(NMatrix[:-1,2]),3)\\n\\n Eiversor = EMatrix[:-1,0]/EPixelSize[0]\\n Ejversor = EMatrix[:-1,1]/EPixelSize[1]\\n Ekversor = np.round(np.cross(Eiversor,Ejversor),3)\\n Ekstep = round(np.linalg.norm(EMatrix[:-1,2]),3)\\n print(Nkversor,Ekversor,Nkstep,Ekstep,NVector,EVector,(NVector-EVector).dot(Ekversor))\\n if not ( np.sum(Nkversor==Ekversor) == 3 and Nkstep==Ekstep and ((NVector-EVector).dot(Ekversor)) == 0 ): # it verifies if the slices are oriented in the same direction, with the same step between slices and if the first images are complanar.\\n slicer.util.warningDisplay('The geometry of the LL Native and LL Enhanced volume doesn\\\\'t match. It could deteriorate the ECV map', windowTitle= 'Warning')\\n\\n if (DimE == DimN):\\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.NativeT1_Selector.currentNode()) \\n return [T1Native_Matrix,T1Enhanced_Matrix]\\n if (DimE[1:3] == DimN[1:3]):\\n k = min([DimE[1],DimN[1]])\\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.NativeT1_Selector.currentNode())\\n return [T1Native_Matrix[:k,:,:],T1Enhanced_Matrix[:k,:,:]]\\n\\n jN = np.arange(0,DimN[2]*NPixelSize[1],NPixelSize[1])+NPixelSize[1]/2+(NVector-EVector).dot(Njversor)\\n iN = np.arange(0,DimN[1]*NPixelSize[0],NPixelSize[0])+NPixelSize[0]/2+(NVector-EVector).dot(Niversor)\\n iE = np.arange(0,DimE[1]*EPixelSize[0],EPixelSize[0])+EPixelSize[0]/2\\n jE = np.arange(0,DimE[2]*EPixelSize[1],EPixelSize[1])+EPixelSize[1]/2 \\n if DimE[1] > DimN[1]: ## I concidered a square image\\n T1Nreshaped = np.zeros(DimE)\\n for k in range(DimN[0]):\\n f = interpolate.interp2d(iN, jN, np.nan_to_num(T1Native_Matrix[k,:,:]), fill_value = 0)\\n T1Nreshaped[k,:,:] = f(iE, jE)\\n T1Ereshaped = T1Enhanced_Matrix[:k+1,:,:]\\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.EnhancedT1_Selector.currentNode())\\n return [T1Nreshaped,T1Ereshaped]\\n else:\\n T1Ereshaped = np.zeros(DimN)\\n for k in range(DimE[0]):\\n f = interpolate.interp2d(iE, jE, np.nan_to_num(T1Enhanced_Matrix[k,:,:]), fill_value = 0)\\n T1Ereshaped[k,:,:] = f(iN, jN) \\n T1Nreshaped = T1Native_Matrix[:k+1,:,:]\\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.NativeT1_Selector.currentNode()) \\n return [T1Nreshaped,T1Ereshaped]\",\n \"def data_model_residual(surface, dem, unw, incidence):\\n los,fem_los,residual = pu.los2pylith(surface,dem,unw,incidence)\\n\\n # Using image_grid\\n fig = plt.figure()\\n grid = ImageGrid(fig, 111, # similar to subplot(111)\\n nrows_ncols = (1, 3),\\n direction=\\\"row\\\",\\n axes_pad = 0.05,\\n add_all=True,\\n label_mode = \\\"1\\\",\\n share_all = True,\\n cbar_location=\\\"top\\\",\\n cbar_mode=\\\"each\\\", #\\\"single\\\"\\n cbar_size=\\\"5%\\\",\\n cbar_pad=0.05,\\n )\\n #grid[0].set_xlabel(\\\"X\\\")\\n #grid[0].set_ylabel(\\\"Y\\\")\\n #grid2[0].set_xticks([-2, 0])\\n #grid2[0].set_yticks([-2, 0, 2])\\n\\n #NOTE: could find global min/max from three arrays here\\n norm = Normalize(vmin=np.nanmin(los), vmax=np.nanmax(los))\\n #for ax,data in zip(grid,[los,fem_los,residual]):\\n im = grid[0].imshow(los,origin='upper',norm=norm,cmap=plt.cm.jet)\\n grid[0].axhline(100,color='m') #show profile\\n cax = grid.cbar_axes[0]\\n cax.colorbar(im)\\n grid[1].axhline(100,color='k') #show profile\\n im1 = grid[1].imshow(fem_los,origin='upper',norm=norm,cmap=plt.cm.jet)\\n\\n cax = grid.cbar_axes[1]\\n cax.colorbar(im1)\\n\\n im2 = grid[2].imshow(residual,origin='upper',cmap=plt.cm.jet)\\n cax = grid.cbar_axes[2]\\n cax.colorbar(im2)\\n\\n # Add letter labels\\n for ax, label in zip(grid,['A', 'B', 'C']):\\n ax.text(0.05, 0.95, label, transform=ax.transAxes,\\n fontsize=16, fontweight='bold', va='top')\\n\\n # Annotate\\n # NOTE: way too high!\\n #plt.suptitle('FEM Results')\\n\\n # Add profile\\n # NOTE: for now EW, but would be easy to do arbitrary line, and convert to km\\n fig = plt.figure()\\n #x = arange(los.shape[0])\\n plt.axhline(color='k',ls='--')\\n plt.plot(los[100],'m.',label='data')\\n plt.plot(fem_los[100],'k-',lw=2,label='model')\\n plt.xlabel('Distance [km]')\\n plt.ylabel('Distance [km]')\\n plt.legend(loc='upper left')\\n\\n plt.show()\",\n \"def combine_sides(imgID_list_blue, imgID_list_red, output=None, splot='yes'):\\r\\n \\r\\n blue_files = ['blue{:04d}_flux.spec.fits'.format(imgID) for imgID in imgID_list_blue]\\r\\n red_files = ['red{:04d}_flux.spec.fits'.format(imgID) for imgID in imgID_list_red]\\r\\n blue_err_files = ['blue{:04d}_flux.err.fits'.format(imgID) for imgID in imgID_list_blue]\\r\\n red_err_files = ['red{:04d}_flux.err.fits'.format(imgID) for imgID in imgID_list_red]\\r\\n\\r\\n\\r\\n if output is None:\\r\\n hdr = pyfits.getheader(blue_files[0])\\r\\n obj = hdr['OBJECT'].replace(' ', '_')\\r\\n # create a unique name based on the input\\r\\n\\r\\n def ids_to_string(idlist):\\r\\n \\\"\\\"\\\"Create hyphen-delimited string from list of ints\\\"\\\"\\\"\\r\\n if len(idlist) == 1:\\r\\n return \\\"{:d}\\\".format(idlist[0])\\r\\n else:\\r\\n return \\\"-\\\".join([\\\"{:d}\\\".format(id) for id in idlist])\\r\\n\\r\\n output = obj + '_' + \\\\\\r\\n ids_to_string(imgID_list_blue) + '+' + \\\\\\r\\n ids_to_string(imgID_list_red) \\r\\n\\r\\n # clobber the old output files if they exist\\r\\n iraf.delete(output+'.*.fits', verify='no')\\r\\n iraf.delete(output+'.*.txt', verify='no')\\r\\n \\r\\n # determine dispersion: downsample to lower-resolution spectrum\\r\\n hdr = pyfits.getheader(blue_files[0])\\r\\n dw_blue = hdr['CDELT1']\\r\\n hdr = pyfits.getheader(red_files[0])\\r\\n dw_red = hdr['CDELT1']\\r\\n dw = np.max([dw_blue, dw_red])\\r\\n\\r\\n # find wavelength ranges\\r\\n def wavelength_range(fits_list):\\r\\n \\\"\\\"\\\"Given an input list of fits spectra from extract1D, \\r\\n return the absolute minimum and maximum wavelength ranges\\\"\\\"\\\"\\r\\n mins = []\\r\\n maxes = []\\r\\n for fname in fits_list:\\r\\n spec = np.genfromtxt(fname.replace('fits', 'txt'), names='wave, flux', \\r\\n dtype='f4, f4')\\r\\n mins.append(spec['wave'].min())\\r\\n maxes.append(spec['wave'].max())\\r\\n return [np.array(mins).min(), np.array(maxes).max()]\\r\\n\\r\\n blue_range = wavelength_range(blue_files)\\r\\n red_range = wavelength_range(red_files)\\r\\n\\r\\n # find overlap region\\r\\n if red_range[0] >= blue_range[1]:\\r\\n raise ValueError('No overlap in wavelength solution between sides!')\\r\\n\\r\\n # specify total spectral range\\r\\n w1 = blue_range[0]\\r\\n w2 = red_range[1]\\r\\n\\r\\n # re-disperse to common wavelength solution\\r\\n def redisperse_list(files,dw,w1,w2,key='spec'):\\r\\n \\\"\\\"\\\"Re-disperse a list of spectra.\\r\\n\\r\\n Wraps iraf.dispcor.\\r\\n\\r\\n Parameters\\r\\n ----------\\r\\n files : list of strings\\r\\n Files to disperse\\r\\n dw : int\\r\\n rs Spectral dispersion [Angstroms per pixel]\\r\\n w1 : int\\r\\n Minimum wavelength [Angstrom]\\r\\n w2 : int\\r\\n Maximum wavelength [Angstrom]\\r\\n key : {'spec' (default) or 'err'}\\r\\n Whether the files are spectra or uncertainties.\\r\\n \\\"\\\"\\\"\\r\\n input_list = ','.join(files)\\r\\n disp_files = [f.replace(key, key+'-disp') for f in files]\\r\\n output_disp_list = ','.join(disp_files)\\r\\n iraf.unlearn('dispcor')\\r\\n iraf.dispcor.input = input_list\\r\\n iraf.dispcor.output = output_disp_list\\r\\n # keep existing wavelength endpoints\\r\\n iraf.dispcor.dw = dw\\r\\n iraf.dispcor.w1 = w1\\r\\n iraf.dispcor.w2 = w2\\r\\n iraf.dispcor.flux = 'no'\\r\\n iraf.dispcor()\\r\\n # write text files\\r\\n for output in disp_files:\\r\\n iraf.wspectext(output, output.replace('fits', 'txt'), header=\\\"no\\\")\\r\\n\\r\\n return disp_files\\r\\n\\r\\n # delete any lingering files\\r\\n iraf.delete('*-disp.fits', verify='no')\\r\\n iraf.delete('*-disp.txt', verify='no')\\r\\n\\r\\n blue_files_redisp = redisperse_list(blue_files, dw, w1, w2)\\r\\n red_files_redisp = redisperse_list(red_files, dw, w1, w2)\\r\\n blue_err_files_redisp = redisperse_list(blue_err_files, dw, w1, w2, key='err')\\r\\n red_err_files_redisp = redisperse_list(red_err_files, dw, w1, w2, key='err')\\r\\n\\r\\n # combine individual sides\\r\\n coadd_spectra(blue_files_redisp, 'tmp-blue')\\r\\n coadd_spectra(red_files_redisp, 'tmp-red')\\r\\n\\r\\n # find optimum weighting between sides\\r\\n\\r\\n # combine sides, weighted by uncertainties\\r\\n coadd_spectra(['tmp-blue.spec.fits', 'tmp-red.spec.fits'], output,\\r\\n one_side=False)\\r\\n\\r\\n # clean up\\r\\n iraf.delete('*-disp.fits', verify='no')\\r\\n iraf.delete('*-disp.txt', verify='no')\\r\\n iraf.delete('tmp-*.fits', verify='no')\\r\\n iraf.delete('tmp-*.txt', verify='no')\\r\\n \\r\\n if splot == 'yes':\\r\\n iraf.splot(output+'.spec')\",\n \"def show_corls():\\n datar = data_from_fits(\\\"752_1_373_r.fits\\\")\\n datar = other_object(datar)\\n datag = data_from_fits(\\\"752_1_373_g.fits\\\")\\n datag = other_object(datag)\\n corl = correlate2d(datar, datag, mode=\\\"same\\\")\\n plt.figure()\\n plt.imshow(corl)\\n\\n datar = data_from_fits(\\\"752_1_373_r.fits\\\")\\n datar = galaxy(datar)\\n datag = data_from_fits(\\\"752_1_373_g.fits\\\")\\n datag = galaxy(datag)\\n corl = correlate2d(datar, datag, mode=\\\"same\\\")\\n plt.figure()\\n plt.imshow(corl)\\n\\n\\n datar = data_from_fits(\\\"752_1_373_r.fits\\\")\\n datar = asteroid(datar)\\n datag = data_from_fits(\\\"752_1_373_g.fits\\\")\\n datag = asteroid(datag)\\n corl = correlate2d(datar, datag, mode=\\\"same\\\")\\n plt.figure()\\n plt.imshow(corl)\",\n \"def eval_pos():\\n annotations_dir = \\\"/home/sdb/wangshentao/myspace/thesis/data/VisDrone2019-MOT-test-dev/annotations\\\"\\n all_iou = []\\n seqs_sample = '''\\n uav0000249_00001_v\\n uav0000249_02688_v\\n '''\\n seqs_str = seqs_sample\\n seqs = [seq.strip() for seq in seqs_str.split()]\\n for seq in seqs:\\n print(seq)\\n bbox, frame_id = get_frame_bbox(annotations_dir, seq + '.txt')\\n predict_bbox = []\\n for idx in range(len(bbox)):\\n kalman_filter = KalmanFilter()\\n trace_bbox = bbox[idx]\\n trace_predict_bbox = []\\n mean, covariance = kalman_filter.initiate(tlwh_to_xyah(trace_bbox[0]))\\n for i in range(1, trace_bbox.shape[0]):\\n mean, covariance = kalman_filter.predict(mean, covariance)\\n trace_predict_bbox.append(tlwh(mean))\\n mean, covariance = kalman_filter.update(mean, covariance, tlwh_to_xyah(trace_bbox[i]))\\n\\n trace_predict_bbox = np.array(trace_predict_bbox)\\n for i in range(trace_predict_bbox.shape[0]):\\n trace_predict_bbox[i] = tlwh_to_tlbr(trace_predict_bbox[i])\\n for i in range(trace_bbox.shape[0]):\\n trace_bbox[i] = tlwh_to_tlbr(trace_bbox[i])\\n\\n predict_bbox.append(trace_predict_bbox)\\n bbox[idx] = bbox[idx][1:]\\n frame_id[idx] = frame_id[idx][1:]\\n assert bbox[idx].shape[0] == predict_bbox[idx].shape[0]\\n iou = []\\n for i in range(len(bbox)):\\n trace_iou = []\\n trace_bbox = bbox[i]\\n trace_predict_bbx = predict_bbox[i]\\n for j in range(trace_bbox.shape[0]):\\n iou_val = bbox_ious(np.ascontiguousarray(trace_bbox[j][np.newaxis, :], dtype=np.float),\\n np.ascontiguousarray(trace_predict_bbx[j][np.newaxis, :], dtype=np.float))\\n trace_iou.append(iou_val)\\n iou.append(np.array(trace_iou))\\n iou = [int(np.mean(i)*100) for i in iou]\\n all_iou += iou\\n bins = np.zeros(101)\\n for i in all_iou:\\n bins[i] += 1\\n plt.bar(np.arange(101), bins)\\n plt.ylabel('num')\\n plt.xlabel('IoU*100')\\n plt.show()\",\n \"def compare_present_day_and_lgm_river_directions_with_catchments_ICE6G_plus_tarasov_style_orog_corrs_for_both(self):\\n present_day_data_datetime = \\\"20170612_202721\\\"\\n lgm_data_datetime = \\\"20170612_202559\\\"\\n ref_filename=os.path.join(self.plots_data_dir,\\n \\\"flowmap_ICE6g_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_tarasov\\\"\\n \\\"_orog_corrs_{0}_upscaled_updated.nc\\\".\\\\\\n format(present_day_data_datetime))\\n data_filename=os.path.join(self.plots_data_dir,\\n \\\"flowmap_ICE6g_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_\\\"\\n \\\"tarasov_orog_corrs_{0}_upscaled_updated.nc\\\".\\\\\\n format(lgm_data_datetime))\\n lsmask_filename=os.path.join(self.plots_data_dir,\\n \\\"ls_mask_ICE6g_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs\\\"\\n \\\"_tarasov_orog_corrs_{0}_HD_transf.nc\\\".\\\\\\n format(lgm_data_datetime))\\n extra_lsmask_filename=os.path.join(self.plots_data_dir,\\n \\\"ls_mask_ICE6g_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale\\\"\\n \\\"_rdirs_tarasov_orog_corrs_{0}_HD_transf.nc\\\".\\\\\\n format(present_day_data_datetime))\\n ref_catchment_filename=(\\\"catchmentmap_ICE6g_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_\\\"\\n \\\"tarasov_orog_corrs_{0}_upscaled_updated.nc\\\".\\\\\\n format(present_day_data_datetime))\\n data_catchment_filename=(\\\"catchmentmap_ICE6g_lgm_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs\\\"\\n \\\"_tarasov_orog_corrs_{0}_upscaled_updated.nc\\\".\\\\\\n format(lgm_data_datetime))\\n ref_rdirs_filename=(\\\"upscaled_rdirs_ICE6g_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_\\\"\\n \\\"plus_upscale_rdirs_tarasov_orog_corrs_{0}_upscaled_\\\"\\n \\\"updated.nc\\\".format(present_day_data_datetime))\\n reference_rmouth_outflows_filename=os.path.join(self.plots_data_dir,\\n \\\"rmouthflows_ICE6g_0k_ALG4_sinkless_no_true_sinks_oceans_\\\"\\n \\\"lsmask_plus_upscale_rdirs_tarasov_orog_corrs\\\"\\n \\\"_{0}_upscaled_updated.nc\\\".\\\\\\n format(present_day_data_datetime))\\n data_rmouth_outflows_filename=os.path.join(self.plots_data_dir,\\n \\\"rmouthflows_ICE6g_lgm_ALG4_sinkless_no_true_sinks_oceans_\\\"\\n \\\"lsmask_plus_upscale_rdirs_tarasov_orog_corrs_\\\"\\n \\\"{0}_upscaled_updated.nc\\\".\\\\\\n format(lgm_data_datetime))\\n glacier_mask_filename=os.path.join(self.orog_data_directory,\\\"Ice6g_c_VM5a_10min_21k.nc\\\")\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n ref_catchment_filename,\\n data_catchment_filename=\\\\\\n data_catchment_filename,\\n ref_rdirs_filename=\\\\\\n ref_rdirs_filename,\\n data_rdirs_filename=None,\\n reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=75,\\n flip_data=False,\\n rotate_data=True,\\n flip_ref=False,\\n rotate_ref=True,\\n lsmask_has_same_orientation_as_ref=False,\\n invert_ls_mask=True,\\n first_datasource_name=\\\"Present day\\\",\\n second_datasource_name=\\\"LGM\\\",\\n matching_parameter_set='extensive',\\n catchment_and_outflows_mods_list_filename=\\\\\\n \\\"ice6g_catch_and_outflow_mods_lgm_vs_present_day.txt\\\",\\n additional_matches_list_filename=\\\\\\n \\\"ice6g_additional_matches_10min_upscaled_lgm_vs_present.txt\\\",\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n use_title=False,remove_antartica=True,\\n difference_in_catchment_label=\\\"Difference\\\",\\n rivers_to_plot=[(216,433),(117,424),(112,380),(146,327),\\n (132,496),(120,176),(251,638),(115,603),\\n (33,571),(34,571),(36,660),(181,256),\\n (120,457),(77,365),(258,235),(167,361),\\n (219,598)],\\n rivers_to_plot_alt_color=[(237,393),(192,384),(169,371),\\n (119,399),(72,640),(126,165),\\n (87,112),(88,419),(160,237),\\n (60,35),(147,552),(245,635),\\n (86,460),(33,603),\\n (247,243),(41,682),(185,276),\\n (147,522),(244,612)],\\n rivers_to_plot_secondary_alt_color=[(230,427),(170,376),\\n (180,446),(143,327),\\n (201,287),(136,538),\\n (100,467),(116,130),\\n (160,572),(32,614),\\n (50,712),(210,619),\\n (179,445),(212,384),\\n (261,230),(85,438)],\\n glacier_mask_filename=glacier_mask_filename,\\n extra_lsmask_filename=extra_lsmask_filename,\\n glacier_mask_grid_type='LatLong10min',\\n flip_glacier_mask=True,\\n rotate_glacier_mask=True,\\n grid_type='HD')\",\n \"def compare(self, plot=False):\\n oldConditionData, newConditionData = self.runSimulations()\\n \\n #For now make print statements about each none matching data\\n conditionsBroken=[]\\n variablesFailed=[]\\n for i in range(len(oldConditionData)):\\n timeOld, dataListOld = oldConditionData[i]\\n timeNew, dataListNew = newConditionData[i]\\n\\n for variableOld, variableNew in zip(dataListOld, dataListNew):\\n if not curvesSimilar(timeOld.data, variableOld.data, timeNew.data, variableNew.data, 0.05):\\n if i not in conditionsBroken: conditionsBroken.append(i)\\n\\n if variableOld.species:\\n label = variableOld.species.molecule[0].toSMILES()\\n print \\\"Species profile for {0} does not match between the old model ({1}) and \\\\\\n the new model ({2}) in condition {3:d}.\\\".format(variableOld.species.molecule[0].toSMILES(),\\n variableOld.label, \\n variableNew.label,\\n i+1)\\n else:\\n label = variableOld.label\\n print \\\"{0} does not match between the old model and \\\\\\n the new model in condition {1:d}.\\\".format(variableOld.label, i+1)\\n\\n variablesFailed.append((self.conditions[i], label, variableOld, variableNew))\\n print ''\\n print 'The following reaction conditions were broken:'\\n print ''\\n for index in conditionsBroken:\\n print \\\"Condition {0:d}:\\\"\\n print str(self.conditions[index])\\n print ''\\n\\n if plot:\\n # Ignore Inerts\\n inertList = ['[Ar]','[He]','[N#N]','[Ne]']\\n for i in range(len(oldConditionData)):\\n time, dataList = oldConditionData[i]\\n speciesData = [data for data in dataList if data.species.molecule[0].toSMILES() not in inertList]\\n oldSpeciesPlot = SimulationPlot(xVar=time, yVar=speciesData, ylabel='Mole Fraction')\\n\\n time, dataList = newConditionData[i]\\n speciesData = [data for data in dataList if data.species.molecule[0].toSMILES() not in inertList]\\n newSpeciesPlot = SimulationPlot(xVar=time, yVar=speciesData, ylabel='Mole Fraction')\\n\\n # Name after the index of the condition\\n # though it may be better to name it after the actual conditions in T, P, etc\\n oldSpeciesPlot.comparePlot(newSpeciesPlot,filename='simulation_condition_{0}.png'.format(i+1))\\n\\n return variablesFailed\",\n \"def compareRepeatability():\\n fc,pc = refCylNoise()\\n fp,pp = flatNoisePellicle()\\n fcgh,pcgh = flatNoiseCGH()\\n fpco,ppco = PCO1S12Noise()\\n\\n midfreq = [1000*np.sqrt(np.sum(p[np.logical_and(f>.1,f<1.)])) \\\\\\n for f,p in zip([fp,fc,fcgh,fpco],[pp,pc,pcgh,ppco])]\\n plt.clf()\\n \\n plt.loglog(fp,pp/fp[0],label='Flat+Pellicle: %.2f' % midfreq[0])\\n plt.loglog(fc,pc/fc[0],label='Cylinder+CGH: % .2f' % midfreq[1])\\n plt.loglog(fcgh,pcgh/fcgh[0],label='Flat+CGH: %.2f' % midfreq[2])\\n plt.loglog(fpco,ppco/fpco[0],label='PCO1S12: %.2f' % midfreq[3])\\n plt.title('Repeatability Comparison')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n plt.legend(loc='lower left')\",\n \"def evaluate_field_diff(smdf1, smdf2, fieldname, orbitnameone, orbitnametwo, vmin=-1, vmax=1, xaxis='Latitude', save_fig_directory=None):\\n logging.debug(\\\"Evaluating difference between 2 dataframes for field '{}'...\\\".format(fieldname))\\n logging.debug('The difference runs from 1 -> 2, ie. {} -> {}, 2 subtract 1'.format(orbitnameone, orbitnametwo))\\n logging.debug('Dataset 1: {}'.format(orbitnameone))\\n logging.debug('Dataset 2: {}'.format(orbitnametwo))\\n\\n # Exclude NaN records (reported as fieldname = -999.0)\\n frame1 = smdf1[smdf1[fieldname] != -999.0]\\n frame2 = smdf2[smdf2[fieldname] != -999.0]\\n\\n # Print record counts\\n logging.debug('Dataset 1 contains {}/{} valid datarows'.format(len(frame1.index), len(smdf1)))\\n logging.debug('Dataset 2 contains {}/{} valid datarows'.format(len(frame2.index), len(smdf2)))\\n\\n # Get records in common\\n common = pd.merge(frame1, frame2, how='inner', on=['Days', 'Seconds', 'Microseconds', 'Grid_Point_ID'])\\n common.rename(columns={'Latitude_x': 'Latitude', 'Longitude_x': 'Longitude'}, inplace=True)\\n common.drop('Latitude_y', axis=1, inplace=True)\\n common.drop('Longitude_y', axis=1, inplace=True)\\n common[fieldname+'_Diff'] = common[fieldname+'_y'] - common[fieldname+'_x']\\n common.reset_index(inplace=True)\\n\\n # Outer merge ready for getting new records\\n outer = pd.merge(frame1, frame2, how='outer', on=['Days', 'Seconds', 'Microseconds', 'Grid_Point_ID'],\\n indicator=True)\\n # Get records in 1 but not 2\\n leftonly = outer[outer['_merge'] == 'left_only'].copy()\\n leftonly.rename(columns={'Latitude_x': 'Latitude', 'Longitude_x': 'Longitude', fieldname+'_x': fieldname},\\n inplace=True)\\n leftonly.drop('Latitude_y', axis=1, inplace=True)\\n leftonly.drop('Longitude_y', axis=1, inplace=True)\\n leftonly.drop(fieldname+'_y', axis=1, inplace=True)\\n leftonly.drop('_merge', axis=1, inplace=True)\\n\\n # Get records in 2 but not 1\\n rightonly = outer[outer['_merge'] == 'right_only'].copy()\\n rightonly.rename(columns={'Latitude_x': 'Latitude', 'Longitude_x': 'Longitude', fieldname+'_y': fieldname},\\n inplace=True)\\n rightonly.drop('Latitude_y', axis=1, inplace=True)\\n rightonly.drop('Longitude_y', axis=1, inplace=True)\\n rightonly.drop(fieldname+'_x', axis=1, inplace=True)\\n rightonly.drop('_merge', axis=1, inplace=True)\\n\\n non_zero_diff = common[common[fieldname+'_Diff'] != 0]\\n\\n logging.debug('Dataset analysis:')\\n logging.debug('{} rows common to both datasets.'.format(len(common.index)))\\n logging.debug('{}/{} common rows have non-zero differences.'.format(len(non_zero_diff.index), len(common.index)))\\n logging.debug('{} rows in dataset 1 only.'.format(len(leftonly.index)))\\n logging.debug('{} rows in dataset 2 only.'.format(len(rightonly.index)))\\n\\n # Get records in common that are same/diff\\n\\n # Make plots only if we have differences\\n if non_zero_diff.empty:\\n logging.debug('No differences to plot')\\n else:\\n # First plot (geographic map)\\n plot_sm_difference(common, orbitnameone, orbitnametwo, fieldname=fieldname+'_Diff', vmin=vmin, vmax=vmax, save_fig_directory=save_fig_directory)\\n\\n #fig2, ax2 = plt.subplots(1)\\n ## plot each difference against the index grid point id\\n #common.plot(x=xaxis, y=fieldname+'_Diff', ax=ax2, legend=False, rot=90,\\n # fontsize=8, clip_on=False, style='o')\\n #ax2.set_ylabel(fieldname + ' Diff')\\n #ax2.axhline(y=0, linestyle=':', linewidth='0.5', color='k')\\n #fig2.tight_layout()\\n\\n # Second plot (scatter plot, diff by lat)\\n # Plot only the ones with a non-zero difference\\n fig3, ax3 = plt.subplots(1)\\n plt.title('{} : ({}) subtract ({})'.format(fieldname.replace('_',' '), orbitnametwo, orbitnameone), wrap=True)\\n non_zero_diff.plot(x=xaxis, y=fieldname+'_Diff', ax=ax3, legend=False,\\n rot=90, fontsize=8, clip_on=False, style='o')\\n ax3.axhline(y=0, linestyle=':', linewidth='0.5', color='k')\\n ax3.set_ylabel(fieldname + ' Diff')\\n fig3.tight_layout()\\n\\n if (save_fig_directory != None):\\n # Requested to save the figure\\n save_name = 'diff-scatter-({})-subtr-({})-field-({})-{}.png'.format(orbitnametwo, orbitnameone, fieldname.replace(' ', ''), datetime.now().strftime('%Y%m%d-%H%M%S'))\\n logging.debug('Attempting to save figure with name \\\"{}\\\"'.format(save_name))\\n plt.savefig(os.path.join(save_fig_directory, save_name))\\n plt.close()\\n else:\\n plt.show()\",\n \"def notebook_01():\\n\\n freq_list, volt_list = las.load_freq_volt()\\n\\n n_steps, n_det, n_f, _ = np.shape(volt_list)\\n\\n #y_sym_mat_o = ds.by_sym_mat(volt_list, det_ind=0)\\n #y_sym_mat_i = ds.by_sym_mat(volt_list, det_ind=1)\\n\\n # print(np.shape(y_sym_mat_o))\\n # print(np.shape(y_sym_mat_i))\\n # (mu_o, sigma_o) = stats.norm.fit(y_sym_mat_o[:,0])\\n # (mu_i, sigma_i) = stats.norm.fit(y_sym_mat_i[:,0])\\n # print(mu_o, sigma_o)\\n # print(mu_i, sigma_i)\\n # print(mu_o*89000, mu_i*89000.0, -mu_i*89000.0, -mu_o*89000.0)\\n\\n volt_list_sym = ds.volt_list_sym_calc(volt_list)\\n\\n fit_params_mat = fp.fit_params(ff.f_b_field, volt_list_sym)\\n\\n fit_params_mat_s = fp.fit_params(ff.f_b_field_off, volt_list_sym)\\n\\n # pbd.plot_bare_signal_and_fit_norm_shifted(0, volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\\n\\n # pfp.plot_fit_sym_comp(volt_list_sym, fit_params_mat, fit_params_mat_s, freq_list)\\n\\n\\n # pfp.plot_fit_sym_comp_2(volt_list_sym, fit_params_mat_s, freq_list)\\n\\n #pfp.plot_symmetry_along_z(volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\\n\\n fp.fit_params_FH_data(ff.f_b_field)\\n\\n # pbd.plot_rel_diff_bare_signal_and_fit_norm_shifted(0, volt_list_sym, freq_list, fit_params_mat_s, ff.f_b_field_off)\",\n \"def main():\\n print(\\\"Program version: 1.5\\\")\\n StartTime = datetime.now()\\n args = parseArguments()\\n\\n verbose = args.verbose\\n images = args.images\\n ignore_warnings = args.ignore_warnings\\n if(args.silent):\\n verbose = False\\n images = False\\n ignore_warnings = True\\n\\n if(args.images):\\n plt.ioff()\\n\\n if(args.ignore_warnings):\\n warnings.simplefilter('ignore', UserWarning)\\n\\n #sample header keywords\\n # OBJECT = 'P016+03_P1_JKdeep' / Original target\\n # RA = ' 01:06:37.759' / 01:06:37.7 RA (J2000) pointing\\n # DEC = ' 03:32:36.096' / 03:32:36.0 DEC (J2000) pointing\\n # EQUINOX = 2000. / Standard FK5 (years)\\n # RADECSYS= 'FK5 ' / Coordinate reference frame\\n # CRVAL1 = 16.65733 / 01:06:37.7, RA at ref pixel\\n # CRVAL2 = 3.54336 / 03:32:36.0, DEC at ref pixel\\n # CRPIX1 = 447. /Ref pixel in X\\n # CRPIX2 = 452. / Ref pixel in Y\\n # CDELT1 = -8.0000000000000E-5 / SS arcsec per pixel in RA\\n # CDELT2 = 8.00000000000003E-5 / SS arcsec per pixel in DEC\\n # CTYPE1 = 'RA---TAN' / pixel coordinate system\\n # CTYPE2 = 'DEC--TAN' / pixel coordinate system\\n # PC1_1 = 0.000000 / Translation matrix element\\n # PC1_2 = 1.000000 / Translation matrix element\\n # PC2_1 = -1.000000 / Translation matrix element\\n # PC2_2 = 0.000000 / Translation matrix element\\n\\n fits_image_filenames = args.input\\n\\n #if directory given search for appropriate fits files\\n\\n if(os.path.isdir(fits_image_filenames[0])):\\n print(\\\"detected a directory. Will search for fits files in it\\\")\\n path = fits_image_filenames[0]\\n fits_image_filenames = []\\n for file in os.listdir(path):\\n if file.endswith(\\\".fits\\\") and \\\"_astro\\\" not in file:\\n fits_image_filenames.append(path+\\\"/\\\"+file)\\n print(fits_image_filenames)\\n\\n multiple = False\\n if(len(fits_image_filenames)>1):\\n multiple = True\\n not_converged = []\\n converged_counter = 0\\n for fits_image_filename in fits_image_filenames:\\n\\n result,_ = astrometry_script(fits_image_filename, catalog=args.catalog, rotation_scaling=0, xy_transformation=args.xy_transformation, fine_transformation=args.fine_transformation,\\n images=images, vignette=args.vignette,vignette_rectangular=args.vignette_rectangular, cutouts=args.cutout, ra=args.ra, dec=args.dec, projection_ra=args.projection_ra, projection_dec=args.projection_dec, verbose=verbose, save_images=args.save_images, ignore_header_rot=args.ignore_header_rot, radius = args.radius, save_bad_result=args.save_bad_result, silent =args.silent, sigma_threshold_for_source_detection= args.sigma_threshold_for_source_detection, high_res=args.high_resolution, hdul_idx=args.hdul_idx, filename_for_sources=args.filename_for_sources, FWHM=args.seeing)\\n\\n if((not result) and args.rotation_scaling):\\n print(\\\"Did not converge. Will try again with full rotation and scaling\\\")\\n result, _ = astrometry_script(fits_image_filename, catalog=args.catalog, rotation_scaling=args.rotation_scaling, xy_transformation=args.xy_transformation, fine_transformation=args.fine_transformation,\\n images=images, vignette=args.vignette,vignette_rectangular=args.vignette_rectangular, cutouts=args.cutout, ra=args.ra, dec=args.dec, projection_ra=args.projection_ra, projection_dec=args.projection_dec, verbose=verbose, save_images=args.save_images, ignore_header_rot=args.ignore_header_rot, radius = args.radius, save_bad_result=args.save_bad_result, silent=args.silent, sigma_threshold_for_source_detection=args.sigma_threshold_for_source_detection, high_res=args.high_resolution, hdul_idx=args.hdul_idx, filename_for_sources=args.filename_for_sources, FWHM=args.seeing)\\n\\n if(result):\\n print(\\\"Astrometry was determined to be good.\\\")\\n converged_counter = converged_counter+1\\n else:\\n print(\\\"Astrometry was determined to be bad.\\\")\\n not_converged.append(fits_image_filename)\\n if(args.save_bad_result):\\n print(\\\"Result was saved anyway\\\")\\n else:\\n print(\\\"Result was not saved.\\\")\\n # print(\\\"\\\")\\n # print(\\\">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\\\")\\n # print(\\\"> Astrometry for {} \\\".format(fits_image_filename))\\n #\\n # with fits.open(fits_image_filename) as hdul:\\n # #print(hdul.info())\\n # if(args.verbose):\\n # print(\\\"if image is not at first position in the fits file the program will break later on\\\")\\n # #print(hdul[0].header)\\n #\\n # hdu = hdul[0]\\n # #hdu.verify('fix')\\n # hdr = hdu.header\\n #\\n #\\n # image_or = hdul[0].data.astype(float)\\n # median = np.nanmedian(image_or)\\n # image_or[np.isnan(image_or)]=median\\n # image = image_or - median\\n #\\n # observation = find_sources(image, args.vignette)\\n # #print(observation)\\n #\\n # positions = (observation['xcenter'], observation['ycenter'])\\n # apertures = CircularAperture(positions, r=4.)\\n #\\n #\\n # #world coordinates\\n # print(\\\">Info found in the file -- (CRVAl: position of central pixel (CRPIX) on the sky)\\\")\\n # print(WCS(hdr))\\n #\\n # hdr[\\\"NAXIS1\\\"] = image.shape[0]\\n # hdr[\\\"NAXIS2\\\"] = image.shape[1]\\n #\\n # #wcsprm = Wcsprm(hdr.tostring().encode('utf-8')) #everything else gave me errors with python 3, seemed to make problems with pc conversios, so i wwitched to the form below\\n # wcsprm = WCS(hdr).wcs\\n # wcsprm_original = WCS(hdr).wcs\\n # if(args.verbose):\\n # print(WCS(wcsprm.to_header()))\\n # wcsprm, fov_radius, INCREASE_FOV_FLAG, PIXSCALE_UNCLEAR = read_additional_info_from_header(wcsprm, hdr, args.ra, args.dec, args.projection_ra, args.projection_dec)\\n # if(args.verbose):\\n # print(WCS(wcsprm.to_header()))\\n #\\n # #print(wcsprm)\\n # #wcsprm.pc = [[2, 0],[0,1]]\\n #\\n #\\n # #Possibly usefull examples of how to use wcsprm:\\n # #print(wcsprm.set())\\n # #print(wcsprm.get_pc())\\n # #pc = wcsprm.get_pc()\\n # #print(np.linalg.det(pc))\\n # #print(wcsprm.get_cdelt())\\n # #wcs.fix()\\n # #print(wcsprm.print_contents())\\n # #print(repr(hdr.update(wcsprm.to_header().encode('utf-8')))) #not working\\n #\\n # #hdu.verify(\\\"fix\\\")\\n # #print(repr(hdr))\\n # #wcs.wcs_pix2world(pixcrd, 1)\\n # #wcs.wcs_world2pix(world, 1)\\n # #wcs.wcs.crpix = [-234.75, 8.3393]\\n # # wcs.wcs.cdelt = np.array([-0.066667, 0.066667])\\n # # wcs.wcs.crval = [0, -90]\\n # # wcs.wcs.ctype = [\\\"RA---AIR\\\", \\\"DEC--AIR\\\"]\\n # # wcs.wcs.set_pv([(2, 1, 45.0)])\\n # # For historical compatibility, three alternate specifications of the linear transformations\\n # # are available in wcslib. The canonical PCi_ja with CDELTia, CDi_ja, and the deprecated CROTAia\\n # # keywords. Although the latter may not formally co-exist with PCi_ja,\\n # # the approach here is simply to ignore them if given in conjunction with PCi_ja.\\n # # has_pc, has_cd and has_crota can be used to determine which of these alternatives are present in the header.\\n # # These alternate specifications of the linear transformation matrix are translated immediately to PCi_ja by set\\n # # and are nowhere visible to the lower-level routines. In particular, set resets cdelt to unity if CDi_ja is present\\n # # (and no PCi_ja). If no CROTAia is associated with the latitude axis, set reverts to a unity PCi_ja matrix.\\n #\\n #\\n #\\n #\\n #\\n # #get rough coordinates\\n # #print(hdr[\\\"RA\\\"])\\n # #coord = SkyCoord(hdr[\\\"RA\\\"], hdr[\\\"DEC\\\"], unit=(u.hourangle, u.deg), frame=\\\"icrs\\\")\\n # coord = SkyCoord(wcsprm.crval[0], wcsprm.crval[1], unit=(u.deg, u.deg), frame=\\\"icrs\\\")\\n # if(not PIXSCALE_UNCLEAR):\\n # if(wcsprm.crpix[0] < 0 or wcsprm.crpix[1] < 0 or wcsprm.crpix[0] > image.shape[0] or wcsprm.crpix[1] > image.shape[1] ):\\n # print(\\\"central value outside of the image, moving it to the center\\\")\\n # coord_radec = wcsprm.p2s([[image.shape[0]/2, image.shape[1]/2]], 0)[\\\"world\\\"][0]\\n # coord = SkyCoord(coord_radec[0], coord_radec[1], unit=(u.deg, u.deg), frame=\\\"icrs\\\")\\n # #print(wcsprm)\\n #\\n #\\n #\\n # #better: put in nice wrapper! with repeated tries and maybe try synchron!\\n # print(\\\">Dowloading catalog data\\\")\\n # radius = u.Quantity(fov_radius, u.arcmin)#will prob need more\\n # catalog_data = query.get_data(coord, radius, args.catalog)\\n # #reference = reference.query(\\\"mag <20\\\")\\n # max_sources = 500\\n # if(INCREASE_FOV_FLAG):\\n # max_sources= max_sources*2.25 #1.5 times the radius, so 2.25 the area\\n # if(catalog_data.shape[0]>max_sources):\\n # catalog_data = catalog_data.nsmallest(400, \\\"mag\\\")\\n #\\n # if(args.catalog == \\\"GAIA\\\" and catalog_data.shape[0] < 5):\\n # print(\\\"GAIA seems to not have enough objects, will enhance with PS1\\\")\\n # catalog_data2 = query.get_data(coord, radius, \\\"PS\\\")\\n # catalog_data = pd.concat([catalog_data, catalog_data2])\\n # #apertures_catalog = CircularAperture(wcs.wcs_world2pix(catalog_data[[\\\"ra\\\", \\\"dec\\\"]], 1), r=5.)\\n # print(\\\"Now we have a total of {} sources. Keep in mind that there might be duplicates now since we combined 2 catalogs\\\".format(catalog_data.shape[0]))\\n # elif(args.catalog == \\\"PS\\\" and (catalog_data is None or catalog_data.shape[0] < 5)):\\n # print(\\\"We seem to be outside the PS footprint, enhance with GAIA data\\\")\\n # catalog_data2 = query.get_data(coord, radius, \\\"GAIA\\\")\\n # catalog_data = pd.concat([catalog_data, catalog_data2])\\n # #apertures_catalog = CircularAperture(wcs.wcs_world2pix(catalog_data[[\\\"ra\\\", \\\"dec\\\"]], 1), r=5.)\\n # print(\\\"Now we have a total of {} sources. Keep in mind that there might be duplicates now since we combined 2 catalogs\\\".format(catalog_data.shape[0]))\\n #\\n # #remove duplicates in catalog?\\n #\\n # apertures_catalog = CircularAperture(wcsprm.s2p(catalog_data[[\\\"ra\\\", \\\"dec\\\"]], 1)['pixcrd'], r=5.)\\n #\\n #\\n # #plotting what we have, I keep it in the detector field, world coordinates are more painfull to plot\\n # if(args.images):\\n # fig = plt.figure()\\n # fig.canvas.set_window_title('Input for {}'.format(fits_image_filename))\\n # plt.xlabel(\\\"pixel x direction\\\")\\n # plt.ylabel(\\\"pixel y direction\\\")\\n # plt.title(\\\"Input - red: catalog sources, blue: detected sources in img\\\")\\n # plt.imshow(image,cmap='Greys', origin='lower', norm=LogNorm())\\n # apertures.plot(color='blue', lw=1.5, alpha=0.5)\\n # apertures_catalog.plot(color='red', lw=1.5, alpha=0.5)\\n #\\n # plt.xlim(-200,image.shape[0]+200)\\n # plt.ylim(-200,image.shape[1]+200)\\n # if(args.save_images):\\n # name_parts = fits_image_filename.rsplit('.', 1)\\n # plt.savefig(name_parts[0]+\\\"_image_before.pdf\\\")\\n #\\n # ###tranforming to match the sources\\n # print(\\\"---------------------------------\\\")\\n # print(\\\">Finding the transformation\\\")\\n # if(args.rotation_scaling):\\n # print(\\\"Finding scaling and rotation\\\")\\n # wcsprm = register.get_scaling_and_rotation(observation, catalog_data, wcsprm, scale_guessed=PIXSCALE_UNCLEAR, verbose=args.verbose)\\n # if(args.xy_transformation):\\n # print(\\\"Finding offset\\\")\\n # wcsprm,_,_ = register.offset_with_orientation(observation, catalog_data, wcsprm, fast=False , INCREASE_FOV_FLAG=INCREASE_FOV_FLAG, verbose= args.verbose)\\n #\\n # #correct subpixel error\\n # obs_x, obs_y, cat_x, cat_y, distances = register.find_matches(observation, catalog_data, wcsprm, threshold=3)\\n # rms = np.sqrt(np.mean(np.square(distances)))\\n # best_score = len(obs_x)/(rms+10) #start with current best score\\n # fine_transformation = False\\n # if(args.fine_transformation):\\n # for i in [2,3,5,8,10,6,4, 20,2,1,0.5]:\\n # wcsprm_new, score = register.fine_transformation(observation, catalog_data, wcsprm, threshold=i)\\n # if(score> best_score):\\n # wcsprm = wcsprm_new\\n # best_score = score\\n # fine_transformation = True\\n # if not fine_transformation:\\n # print(\\\"Fine transformation did not improve result so will be discarded.\\\")\\n # else:\\n # print(\\\"Fine transformation applied to improve result\\\")\\n # #register.calculate_rms(observation, catalog_data,wcs)\\n #\\n # #make wcsprim more physical by moving scaling to cdelt, out of the pc matrix\\n # wcs =WCS(wcsprm.to_header())\\n # if(args.verbose):\\n # print(wcs)\\n #\\n # from astropy.wcs import utils\\n # scales = utils.proj_plane_pixel_scales(wcs)\\n # print(scales)\\n # cdelt = wcsprm.get_cdelt()\\n # print(cdelt)\\n # scale_ratio = scales/cdelt\\n # #print(scale_ratio)\\n # pc = np.array(wcsprm.get_pc())\\n # pc[0,0] = pc[0,0]/scale_ratio[0]\\n # pc[1,0] = pc[1,0]/scale_ratio[1]\\n # pc[0,1] = pc[0,1]/scale_ratio[0]\\n # pc[1,1] = pc[1,1]/scale_ratio[1]\\n # wcsprm.pc = pc\\n # wcsprm.cdelt = scales\\n # if(args.verbose):\\n # print(\\\"moved scaling info to CDelt\\\")\\n # print(WCS(wcsprm.to_header()))\\n #\\n # #WCS difference before and after\\n # print(\\\"> Compared to the input the Wcs was changed by: \\\")\\n # scales_original = utils.proj_plane_pixel_scales(WCS(hdr))\\n # print(\\\"WCS got scaled by {} in x direction and {} in y direction\\\".format(scales[0]/scales_original[0], scales[1]/scales_original[1]))\\n # #sources:\\n # #https://math.stackexchange.com/questions/2113634/comparing-two-rotation-matrices\\n # #https://stackoverflow.com/questions/2827393/angles-between-two-n-dimensional-vectors-in-python/13849249#13849249\\n # def unit_vector(vector):\\n # \\\"\\\"\\\" Returns the unit vector of the vector. \\\"\\\"\\\"\\n # return vector / max(np.linalg.norm(vector), 1e-10)\\n # def matrix_angle( B, A ):\\n # \\\"\\\"\\\" comment cos between vectors or matrices \\\"\\\"\\\"\\n # Aflat = A.reshape(-1)\\n # Aflat = unit_vector(Aflat)\\n # Bflat = B.reshape(-1)\\n # Bflat = unit_vector(Bflat)\\n # #return np.arccos((np.dot( Aflat, Bflat ) / max( np.linalg.norm(Aflat) * np.linalg.norm(Bflat), 1e-10 )))\\n # return np.arccos(np.clip(np.dot(Aflat, Bflat), -1.0, 1.0))\\n # #print(matrix_angle(wcsprm.get_pc(), wcsprm_original.get_pc()) /2/np.pi*360)\\n # rotation_angle = matrix_angle(wcsprm.get_pc(), wcsprm_original.get_pc()) /2/np.pi*360\\n # if((wcsprm.get_pc() @ wcsprm_original.get_pc() )[0,1] > 0):\\n # text = \\\"counterclockwise\\\"\\n # else:\\n # text = \\\"clockwise\\\"\\n # print(\\\"Rotation of WCS by an angle of {} deg \\\".format(rotation_angle)+text)\\n # old_central_pixel = wcsprm_original.s2p([wcsprm.crval], 0)[\\\"pixcrd\\\"][0]\\n # print(\\\"x offset: {} px, y offset: {} px \\\".format(wcsprm.crpix[0]- old_central_pixel[0], wcsprm.crpix[1]- old_central_pixel[1]))\\n #\\n #\\n # #check final figure\\n # if(args.images):\\n # fig = plt.figure()\\n # fig.canvas.set_window_title('Result for {}'.format(fits_image_filename))\\n # plt.xlabel(\\\"pixel x direction\\\")\\n # plt.ylabel(\\\"pixel y direction\\\")\\n # plt.title(\\\"Result - red: catalog sources, blue: detected sources in img\\\")\\n # plt.imshow(image,cmap='Greys', origin='lower', norm=LogNorm())\\n # apertures.plot(color='blue', lw=1.5, alpha=0.5)\\n # #apertures_catalog = CircularAperture(wcs.wcs_world2pix(catalog_data[[\\\"ra\\\", \\\"dec\\\"]], 1), r=5.)\\n # apertures_catalog = CircularAperture(wcsprm.s2p(catalog_data[[\\\"ra\\\", \\\"dec\\\"]], 1)['pixcrd'], r=5.)\\n #\\n # apertures_catalog.plot(color='red', lw=1.5, alpha=0.5)\\n # if(args.save_images):\\n # name_parts = fits_image_filename.rsplit('.', 1)\\n # plt.savefig(name_parts[0]+\\\"_image_after.pdf\\\")\\n #\\n # print(\\\"--- Evaluate how good the transformation is ----\\\")\\n # register.calculate_rms(observation, catalog_data,wcsprm)\\n #\\n #\\n # #updating file\\n # write_wcs_to_hdr(fits_image_filename, wcsprm)\\n #\\n #\\n # print(\\\"overall time taken\\\")\\n # print(datetime.now()-StartTime)\\n # if(args.images):\\n # plt.show()\\n if(multiple):\\n print(\\\">> Final report:\\\")\\n print(\\\"Processed {} files, {} of them did converge. The following files failed:\\\".format(len(fits_image_filenames), converged_counter))\\n print(not_converged)\\n print(\\\"-- finished --\\\")\",\n \"def compare_present_day_and_lgm_river_directions_with_catchments_ICE5G_plus_tarasov_style_orog_corrs_for_both(self):\\n present_day_data_datetime = \\\"20170521_002051\\\"\\n lgm_data_datetime = \\\"20170521_151723\\\"\\n ref_filename=os.path.join(self.plots_data_dir,\\n \\\"flowmap_ICE5G_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_tarasov\\\"\\n \\\"_orog_corrs_generation_and_upscaling_{0}_upscaled_updated.nc\\\".\\\\\\n format(present_day_data_datetime))\\n data_filename=os.path.join(self.plots_data_dir,\\n \\\"flowmap_ICE5G_21k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_\\\"\\n \\\"tarasov_orog_corrs_generation_and_upscaling_{0}_upscaled_updated.nc\\\".\\\\\\n format(lgm_data_datetime))\\n lsmask_filename=os.path.join(self.plots_data_dir,\\n \\\"ls_mask_ICE5G_21k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs\\\"\\n \\\"_tarasov_orog_corrs_generation_and_upscaling_{0}_HD_transf.dat\\\".\\\\\\n format(lgm_data_datetime))\\n ref_catchment_filename=(\\\"catchmentmap_ICE5G_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs_\\\"\\n \\\"tarasov_orog_corrs_generation_and_upscaling_{0}_upscaled_updated.nc\\\".\\\\\\n format(present_day_data_datetime))\\n data_catchment_filename=(\\\"catchmentmap_ICE5G_21k_ALG4_sinkless_no_true_sinks_oceans_lsmask_plus_upscale_rdirs\\\"\\n \\\"_tarasov_orog_corrs_generation_and_upscaling_{0}_upscaled_updated.nc\\\".\\\\\\n format(lgm_data_datetime))\\n ref_rdirs_filename=(\\\"upscaled_rdirs_ICE5G_0k_ALG4_sinkless_no_true_sinks_oceans_lsmask_\\\"\\n \\\"plus_upscale_rdirs_tarasov_orog_corrs_generation_and_upscaling_{0}_upscaled_\\\"\\n \\\"updated_transf.dat\\\".format(present_day_data_datetime))\\n reference_rmouth_outflows_filename=os.path.join(self.plots_data_dir,\\n \\\"rmouthflows_ICE5G_0k_ALG4_sinkless_no_true_sinks_oceans_\\\"\\n \\\"lsmask_plus_upscale_rdirs_tarasov_orog_corrs\\\"\\n \\\"_generation_and_upscaling_{0}_upscaled_updated.nc\\\".\\\\\\n format(present_day_data_datetime))\\n data_rmouth_outflows_filename=os.path.join(self.plots_data_dir,\\n \\\"rmouthflows_ICE5G_21k_ALG4_sinkless_no_true_sinks_oceans_\\\"\\n \\\"lsmask_plus_upscale_rdirs_tarasov_orog_corrs_\\\"\\n \\\"generation_and_upscaling_{0}_upscaled_updated.nc\\\".\\\\\\n format(lgm_data_datetime))\\n glacier_mask_filename=os.path.join(self.orog_data_directory,\\\"ice5g_v1_2_21_0k_10min.nc\\\")\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n ref_catchment_filename,\\n data_catchment_filename=\\\\\\n data_catchment_filename,\\n ref_rdirs_filename=\\\\\\n ref_rdirs_filename,\\n data_rdirs_filename=None,\\n reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=100,\\n flip_data=False,\\n rotate_data=True,\\n flip_ref=False,\\n rotate_ref=True,\\n lsmask_has_same_orientation_as_ref=False,\\n invert_ls_mask=True,\\n first_datasource_name=\\\"Present day\\\",\\n second_datasource_name=\\\"LGM\\\",\\n matching_parameter_set='extensive',\\n catchment_and_outflows_mods_list_filename=\\\\\\n \\\"catch_and_outflow_mods_lgm_vs_present_day.txt\\\",\\n additional_matches_list_filename=\\\\\\n \\\"additional_matches_10min_upscaled_lgm_vs_present.txt\\\",\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n use_title=False,remove_antartica=True,\\n difference_in_catchment_label=\\\"Difference\\\",\\n glacier_mask_filename=glacier_mask_filename,\\n glacier_mask_grid_type='LatLong10min',\\n flip_glacier_mask=True,\\n rotate_glacier_mask=True,\\n grid_type='HD')\",\n \"def test_vis_calc():\\n\\n ant1_enu = np.array([0, 0, 0])\\n ant2_enu = np.array([0.0, 14.6, 0])\\n\\n bl = observatory.Baseline(ant1_enu, ant2_enu)\\n\\n freqs = np.array([1e8])\\n nfreqs = 1\\n\\n fov = 20 # Deg\\n\\n # Longitude/Latitude in degrees.\\n\\n nside = 32\\n ind = 10\\n center = list(hp.pix2ang(nside, ind, lonlat=True))\\n centers = [center]\\n npix = nside ** 2 * 12\\n shell = np.zeros((npix, nfreqs))\\n pix_area = 4 * np.pi / float(npix)\\n shell[ind] = 1 # Jy/pix\\n shell[ind] *= utils.jy2Tsr(freqs[0], bm=pix_area) # K\\n\\n obs = observatory.Observatory(latitude, longitude, array=[bl], freqs=freqs)\\n obs.pointing_centers = centers\\n obs.times_jd = np.array([1])\\n obs.set_fov(fov)\\n obs.set_beam(\\\"uniform\\\")\\n\\n sky = sky_model.SkyModel(Nside=nside, freqs=freqs, data=shell[np.newaxis, :, :])\\n\\n visibs, times, bls = obs.make_visibilities(sky)\\n assert np.isclose(np.real(visibs), 1.0).all() # Unit point source at zenith\",\n \"def test_compare_blackrockio_with_matlabloader_v21(self):\\n\\n dirname = self.get_local_path('blackrock/blackrock_2_1/l101210-001')\\n # First run with parameters for ns5, then run with correct parameters for ns2\\n parameters = [('blackrock/blackrock_2_1/l101210-001_nev-02_ns5.mat',\\n {'nsx_to_load': 5, 'nev_override': '-'.join([dirname, '02'])}, 96),\\n ('blackrock/blackrock_2_1/l101210-001.mat', {'nsx_to_load': 2}, 6)]\\n for param in parameters:\\n # Load data from Matlab generated files\\n ml = scipy.io.loadmat(self.get_local_path(param[0]))\\n lfp_ml = ml['lfp'] # (channel x time) LFP matrix\\n ts_ml = ml['ts'] # spike time stamps\\n elec_ml = ml['el'] # spike electrodes\\n unit_ml = ml['un'] # spike unit IDs\\n wf_ml = ml['wf'] # waveforms\\n mts_ml = ml['mts'] # marker time stamps\\n mid_ml = ml['mid'] # marker IDs\\n\\n # Load data from original data files using the Neo BlackrockIO\\n reader = BlackrockRawIO(dirname, **param[1])\\n reader.parse_header()\\n\\n # Check if analog data are equal\\n stream_index = 0\\n self.assertGreater(reader.signal_channels_count(stream_index), 0)\\n\\n for c in range(0, param[2]):\\n raw_sigs = reader.get_analogsignal_chunk(channel_indexes=[c])\\n raw_sigs = raw_sigs.flatten()\\n assert_equal(raw_sigs[:], lfp_ml[c, :])\\n\\n # Check if spikes in channels are equal\\n nb_unit = reader.spike_channels_count()\\n for spike_channel_index in range(nb_unit):\\n unit_name = reader.header['spike_channels'][spike_channel_index]['name']\\n # name is chXX#YY where XX is channel_id and YY is unit_id\\n channel_id, unit_id = unit_name.split('#')\\n channel_id = int(channel_id.replace('ch', ''))\\n unit_id = int(unit_id)\\n\\n matlab_spikes = ts_ml[(elec_ml == channel_id) & (unit_ml == unit_id)]\\n\\n io_spikes = reader.get_spike_timestamps(spike_channel_index=spike_channel_index)\\n assert_equal(io_spikes, matlab_spikes)\\n\\n # Check all waveforms\\n io_waveforms = reader.get_spike_raw_waveforms(\\n spike_channel_index=spike_channel_index)\\n io_waveforms = io_waveforms[:, 0, :] # remove dim 1\\n matlab_wf = wf_ml[np.nonzero(\\n np.logical_and(elec_ml == channel_id, unit_ml == unit_id)), :][0]\\n assert_equal(io_waveforms, matlab_wf)\\n\\n # Check if digital input port events are equal\\n nb_ev_chan = reader.event_channels_count()\\n # ~ print(reader.header['event_channels'])\\n for ev_chan in range(nb_ev_chan):\\n name = reader.header['event_channels']['name'][ev_chan]\\n # ~ print(name)\\n if name == 'digital_input_port':\\n all_timestamps, _, labels = reader.get_event_timestamps(\\n event_channel_index=ev_chan)\\n\\n for label in np.unique(labels):\\n python_digievents = all_timestamps[labels == label]\\n matlab_digievents = mts_ml[mid_ml == int(label)]\\n assert_equal(python_digievents, matlab_digievents)\",\n \"def test_tastis_output_linearaxis1(self, capsys):\\n\\n self.get_data(\\\"input\\\", \\\"od3v01bfq_raw.fits\\\")\\n self.get_data(\\\"input\\\", \\\"od3v01bfq_spt.fits\\\")\\n\\n capsys.readouterr()\\n\\n tastis('od3v01bfq_raw.fits')\\n\\n captured = capsys.readouterr()\\n assert captured.out == \\\"===============================================================================\\\\n\\\" \\\\\\n \\\"od3v01bfq HST/STIS MIRVIS 52X0.05 ACQ/PEAK-UP\\\\n\\\" \\\\\\n \\\"prop: 14493 visit: 01 line: 5 target: 2MASS-J23062928-0502285\\\\n\\\" \\\\\\n \\\"obs date, time: 2016-09-26 04:17:57 exposure time: 10.00\\\\n\\\" \\\\\\n \\\"dom GS/FGS: SB5F000135F1 sub-dom GS/FGS: SB5F000156F2\\\\n\\\" \\\\\\n \\\"ACQ params: bias sub: 1510 method: MAX-FLUX-CENTROID\\\\n\\\" \\\\\\n \\\"subarray (axis1,axis2): size=(32,32) corner=(521,500)\\\\n\\\" \\\\\\n \\\"-------------------------------------------------------------------------------\\\\n\\\" \\\\\\n \\\"Scan type: LINEARAXIS1 Step size (mas): 26\\\\n\\\" \\\\\\n \\\"\\\\n\\\" \\\\\\n \\\" [ 0 848 3069 3432 1912 555 228]\\\\n\\\" \\\\\\n \\\"\\\\n\\\" \\\\\\n \\\" axis1 axis2 axis1 axis2 V2 V3\\\\n\\\" \\\\\\n \\\" (pixels) (arcsec) (arcsec)\\\\n\\\" \\\\\\n \\\"Estimated slew: -0.2 0.0 -0.010 0.000 -0.007 -0.007\\\\n\\\" \\\\\\n \\\"Flux in post-slew confirmation image (40210) - Pedestal (35982) = 4228 DN\\\\n\\\" \\\\\\n \\\"-------------------------------------------------------------------------------\\\\n\\\" \\\\\\n \\\"The confirmation image has a flux between 0.8 and 2.0 times the\\\\n\\\" \\\\\\n \\\"maximum flux in the peakup, which is typical of a successful ACQ/PEAK.\\\\n\\\" \\\\\\n \\\"===============================================================================\\\\n\\\"\",\n \"def _check_xyz_output(self, cwd):\\n\\n for ii, refname in enumerate(self.files):\\n if self.forms[ii] == \\\"xyz\\\":\\n ref_structs = []\\n try:\\n with open(Path(cwd) / refname) as ref:\\n ref_natoms = int(ref.readline())\\n for s, ll in enumerate(ref.readlines()):\\n if (s + 1) % (ref_natoms + 2) != 0 and (s + 1) % (\\n ref_natoms + 2\\n ) != 1:\\n ref_structs.append(ll.split()[1:])\\n reff = [[float(v) for v in r] for r in ref_structs]\\n ref_xyz = np.array(reff)\\n except IOError:\\n raise IOError(\\n \\\"Please provide a reference file named {} in {}\\\".format(\\n refname, str((self.parent / cwd).absolute())\\n )\\n )\\n\\n except ValueError:\\n raise ValueError(\\n \\\"Please check the values for the file named {} in {}\\\".format(\\n refname, str((self.parent / cwd).absolute())\\n )\\n )\\n\\n fname = refname[4:]\\n structs = []\\n with open(self.tmp_dir / fname) as f:\\n natoms = int(f.readline())\\n for s, ll in enumerate(f.readlines()):\\n if (s + 1) % (natoms + 2) != 0 and (s + 1) % (natoms + 2) != 1:\\n structs.append(ll.split()[1:])\\n testt = [[float(v) for v in r] for r in structs]\\n test_xyz = np.array(testt)\\n\\n try:\\n np.testing.assert_allclose(\\n test_xyz, ref_xyz, rtol=1.0e-7, atol=1.0e-8\\n )\\n # print(\\\"No anomaly during the regtest for {}\\\".format(refname))\\n except AssertionError:\\n raise AssertionError(\\n \\\"ANOMALY: {} in {}\\\".format(\\n fname,\\n str((self.parent / cwd).absolute()).split(\\\"ipi_tests/\\\", 1)[\\n 1\\n ],\\n )\\n )\",\n \"def compare_river_directions_with_dynriver_corrs_and_MERIThydro_derived_corrs_original_ts(self):\\n ref_base_dir = (\\\"/Users/thomasriddick/Documents/data/lake_analysis_runs\\\"\\n \\\"/lake_analysis_one_21_Jun_2021\\\")\\n data_base_dir = (\\\"/Users/thomasriddick/Documents/data/lake_analysis_runs/\\\"\\n \\\"lake_analysis_two_26_Mar_2022\\\")\\n ref_filename=os.path.join(ref_base_dir,\\n \\\"rivers/results/default_orog_corrs/diag_version_29_date_0_original_truesinks\\\",\\n \\\"30min_flowtocell.nc\\\")\\n data_filename=os.path.join(data_base_dir,\\n \\\"rivers/results/diag_version_0_date_0_original_truesinks\\\",\\n \\\"30min_flowtocell.nc\\\")\\n lsmask_filename=os.path.join(self.plots_data_dir,\\n \\\"ls_mask_extract_ls_mask_from_corrected_HD_rdirs_20160504_142435.nc\\\")\\n ref_catchment_filename=os.path.join(ref_base_dir,\\n \\\"rivers/results/default_orog_corrs/diag_version_29_date_0_original_truesinks\\\",\\n \\\"30min_catchments.nc\\\")\\n data_catchment_filename=os.path.join(data_base_dir,\\n \\\"rivers/results/diag_version_0_date_0_original_truesinks\\\",\\n \\\"30min_catchments.nc\\\")\\n ref_rdirs_filename=os.path.join(ref_base_dir,\\n \\\"rivers/results/default_orog_corrs/\\\"\\n \\\"diag_version_29_date_0_original_truesinks\\\",\\n \\\"30min_rdirs.nc\\\")\\n reference_rmouth_outflows_filename=os.path.join(ref_base_dir,\\n \\\"rivers/results/default_orog_corrs/\\\"\\n \\\"diag_version_29_date_0_original_truesinks\\\",\\n \\\"30min_rmouth_flowtocell.nc\\\")\\n data_rmouth_outflows_filename=os.path.join(data_base_dir,\\n \\\"rivers/results/diag_version_0_date_0_original_truesinks\\\",\\n \\\"30min_rmouth_flowtocell.nc\\\")\\n #glacier_mask_filename=os.path.join(self.orog_data_directory,\\\"ice5g_v1_2_21_0k_10min.nc\\\")\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n ref_catchment_filename,\\n data_catchment_filename=\\\\\\n data_catchment_filename,\\n ref_rdirs_filename=\\\\\\n ref_rdirs_filename,\\n data_rdirs_filename=None,\\n reference_rmouth_outflows_filename=\\\\\\n reference_rmouth_outflows_filename,\\n data_rmouth_outflows_filename=\\\\\\n data_rmouth_outflows_filename,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=80,\\n flip_data=False,\\n rotate_data=False,\\n flip_ref=False,\\n rotate_ref=False,\\n lsmask_has_same_orientation_as_ref=False,\\n flip_lsmask=False,rotate_lsmask=False,\\n invert_ls_mask=False,\\n first_datasource_name=\\\"old\\\",\\n second_datasource_name=\\\"MERIT derived\\\",\\n matching_parameter_set='default',\\n catchment_and_outflows_mods_list_filename=\\\\\\n None,\\n #additional_matches_list_filename=\\\\\\n #\\\"additional_matches_ice6g_vs_ice5g_lgm.txt\\\",\\n use_single_color_for_discrepancies=True,\\n use_only_one_color_for_flowmap=False,\\n use_title=False,remove_antartica=True,\\n difference_in_catchment_label=\\\"Difference\\\",\\n grid_type='HD')\",\n \"def completeness(input_sources_cat,detected_sources_cat,output_fname,cat_falsedet,Mag_lim,pix_radius):\\n\\n #Load catalogues in table\\n input_cat=ascii.read('%s.txt' % input_sources_cat)\\n detected_cat=ascii.read('%s.cat' % detected_sources_cat) \\n #print (input_cat)\\n #print (detected_cat)\\n print ('Number of sources in stuff catalog below the mag lim of %.2f: %d' % (Mag_lim,len(input_cat[input_cat['MAG']<Mag_lim])))\\n print ('Number of sources detected: %d \\\\n' % len(detected_cat))\\n\\n #Pixel radius\\n pixradius=pix_radius\\n\\n nb=0\\n i=0\\n det=np.zeros(len(input_cat))\\n x_det_list=np.zeros(len(input_cat))\\n y_det_list=np.zeros(len(input_cat))\\n mag_sex=np.zeros(len(input_cat))\\n\\n col_det=Column(name='detected',data=det)\\n x_det_coord=Column(name='x_coord_det',data=x_det_list)\\n y_det_coord=Column(name='y_coord_det',data=y_det_list)\\n mag_det=Column(name='mag_det',data=mag_sex)\\n input_cat.add_columns([col_det,x_det_coord,y_det_coord,mag_det])\\n\\n col_det_sex=Column(name='detected',data=np.zeros(len(detected_cat)))\\n detected_cat.add_columns([col_det_sex])\\n\\n\\n for x1, y1 in zip (detected_cat['XPEAK_IMAGE'], detected_cat['YPEAK_IMAGE']):\\n #print ('object n. {0:d} at position: {1:.2f}-{2:.2f} \\\\n'.format(nb,x1,y1))\\n min_dist=1e40\\n j=0\\n x_det=-1;y_det=-1;\\n for x2,y2,mag in zip(input_cat['COORD_XPIXEL'],input_cat['COORD_YPIXEL'],input_cat['MAG']):\\n if detected_cat['detected'][i]==0 and x1 >= int(x2)-pixradius and x1 <= int(x2)+pixradius and y1 >= int(y2)-pixradius and y1 <= int(y2)+pixradius:\\n #Test the minimum distance\\n dist=(x2-x1)**2+(y2-y1)**2\\n if dist < min_dist:# and detected_cat['MAG_AUTO'][i] > 0.9*mag and detected_cat['MAG_AUTO'][i] < 1.1*mag:\\n min_dist=dist\\n x_det=x1\\n y_det=y1\\n mag_det=detected_cat['MAG_AUTO'][i]\\n index=j\\n j+=1\\n if min_dist<1e40:\\n nb+=1\\n detected_cat['detected'][i]=1\\n #print ('Matched sources n. {0:d} at position: {1:.2f}-{2:.2f} \\\\n'.format(i,x_det,y_det))\\n input_cat['detected'][index]=1\\n input_cat['x_coord_det'][index]=x_det\\n input_cat['y_coord_det'][index]=y_det\\n input_cat['mag_det'][index]=mag_det\\n else:\\n detected_cat['detected'][i]=-1\\n #print ('Matched sources n. {0:d} at position: {1:.2f}-{2:.2f} \\\\n'.format(i,x_det,y_det))\\n\\n i+=1\\n\\n\\n \\\"\\\"\\\"\\n for x1,y1 in zip(input_cat['COORD_YPIXEL'],input_cat['COORD_XPIXEL']):\\n nb+=1\\n #print ('object n. {0:d} at position: {1:.2f}-{2:.2f} \\\\n'.format(nb,x1,y1))\\n min_dist=1e40\\n x_det=-1;y_det=-1;\\n j=0\\n for x2, y2 in zip (detected_cat['XPEAK_IMAGE'], detected_cat['YPEAK_IMAGE']):\\n if detected_cat['detected'][j]==0 and x2 >= int(x1)-pixradius and x2 <= int(x1)+pixradius and y2 >= int(y1)-pixradius and y2 <= int(y1)+pixradius:\\n #Test the minimum distance\\n dist=(x2-x1)**2+(y2-y1)**2\\n if dist < min_dist:\\n min_dist=dist\\n x_det=x2\\n y_det=y2\\n mag_det=detected_cat['MAG_AUTO'][j]\\n index=j\\n j+=1\\n \\n if min_dist<1e40:\\n i+=1\\n detected_cat['detected'][index]=1\\n #print ('Matched sources n. {0:d} at position: {1:.2f}-{2:.2f} \\\\n'.format(i,x_det,y_det))\\n input_cat['detected'][nb-1]=1\\n input_cat['x_coord_det'][nb-1]=x_det\\n input_cat['y_coord_det'][nb-1]=y_det\\n input_cat['mag_det'][nb-1]=mag_det\\n \\\"\\\"\\\"\\n #Cross match catalog\\n print ('Number of sources matched in both catalogs: %d' % nb)\\n\\n #Write output file\\n ascii.write(input_cat,'%s.txt' % output_fname)\\n\\n\\n\\n x_false_list=detected_cat['XPEAK_IMAGE'][detected_cat['detected']==-1]\\n y_false_list=detected_cat['YPEAK_IMAGE'][detected_cat['detected']==-1]\\n mag_sex=detected_cat['MAG_AUTO'][detected_cat['detected']==-1]\\n\\n #x_det_coord=Column(name='x_coord',data=x_det_list)\\n #y_det_coord=Column(name='y_coord',data=y_det_list)\\n #mag_det=Column(name='mag_det',data=mag_sex)\\n false_det_cat=Table([x_false_list,y_false_list,mag_sex],names=('x_coord','y_coord','mag_det'))\\n\\n\\n #Write false detections in a separated file\\n ascii.write(false_det_cat,'%s.txt' % cat_falsedet)\",\n \"def test_mock_spec():\\n\\n # try fitting a mock spectrum which you know has a match in the model grid\\n lam_obs, flam_obs, ferr_obs, mock_lsf = get_mock_spec()\\n\\n # read in entire model set\\n bc03_all_spec = fits.open(figs_dir + 'all_comp_spectra_bc03_ssp_and_csp_nolsf_noresample.fits')\\n\\n # prep for fitting\\n total_models = 34542 # if ssp + csp\\n\\n # arrange the model spectra to be compared in a properly shaped numpy array for faster computation\\n # first check where the models are\\n model_dir = '/Volumes/Bhavins_backup/bc03_models_npy_spectra/m62/'\\n # this is if working on the laptop. Then you must be using the external hard drive where the models are saved.\\n if not os.path.isdir(model_dir):\\n model_dir = home + '/Documents/GALAXEV_BC03/bc03/src/cspout_new/m62/' # this path only exists on firstlight\\n if not os.path.isdir(model_dir):\\n print \\\"Model files not found. Exiting...\\\"\\n sys.exit(0)\\n\\n example_filename_lamgrid = 'bc2003_hr_m62_tauV0_csp_tau100_salp_lamgrid.npy'\\n model_lam_grid = np.load(model_dir + example_filename_lamgrid)\\n model_comp_spec = np.zeros([total_models, len(model_lam_grid)], dtype=np.float64)\\n for j in range(total_models):\\n model_comp_spec[j] = bc03_all_spec[j+1].data\\n\\n # total run time up to now\\n print \\\"All models put in numpy array. Total time taken up to now --\\\", time.time() - start, \\\"seconds.\\\"\\n\\n # now call the actual fitting function\\n mock_redshift_estimate = 1.0 # this behaves like the photo-z\\n\\n # extend lam_grid to be able to move the lam_grid later \\n avg_dlam = old_ref.get_avg_dlam(lam_obs)\\n\\n lam_low_to_insert = np.arange(5000, lam_obs[0], avg_dlam)\\n lam_high_to_append = np.arange(lam_obs[-1] + avg_dlam, 10500, avg_dlam)\\n\\n resampling_lam_grid = np.insert(lam_obs, obj=0, values=lam_low_to_insert)\\n resampling_lam_grid = np.append(resampling_lam_grid, lam_high_to_append)\\n\\n # call actual fitting function\\n do_fitting(flam_obs, ferr_obs, lam_obs, mock_lsf, mock_redshift_estimate, resampling_lam_grid, \\\\\\n model_lam_grid, total_models, model_comp_spec, bc03_all_spec)\\n\\n # total time\\n print \\\"Total time taken up to now --\\\", time.time() - start, \\\"seconds.\\\"\\n sys.exit(0)\\n\\n return None\",\n \"def data_vis():\\n dataroot = 'solar_data.txt'\\n debug = False \\n diff = False\\n X, y = read_data(dataroot, debug, diff)\\n\\n # First plot the original timeseries\\n fig = plt.figure(figsize=(40,40))\\n\\n fig.add_subplot(3,3,1)\\n plt.plot(y)\\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,2)\\n plt.plot(X[:,0])\\n plt.title('Avg Zenith Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,3)\\n plt.plot(X[:,1])\\n plt.title('Avg Azimuth Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,4)\\n plt.plot(X[:,2])\\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,5)\\n plt.plot(X[:,3])\\n plt.title('Avg Tower RH [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,6)\\n plt.plot(X[:,4])\\n plt.title('Avg Total Cloud Cover [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,7)\\n plt.plot(X[:,5])\\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\\n # plt.show()\\n\\n ##########################################################################################\\n # Plotting the Fourier Transform of the signals\\n\\n freq = np.fft.fftfreq(len(y), 1*60*60)\\n\\n fig = plt.figure(figsize=(40,40))\\n\\n fig.add_subplot(3,3,1)\\n plt.plot(freq, np.abs(np.fft.fft(y)))\\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,2)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,0])))\\n plt.title('Avg Zenith Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,3)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,1])))\\n plt.title('Avg Azimuth Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,4)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,2])))\\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,5)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,3])))\\n plt.title('Avg Tower RH [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,6)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,4])))\\n plt.title('Avg Total Cloud Cover [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,7)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,5])))\\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\\n # plt.show()\\n\\n ##################################################################################################\\n # Print correlation matrix\\n\\n df = pd.DataFrame(np.c_[y, X])\\n df.columns = ['Avg Global PSP (vent/cor) [W/m^2]','Avg Zenith Angle [degrees]','Avg Azimuth Angle [degrees]','Avg Tower Dry Bulb Temp [deg C]','Avg Tower RH [%]','Avg Total Cloud Cover [%]','Avg Avg Wind Speed @ 6ft [m/s]']\\n f = plt.figure(figsize=(19, 15))\\n plt.matshow(df.corr(), fignum=f.number)\\n plt.xticks(range(df.shape[1]), df.columns, fontsize=14, rotation=20)\\n plt.yticks(range(df.shape[1]), df.columns, fontsize=14)\\n cb = plt.colorbar()\\n cb.ax.tick_params(labelsize=14)\\n plt.title('Correlation Matrix', fontsize=16);\\n plt.show()\",\n \"def diff_mat(fmin, fmax, mat_dir=None, ROI_labels=None,\\n incon_event=['LRst', 'RLst'], con_event=['LLst', 'RRst']):\\n\\n fn_con1 = mat_dir + '/%s_%d_%dHz.npy' % (con_event[0], fmin, fmax)\\n fn_con2 = mat_dir + '/%s_%d_%dHz.npy' % (con_event[1], fmin, fmax)\\n fn_incon1 = mat_dir + '/%s_%d_%dHz.npy' % (incon_event[0], fmin, fmax)\\n fn_incon2 = mat_dir + '/%s_%d_%dHz.npy' % (incon_event[1], fmin, fmax)\\n am_ROI = len(ROI_labels)\\n con_cau1 = np.load(fn_con1)\\n con_cau2 = np.load(fn_con2)\\n con_cau = con_cau1 + con_cau2\\n incon_cau = np.load(fn_incon1) + np.load(fn_incon2)\\n con_cau[con_cau > 0] = 1\\n incon_cau[incon_cau > 0] = 1\\n dif_cau = incon_cau - con_cau\\n dif_cau[dif_cau < 0] = 0\\n com_cau = incon_cau - dif_cau\\n com_cau[com_cau < 0] = 0\\n fn_dif = mat_dir + '/incon_con_%d-%dHz.npy' % (fmin, fmax)\\n fn_com = mat_dir + '/com_incon_con_%d-%dHz.npy' % (fmin, fmax)\\n fig_dif = mat_dir + '/incon_con_%d-%dHz.png' % (fmin, fmax)\\n plt.matshow(dif_cau, interpolation='nearest')\\n plt.xticks(np.arange(am_ROI), ROI_labels, fontsize=9, rotation='vertical')\\n plt.yticks(np.arange(am_ROI), ROI_labels, fontsize=9)\\n # pl.tight_layout(pad=2)\\n # pl.show()\\n plt.savefig(fig_dif, dpi=300)\\n plt.close()\\n np.save(fn_dif, dif_cau)\\n np.save(fn_com, com_cau)\\n # print len(np.argwhere(dif_cau))\",\n \"def detail_matching(self):\\n paradic = self.cfg['param']['paradic']\\n work_dir = self.work_dir\\n \\n x = float(self.cfg['param']['x']) # selected pixel in the first image\\n y = float(self.cfg['param']['y'])\\n \\n # sift parameters\\n # number of bins in the orientation histogram\\n n_bins = int(paradic['n_bins']) \\n n_hist = int(paradic['n_hist']) \\n # descriptor of n_hist X n_hist weighted histograms with n_ori\\n n_ori = int(paradic['n_ori']) \\n delta_min = float(paradic['delta_min'])\\n sigma_min = float(paradic['sigma_min'])\\n sigma_in = float(paradic['sigma_in'])\\n lambda_ori = float(paradic['lambda_ori'])\\n lambda_descr = float(paradic['lambda_descr'])\\n #threshold defining reference orientations\\n n_spo = int(paradic['n_spo'])\\n \\n # Read feature vectors from output files\\n if (os.path.getsize(work_dir+'OUTmatches.txt') > 0 ):\\n pairdata = find_nearest_keypoint(work_dir+'OUTmatches.txt', y, x)\\n \\n illustrate_pair(pairdata, n_bins, n_hist, n_ori, work_dir)\\n\\n \\n # Read keys coordinates.\\n d = 6+n_bins+n_hist*n_hist*n_ori # size of keydata inside pairdata\\n v = n_hist*n_hist*n_ori\\n [x1, y1, sigma1, theta1] = [float(x) for x in pairdata[0:4]]\\n [o1, s1] = [float(x) for x in pairdata[4+v:4+v+2]]\\n [x2a, y2a, sigma2a, theta2a] = [float(x) for x in pairdata[d:d+4]]\\n [o2a, s2a] = [float(x) for x in pairdata[d+4+v:d+4+v+2]]\\n [x2b, y2b, sigma2b, theta2b] = \\\\\\n [float(x) for x in pairdata[2*d:2*d+4]]\\n [o2b, s2b] = [float(x) for x in pairdata[2*d+4+v:2*d+4+v+2]]\\n \\n draw_one_match(pairdata,\\n work_dir+'input_0.png',\\n work_dir+'input_1.png',\\n d,\\n lambda_ori,\\n lambda_descr,\\n n_hist,\\n work_dir+'OUTonepair.png')\\n \\n \\n # Extract thumbnails.\\n # keypoint 1 (image 1)\\n print ' '.join(['demo_extract_patch', work_dir+'input_0.png',\\n str(x1), str(y1), str(sigma1), str(theta1), str(o1), str(s1),\\n str(delta_min), str(sigma_min), str(sigma_in), str(n_spo),\\n str(lambda_ori), str(lambda_descr), str(n_hist),\\n work_dir+\\\"detail_im1\\\"])\\n proc = self.run_proc(['demo_extract_patch', work_dir+'input_0.png',\\n str(x1), str(y1), str(sigma1), str(theta1), str(o1), str(s1),\\n str(delta_min), str(sigma_min), str(sigma_in), str(n_spo),\\n str(lambda_ori), str(lambda_descr), str(n_hist),\\n work_dir+\\\"detail_im1\\\"])\\n self.wait_proc(proc, timeout=self.timeout)\\n \\n # keypoint 2a (nearest neighbor in image 2)\\n print ' '.join(['demo_extract_patch', work_dir+'input_1.png',\\n str(x2a), str(y2a), str(sigma2a), str(theta2a), str(o2a), str(s2a),\\n str(delta_min), str(sigma_min), str(sigma_in), str(n_spo),\\n str(lambda_ori), str(lambda_descr), str(n_hist),\\n work_dir+\\\"detail_im2a\\\"])\\n proc = self.run_proc(['demo_extract_patch', work_dir+'input_1.png',\\n str(x2a), str(y2a), str(sigma2a), str(theta2a), str(o2a), str(s2a),\\n str(delta_min), str(sigma_min), str(sigma_in), str(n_spo),\\n str(lambda_ori), str(lambda_descr), str(n_hist),\\n work_dir+\\\"detail_im2a\\\"])\\n self.wait_proc(proc, timeout=self.timeout) \\n \\n # keypoint 2b (second nearest neighbor in image 2)\\n proc = self.run_proc(['demo_extract_patch', work_dir+'input_1.png',\\n str(x2b), str(y2b), str(sigma2b), str(theta2b), str(o2b), str(s2b),\\n str(delta_min), str(sigma_min), str(sigma_in), str(n_spo),\\n str(lambda_ori), str(lambda_descr), str(n_hist),\\n work_dir+\\\"detail_im2b\\\"])\\n self.wait_proc(proc, timeout=self.timeout) \\n \\n \\n return 1\",\n \"def decode_plot(model,datapath,img_size=100,vae=False,compare=False,adjust=False,discrepancy=0.1):\\n target = set_creation(datapath,img_size=img_size,nrand=5,adjust=adjust)\\n model.eval()\\n out, _ = model(target.float())\\n plt.style.use('seaborn')\\n plt.figure(figsize=(14,6*(1+int(compare))),dpi=80)\\n for i in range(5):\\n # Load and plot original image\\n ax1 = plt.subplot(2*(1+int(compare)),5,i+1)\\n ax1.imshow(target[i][0],cmap='viridis')\\n ax1.set_title('Original image')\\n normout = out[i][0]-out[i][0].min()\\n normout = normout/normout.max()\\n # Plot decoded image\\n ax2 = plt.subplot(2*(1+int(compare)),5,6+i)\\n ax2.imshow(normout.data,cmap='viridis')\\n ax2.set_title('Decoded image'+(' (reference)' if i==0 and compare else ''))\\n if compare:\\n diff = normout-target[i][0]\\n accuracy = len(diff[numpy.array(abs(diff)<discrepancy)])/args.img_size**2*100\\n # Plot difference between decoded and original image\\n ax3 = plt.subplot(4,5,11+i)\\n ax3.imshow((normout-target[i][0]).data,cmap='seismic',vmin=-1,vmax=1)\\n ax3.set_title('%.2f%% accuracy'%accuracy)\\n # Plot difference between decoded and reference images\\n if i==0:\\n refout = normout\\n ax4 = plt.subplot(4,5,16+i)\\n ax4.imshow(abs(normout-refout).data,cmap='OrRd')\\n ax4.set_title('Decoded - Reference')\\n plt.tight_layout()\\n plt.show()\",\n \"def report_sim_difference(sim0: rebound.Simulation, sim1: rebound.Simulation, \\n object_names: List[str], verbose: bool=False) -> \\\\\\n Tuple[np.array, np.array]:\\n # Extract configuration arrays for the two simulations\\n cfg0: np.array = sim_cfg_array(sim0, object_names)\\n cfg1: np.array = sim_cfg_array(sim1, object_names)\\n \\n # Convert both arrays to heliocentric coordinates\\n cfg0 = cfg0 - cfg0[0:1,:]\\n cfg1 = cfg1 - cfg1[0:1,:]\\n\\n # Displacement of each body to earth\\n earth_idx: int = object_names.index('Earth')\\n q0: np.array = cfg0[:, 0:3] - cfg0[earth_idx, 0:3]\\n q1: np.array = cfg1[:, 0:3] - cfg1[earth_idx, 0:3]\\n \\n # Right Ascension and Declination\\n r0, asc0, dec0 = cart_to_sph(q0)\\n r1, asc1, dec1 = cart_to_sph(q1)\\n\\n # Error in asc and dec; convert from radians to arcseconds\\n asc_err: np.array = np.degrees(np.abs(asc1-asc0)) * 3600\\n dec_err: np.array = np.degrees(np.abs(dec1-dec0)) * 3600\\n\\n # Take differences\\n cfg_diff: np.array = (cfg1 - cfg0)\\n pos_diff: np.array = cfg_diff[:, 0:3]\\n vel_diff: np.array = cfg_diff[:, 3:6]\\n\\n # Error in position and velocity in heliocentric coordinates; skip the sun\\n pos_err: np.array = np.linalg.norm(pos_diff, axis=1)\\n pos_err_den: np.array = np.linalg.norm(cfg0[:, 0:3], axis=1)\\n pos_err_den[0] = 1.0\\n pos_err_rel: np.array = pos_err / pos_err_den\\n vel_err: np.array = np.linalg.norm(vel_diff, axis=1)\\n vel_err_den: np.array = np.linalg.norm(cfg0[:, 3:6], axis=1)\\n vel_err_den[0] = 1.0\\n vel_err_rel: np.array = vel_err / vel_err_den\\n\\n if verbose:\\n print(f'\\\\nPosition difference - absolute & relative')\\n print(f'(Angle errors in arcseconds, position in AU)')\\n print(f'Body : Phi : Theta : Pos AU : Pos Rel : Vel Rel')\\n object_names_short: List[str] = [nm.replace(' Barycenter', '') for nm in object_names]\\n for i, nm in enumerate(object_names_short):\\n print(f'{nm:10} : {asc_err[i]:5.2e}: {dec_err[i]:5.2e}: {pos_err[i]:5.2e}: '\\n f'{pos_err_rel[i]:5.2e}: {vel_err_rel[i]:5.2e}')\\n print(f'Overall : {rms(asc_err):5.2e}: {rms(dec_err):5.2e}: {rms(pos_err):5.2e}: '\\n f'{rms(pos_err_rel):5.2e}: {rms(vel_err_rel):5.2e}')\\n\\n # Extract orbital element arrays from the two simulations\\n elt0: np.array = sim_elt_array(sim0, object_names[1:])\\n elt1: np.array = sim_elt_array(sim1, object_names[1:])\\n\\n # Take differences\\n elt_diff: np.array = (elt1 - elt0)\\n # Angle differences are mod two pi\\n two_pi: float = 2.0 * np.pi\\n elt_diff[:,2:] = (elt_diff[:,2:] +np.pi ) % two_pi - np.pi\\n \\n # Compute RMS difference by orbital element\\n elt_rms: np.array = rms(elt_diff, axis=0)\\n elt_err: np.array = np.abs(elt_diff)\\n\\n # Names of selected elements\\n elt_names: List[str] = ['a', 'e', 'inc', 'Omega', 'omega', 'f', 'M', 'pomega', 'long']\\n\\n # Report RMS orbital element differences\\n if verbose:\\n print(f'\\\\nOrbital element errors:')\\n print(f'elt : RMS : worst : max_err : HRZN : REB')\\n for j, elt in enumerate(elt_names):\\n idx = np.argmax(elt_err[:, j])\\n worse = object_names_short[idx+1]\\n print(f'{elt:6} : {elt_rms[j]:5.2e} : {worse:10} : {elt_err[idx, j]:5.2e} : '\\n f'{elt0[idx, j]:11.8f} : {elt1[idx, j]:11.8f}')\\n print(f'RMS (a, e, inc) = {rms(elt_diff[:,0:3]):5.2e}')\\n print(f'RMS (f, M, pomega, long) = {rms(elt_diff[:,5:9]):5.2e}') \\n\\n # One summary error statistic\\n ang_err: np.array = rms(np.array([asc_err, dec_err]))\\n \\n # Return the RMS position error and angle errors\\n return pos_err, ang_err\",\n \"def avCDNC(CL,abovesize=nan,uppersize=nan,inst=\\\"FSSP96\\\",scan=0):\\n if len(CL.times[\\\"verticloud\\\"])<=scan:\\n print(\\\"[avCDNC] No vertical scan for this cloud.\\\")\\n return nan\\n else:\\n ts=CL.times[\\\"verticloud\\\"][scan] # times of the vertical scan\\n pos=[i for i,x in enumerate(CL.sd) if inst.lower() in x[\\\"Distname\\\"].lower()]; \\n if len(pos)<=0: cancel=1; raise ValueError(\\\"This instrument name has not been found (inst=%s).\\\" % inst)\\n else: pos=pos[0]\\n calt=[i for i,x in enumerate(CL.dttl) if x == 'altitude']; calt=calt[0]\\n ctim=[i for i,x in enumerate(CL.dttl) if x == 'time']; ctim=ctim[0]\\n alt=CL.data[calt]\\n tim=CL.data[ctim]\\n clwc=[i for i,x in enumerate(CL.dttl) if x == 'LWC']; \\n if len(clwc)>1: print(\\\"[avCDNC] Multiple LWC found.\\\"); lwc=np.ones((2,))*NaN; lwctime=ts # LWC found in the basic data\\n elif len(clwc)==1: lwc=CL.data[clwc[0]]; lwctime=tim; \\n else: # looking for LWC in the extradata\\n posx=[] \\n for i,L in enumerate(CL.extrattl): # for all extra datasets available\\n posx=posx+[[i,j] for j,x in enumerate(L) if x.lower() == 'lwc'] # check all titles matching with LWC\\n if len(posx)==1: \\n lwc=CL.extradata[posx[0][0]][posx[0][1]] # loading the LWC data\\n j=[j for j,x in enumerate(CL.extrattl[i]) if x.lower() == 'time'][0]\\n lwctime=CL.extradata[posx[0][0]][j] # loading associated time stamp\\n else: print(\\\"[avCDNC] No LWC (or multiple) was found in the basic data or the extra data.\\\"); return nan\\n \\n \\n timtc=CL.sd[pos][\\\"time\\\"] # time corresponding to the concentration tc\\n # find shortest common time stamp\\n ta1=np.max([lwctime[0],tim[0],timtc[0],ts[0]]); ta2=np.min([lwctime[-1],tim[-1],timtc[-1],ts[1]]); \\n taix=[nonzero((timtc>=ta1)*(timtc<=ta2))[0]]; \\n usedtime=timtc[taix]\\n if len(usedtime)==0: WA=nan # weighted average is not calculable (no data for the vertical scan)\\n else:\\n tc=samac.dNdlogDp2N(CL.sd[pos],abovesize,uppersize)[taix] # total concentration between above- and upper-size\\n test=tim.__array__()==timtc\\n if len(tim)==len(timtc): \\n if (tim.__array__()==timtc).all()==True: alt=alt[taix]\\n else:\\n print(\\\"[avCDNC] nonequal times (although same length): altitude was interpolated.\\\")\\n # interpolating on size distribution data.\\n falt=interpolate.interp1d(tim,alt,kind='linear') \\n alt=falt(usedtime); \\n else:\\n print(\\\"[avCDNC] nonequal times: altitude was interpolated.\\\")\\n # interpolating on size distribution data.\\n falt=interpolate.interp1d(tim,alt,kind='linear') \\n alt=falt(usedtime); \\n if len(lwctime)==len(timtc):\\n if (lwctime.__array__()==timtc).all()==True: lwc=lwc[taix]\\n else: flwc=interpolate.interp1d(lwctime,lwc,kind='linear'); lwc=flwc(usedtime)\\n # integrating\\n dalt=np.diff(alt);\\n lwc=lwc[1:];\\n tc=tc[1:];\\n WA=abs(sum(tc*lwc*dalt))/(samac.lwp(CL)[scan][0]) # if inst conc is cm-3 (cm-3 lwc*meters / lwc*meters = cm-3)\\n return WA\",\n \"def visitspec(load,plate,mjd,fiber,gridfile='apg_rvsynthgrid',apstar=False) :\\n grid = fits.open(os.environ['APOGEE_DIR']+'/data/synthgrid/'+gridfile+'.fits')\\n if gridfile == 'apg_rvsynthgrid' : hdu=1\\n elif gridfile == 'apg_rvsynthgrid_v2': hdu=0\\n elif apstar : hdu=2\\n else : hdu=1\\n gridspec=grid[hdu].data\\n gridwave = 10.**spectra.fits2vector(grid[hdu].header,2)\\n griderr = np.ones(gridspec.shape[0])\\n #for ispec in range(gridspec.shape[1]) :\\n # cont = norm.cont(gridspec[:,ispec],griderr)\\n # gridspec[:,ispec] /= cont\\n\\n data = load.apVisit(plate,mjd,fiber)\\n\\n # compare with DR14 \\n comp(a,b,domatch=False,out='plots/dr14all')\\n grid.append(['dr14all_1.png',''])\\n xtit.append('all stars: DR14 (dotted) and test DR16 (solid)')\\n\\n comp(a,b,domatch=True,out='plots/dr14match')\\n grid.append(['dr14match_1.png','dr14match_2.png'])\\n xtit.append('same stars: DR14 (dotted) and test DR16 (solid)')\\n # set bad pixels to nan\\n shape=data[1].data.shape\\n spec = copy.copy(data[1].data).flatten()\\n specerr = copy.copy(data[2].data)\\n specwave=data[4].data\\n pixmask=bitmask.PixelBitMask()\\n bd = np.where( ((data[3].data & pixmask.badval()) > 0) | \\n ((data[3].data & pixmask.getval('SIG_SKYLINE')) > 0) ) [0]\\n spec[bd] = np.nan\\n spec = spec.reshape(shape)\\n\\n # continuum normalize and sample to grid\\n outspec = np.full(len(gridwave),np.nan)\\n if not apstar :\\n # apVisit wavelengths are reversed\\n spec=np.flip(spec)\\n specwave=np.flip(specwave)\\n specerr=np.flip(specerr)\\n for ichip in range(3) :\\n cont = norm.cont(spec[ichip,:],specerr[ichip,:])\\n spec[ichip,:] /= cont\\n gd=np.where(np.isfinite(spec[ichip,:]))[0]\\n ip= interpolate.InterpolatedUnivariateSpline(specwave[ichip,gd],spec[ichip,gd],k=3)\\n out = ip(gridwave)\\n gd = np.where( (gridwave > specwave[ichip,0]) & (gridwave < specwave[ichip,-1]) )[0]\\n outspec[gd] = out[gd]\\n plt.plot(specwave[ichip,:],spec[ichip,:])\\n plt.plot(gridwave[gd],out[gd])\\n plt.show()\\n\\n for ispec in range(gridspec.shape[1]) :\\n print(ispec)\\n bd=np.where(np.isnan(outspec))\\n outspec[bd]=1.\\n out=correlate(outspec,gridspec[:,ispec])\\n pdb.set_trace()\",\n \"def extract_relevant_data( case_list = [], exceptions = [], y_delta_locs = [],\\n x_2h_locs = [] , plot = False, output_root = '',\\n overwrite = False, just_plot = False ):\\n\\n from os import listdir\\n from os.path import join,split,isfile\\n from pandas import DataFrame, HDFStore\\n from boundary_layer_routines import return_bl_parameters\\n from progressbar import ProgressBar,Percentage\\n from progressbar import Bar,ETA,SimpleProgress\\n from numpy import array, round, linspace, nan, sign\\n from data_cleaning_routines import show_surface_from_df\\n\\n x_2h_locs = round( array( x_2h_locs ), 2 )\\n y_delta_locs = round( array( y_delta_locs ), 2 )\\n\\n if not output_root:\\n output_root = '/media/carlos/6E34D2CD34D29783/' +\\\\\\n '2015-02_SerrationPIV/TR_Data_Location_Calibrated_Article3'\\n\\n # Get the available HDF5 files #############################################\\n hdf5_root = '/media/carlos/6E34D2CD34D29783/' +\\\\\\n '2015-02_SerrationPIV/TR_Data_Location_Calibrated_Article3'\\n\\n if not len(case_list):\\n hdf5_files = [f for f in listdir( hdf5_root ) \\\\\\n if f.endswith('.hdf5') \\\\\\n and not f in exceptions ]\\n else:\\n hdf5_files = [f for f in listdir( hdf5_root ) \\\\\\n if f.endswith('.hdf5') \\\\\\n and f in case_list ]\\n # ##########################################################################\\n\\n for hf in [join( hdf5_root, f ) for f in hdf5_files]:\\n\\n suffix = '_AirfoilNormal'\\n\\n mean_flow_rotated = False\\n if hf.endswith(\\\"MeanFlowRotated.hdf5\\\"):\\n mean_flow_rotated = True\\n suffix = ('_MeanFlowRotated')\\n\\n f = split( hf )[1].replace(suffix,'')\\\\\\n .replace('_Aligned.hdf5','').replace('.hdf5','')\\n if mean_flow_rotated:\\n f = f + '_mfr'\\n\\n # Get the normalization locations depending on the case ################\\n if 'z00' in f and not 'STE' in f:\\n x_bl_loc = 38\\n elif 'z05' in f:\\n x_bl_loc = 18\\n elif 'z10' in f or 'STE' in f:\\n x_bl_loc = -2\\n\\n #if mean_flow_rotated:\\n # mean_flow_df = read_pickle( mean_flow_pickle )\\n # mean_flow_angle = mean_flow_df.T.ix[ \\n # f.replace('.hdf5','')\\n # ].ix[0].values[0]\\n\\n # yshift = - x_bl_loc * sin( radians( mean_flow_angle ) )\\n #else:\\n # yshift = 0\\n\\n print \\\" Processing {0}\\\".format( f )\\n if not overwrite and isfile( 'ReservedData/' + f + '.hdf5' ):\\n print \\\" File exists; skipping\\\"\\n continue\\n\\n\\n hdf_t = HDFStore( hf, 'r' )\\n\\n # Get the available coordinates ########################################\\n hf_coords = hdf_t.select('data', where = [ 't = 0' ], \\n columns = [ 'x', 'y' , 'u' ] )\\n # ######################################################################\\n\\n # Turn the non-dim requested locations into physical coords ############\\n requested_locations = []\\n requested_normalized_locations = []\\n #for x,x_norm in zip(x_2h_locs * tooth_length, x_2h_locs):\\n # for y_d in y_delta_locs:\\n # bl_params = return_bl_parameters( f , [x] )\\n # d_99 = bl_params.delta_99.values[0]\\n # #if \\\"STE\\\" in f:\\n # # d_99 = 9.4\\n # y = y_d * d_99\\n # requested_locations.append( (x,y) )\\n # requested_normalized_locations.append( ( x_norm, y_d ) )\\n\\n bl_params = return_bl_parameters( \\n f.replace( '_mfr', '' ) , \\n [x_bl_loc] )\\n d_99 = bl_params.delta_99.values[0]\\n\\n for x,x_norm in zip(x_2h_locs * tooth_length, x_2h_locs):\\n for y_d in y_delta_locs:\\n y = y_d * d_99\\n requested_locations.append( (x,y) )\\n requested_normalized_locations.append( ( x_norm, y_d ) )\\n print \\\" Normalizing to a BL thickness of {0:.2f} mm\\\".\\\\\\n format(d_99)\\n # ######################################################################\\n\\n hf_coords = hf_coords.replace( 0, nan )\\n hf_coords = hf_coords.dropna()\\n\\n min_x_real_loc = min( x_2h_locs ) * tooth_length\\n max_x_real_loc = max( x_2h_locs ) * tooth_length\\n\\n # This is the max y location for a full square in the rotated FoV ######\\n max_y_field_of_view = min(\\n hf_coords[ \\n ( hf_coords.x < max_x_real_loc * 1.1 ) & \\\\\\n ( hf_coords.x > max_x_real_loc * 0.9 ) \\n ].y.max(),\\n\\n hf_coords[ \\n ( hf_coords.x < \\\\\\n min_x_real_loc * ( 1 + sign( min_x_real_loc ) * 0.1 ) ) & \\\\\\n ( hf_coords.x > \\\\\\n min_x_real_loc * ( 1 - sign( min_x_real_loc ) * 0.1 ) ) \\n ].y.max()\\n )\\n # ######################################################################\\n\\n # This is the minimum (and x_loc aligned) y location for a full square\\n # in the rotated FoV ###################################################\\n min_y_field_of_view = max(\\n hf_coords[ \\n ( hf_coords.x < \\\\\\n min_x_real_loc * ( 1 + sign( min_x_real_loc ) * 0.1 ) ) & \\\\\\n ( hf_coords.x > \\\\\\n min_x_real_loc * ( 1 - sign( min_x_real_loc ) * 0.1 ) ) \\n ].y.min(), \\n hf_coords[ \\n ( hf_coords.x < max_x_real_loc * 1.1 ) & \\\\\\n ( hf_coords.x > max_x_real_loc * 0.9 ) \\n ].y.min()\\n )\\n\\n # ######################################################################\\n\\n if max( y_delta_locs ) * d_99 < max_y_field_of_view:\\n max_y_loc = max( y_delta_locs ) * d_99\\n else:\\n max_y_loc = max_y_field_of_view\\n\\n if min( y_delta_locs ) * d_99 > min_y_field_of_view:\\n min_y_loc = min( y_delta_locs ) * d_99\\n else:\\n min_y_loc = min_y_field_of_view\\n\\n available_xy_locs = hf_coords[\\n ( hf_coords.x > min( x_2h_locs ) * 40. ) & \\\\\\n ( hf_coords.x < max( x_2h_locs ) * 40. ) & \\\\\\n ( hf_coords.y > min_y_loc ) & \\\\\\n ( hf_coords.y < max_y_loc )\\n ][ ['x','y'] ]\\n\\n if available_xy_locs.empty:\\n return 0\\n \\n available_xy_locs = [ tuple(x) for x in available_xy_locs.values ]\\n\\n #if mean_flow_rotated:\\n # y_correction = - x_bl_loc * sin( radians( mean_flow_angle ) )\\n\\n #if plot:\\n\\n # trailing_edge,phi,alpha,U,z = decript_case_name( f )\\n\\n # if trailing_edge == 'serrated': device = 'Sr20R21'\\n # elif trailing_edge == 'straight': device = 'STE'\\n # elif trailing_edge == 'slitted': device = 'Slit20R21'\\n\\n # case_name = \\\"{0}_phi{1}_alpha{2}_U{3}_loc{4}_tr.dat\\\".format(\\n # device, phi, alpha, U, z\\n # )\\n\\n # plot_name = ''\\n # if mean_flow_rotated:\\n # average_pickle_name = 'averaged_data/' + case_name + \\\\\\n # '_mean_flow_rotated.p'\\n # else:\\n # average_pickle_name = 'averaged_data/' + case_name + '.p'\\n # df_av = read_pickle( average_pickle_name )\\n\\n # if mean_flow_rotated:\\n # df_av.y = df_av.y - yshift\\n\\n # plot_name = 'ReservedData/' + f + '.png'\\n # show_surface_from_df( \\n # df_av , \\n # points = available_xy_locs ,\\n # plot_name = plot_name,\\n # point_correction = ( 0 , 0 )\\n # )\\n # if not plot_name:\\n # continue\\n\\n # Don't try to get it all at once; split the vertical in 4 pieces\\n vertical_split_blocks = 10\\n\\n y_ranges = linspace( \\n min_y_loc,\\n max_y_loc,\\n vertical_split_blocks\\n ) \\n\\n xmin = min(x_2h_locs) * tooth_length\\n xmax = max(x_2h_locs) * tooth_length\\n\\n print \\\" Extracting data from {0}\\\".format(f)\\n print \\\" at the streamwise locations:\\\",\\n print \\\" {0:.2f} to {1:.2f}\\\".format( xmin, xmax )\\n print \\\" at the wall-normal locations:\\\",\\n print \\\" {0:.2f} to {1:.2f}\\\".format( min_y_loc, max_y_loc )\\n\\n if plot:\\n query = \\\" x>={0} & x<{1} & y>={2} & y<{3} & t=0\\\".\\\\\\n format( xmin, xmax, min_y_loc, max_y_loc )\\n\\n df0 = hdf_t.select(\\n key = 'data',\\n where = [ query ],\\n )\\n\\n plot_name = 'ReservedData/' + f + '.png'\\n if mean_flow_rotated:\\n plot_name = plot_name.replace( '.png', '_mfr.png' )\\n\\n show_surface_from_df( \\n df0,\\n plot_name = plot_name,\\n point_correction = ( 0 , 0 )\\n )\\n if just_plot:\\n return 0\\n\\n query = ''\\n cnt_all = 0\\n\\n cnt = 0\\n time_series_hdf = HDFStore( 'ReservedData/' + f + '.hdf5', 'w' )\\n\\n progress = ProgressBar(\\n widgets=[\\n Bar(),' ',\\n Percentage(),' ',\\n ETA(), ' (query bunch ',\\n SimpleProgress(),')'], \\n maxval = vertical_split_blocks\\n ).start()\\n\\n for ymin, ymax in zip( y_ranges[:-1], y_ranges[1:] ):\\n\\n query = \\\" x>={0} & x<{1} & y>={2} & y<{3} \\\".\\\\\\n format( xmin, xmax, ymin, ymax )\\n\\n df_t = hdf_t.select(\\n key = 'data',\\n where = [ query ],\\n )\\n\\n df_t['near_x_2h'] = round( df_t.x / 40., 4 )\\n df_t['near_y_delta'] = round( df_t.y / d_99, 4 )\\n\\n # If it has been flow rotated, the zero y direction needs to be\\n # brought back to the location of the wall at the reference x\\n # location #########################################################\\n #if mean_flow_rotated:\\n # df_t.y = df_t.y - y_correction\\n # ##################################################################\\n # The translation now happens when pickling the raw data\\n\\n if not cnt:\\n time_series_hdf.put( 'data', df_t , \\n data_columns = [\\n 'near_x_2h',\\n 'near_y_delta',\\n 't'\\n ],\\n format = 't')\\n else:\\n time_series_hdf.append( 'data', df_t , \\n data_columns = [\\n 'near_x_2h',\\n 'near_y_delta',\\n 't'\\n ],\\n format = 't')\\n\\n cnt_all += 1\\n cnt += 1\\n\\n progress.update(cnt_all)\\n\\n df_t = DataFrame()\\n\\n\\n progress.finish()\\n hdf_t.close()\\n time_series_hdf.close()\",\n \"def test_jam_axi_rms():\\n np.random.seed(123)\\n xbin, ybin = np.random.uniform(low=[-55, -40], high=[55, 40], size=[1000, 2]).T\\n\\n inc = 60. # Assumed galaxy inclination\\n r = np.sqrt(xbin**2 + (ybin/np.cos(np.radians(inc)))**2) # Radius in the plane of the disk\\n a = 40 # Scale length in arcsec\\n vr = 2000*np.sqrt(r)/(r+a) # Assumed velocity profile\\n vel = vr * np.sin(np.radians(inc))*xbin/r # Projected velocity field\\n sig = 8700/(r+a) # Assumed velocity dispersion profile\\n rms = np.sqrt(vel**2 + sig**2) # Vrms field in km/s\\n\\n surf = np.array([39483., 37158., 30646., 17759., 5955.1, 1203.5, 174.36, 21.105, 2.3599, 0.25493])\\n sigma = np.array([0.153, 0.515, 1.58, 4.22, 10, 22.4, 48.8, 105, 227, 525])\\n qObs = np.full_like(sigma, 0.57)\\n\\n distance = 16.5 # Assume Virgo distance in Mpc (Mei et al. 2007)\\n mbh = 1e8 # Black hole mass in solar masses\\n beta = np.full_like(surf, 0.3)\\n\\n surf_lum = surf # Assume self-consistency\\n sigma_lum = sigma\\n qobs_lum = qObs\\n surf_pot = surf\\n sigma_pot = sigma\\n qobs_pot = qObs\\n\\n sigmapsf = 0.6\\n pixsize = 0.8\\n goodbins = r > 10 # Arbitrarily exclude the center to illustrate how to use goodbins\\n\\n # The model is similar but not identical to the adopted kinematics!\\n rmsModel, ml, chi2, flux = jam_axi_rms(\\n surf_lum, sigma_lum, qobs_lum, surf_pot, sigma_pot, qobs_pot,\\n inc, mbh, distance, xbin, ybin, plot=True, rms=rms, sigmapsf=sigmapsf,\\n beta=beta, pixsize=pixsize, tensor='zz', goodbins=goodbins)\\n plt.pause(0.01)\",\n \"def test_fourth_order():\\n if __name__ == '__main__':\\n logger = piff.config.setup_logger(verbose=2)\\n else:\\n logger = piff.config.setup_logger(log_file='output/test_hsmcatalog.log')\\n\\n image_file = os.path.join('output','test_stats_image.fits')\\n cat_file = os.path.join('output','test_stats_cat.fits')\\n psf_file = os.path.join('output','test_starstats.fits')\\n hsm_file = os.path.join('output', 'test_hsmcatalog.fits')\\n config = {\\n 'input' : {\\n 'image_file_name' : image_file,\\n 'cat_file_name' : cat_file,\\n 'stamp_size' : 48,\\n },\\n 'psf' : {\\n 'model' : { 'type' : 'Gaussian',\\n 'fastfit': True,\\n 'include_pixel': False },\\n 'interp' : { 'type' : 'Mean' },\\n },\\n 'output' : {\\n 'file_name' : psf_file,\\n 'stats' : [\\n {\\n 'type': 'HSMCatalog',\\n 'file_name': hsm_file,\\n 'fourth_order': True\\n }\\n ]\\n }\\n }\\n piff.piffify(config, logger)\\n assert os.path.isfile(hsm_file)\\n\\n data = fitsio.read(hsm_file)\\n print('data = ',data)\\n # Check that the model and data measurements are close\\n np.testing.assert_allclose(data['T_model'], data['T_data'], rtol=1.e-4)\\n np.testing.assert_allclose(data['g1_model'], data['g1_data'], rtol=1.e-4)\\n np.testing.assert_allclose(data['g2_model'], data['g2_data'], rtol=1.e-4)\\n np.testing.assert_allclose(data['T4_model'], data['T4_data'], rtol=1.e-4)\\n np.testing.assert_allclose(data['g41_model'], data['g41_data'], atol=1.e-4)\\n np.testing.assert_allclose(data['g42_model'], data['g42_data'], atol=1.e-4)\\n np.testing.assert_allclose(data['h41_model'], data['h41_data'], rtol=1.e-4)\\n np.testing.assert_allclose(data['h42_model'], data['h42_data'], rtol=1.e-4)\\n\\n # Check that the moment values are what we intend them to be\\n psf = piff.read(psf_file)\\n stars = piff.Star.load_images(psf.stars, image_file)\\n for i, star in enumerate(stars):\\n moments = piff.util.calculate_moments(star, fourth_order=True)\\n T = moments['M11']*2\\n shape = galsim.Shear(e1=moments['M20']/moments['M11'],\\n e2=moments['M02']/moments['M11'])\\n print('moments = ',moments)\\n print('hsm = ',star.hsm)\\n print('data = ',data[i])\\n print(data['T_data'][i], T, 2*star.hsm[3]**2 / (1-shape.e**2)**0.5)\\n print(data['g1_data'][i], shape.g1, star.hsm[4])\\n print(data['g2_data'][i], shape.g2, star.hsm[5])\\n np.testing.assert_allclose(data['T_data'][i], T, rtol=1.e-5)\\n np.testing.assert_allclose(data['g1_data'][i], shape.g1, rtol=1.e-5)\\n np.testing.assert_allclose(data['g2_data'][i], shape.g2, rtol=1.e-5)\\n T4 = moments['M22'] / T\\n np.testing.assert_allclose(data['T4_data'][i], moments['M22']/moments['M11'], rtol=1.e-5)\\n np.testing.assert_allclose(data['g41_data'][i],\\n moments['M31']/moments['M11']**2 - 3*shape.e1, atol=1.e-5)\\n np.testing.assert_allclose(data['g42_data'][i],\\n moments['M13']/moments['M11']**2 - 3*shape.e2, atol=1.e-5)\\n np.testing.assert_allclose(data['h41_data'][i],\\n moments['M40']/moments['M11']**2, rtol=1.e-5)\\n np.testing.assert_allclose(data['h42_data'][i],\\n moments['M04']/moments['M11']**2, rtol=1.e-5)\\n\\n # Our simulated data here are elliptical Gaussians, so check that the fourth order terms\\n # match what we expect for them.\\n #\\n # First, for a round Gaussian, M22 = T^2.\\n # When there is some ellipticity, there is a correction of (1-e^2).\\n # It doesn't come out exact, but it's reasonably close. Not sure why it's not closer...\\n print('T4: ', data['T4_data'][i], T/(1-shape.e**2)**0.5)\\n np.testing.assert_allclose(data['T4_data'][i], T/(1-shape.e**2)**0.5, rtol=0.05)\\n\\n # Next, the naive 4th order shape of an elliptical Gaussian is approximately 3e:\\n # M31/M11^2 ~= 3 M20/M11\\n # M13/M11^2 ~= 3 M02/M11\\n print('e4: ', moments['M31']/moments['M11']**2, 3*moments['M20']/moments['M11'])\\n print('e4: ', moments['M13']/moments['M11']**2, 3*moments['M02']/moments['M11'])\\n np.testing.assert_allclose(moments['M31']/moments['M11'], 3*moments['M20'], rtol=1.e-3)\\n np.testing.assert_allclose(moments['M13']/moments['M11'], 3*moments['M02'], rtol=1.e-3)\\n # Our g4 measurements subtract off this leading order effect, so for these Gaussian\\n # profiles, the 4th order terms are close to 0.\\n print('g4: ', data['g41_data'][i], data['g42_data'][i])\\n np.testing.assert_allclose(data['g41_data'][i], 0, atol=1.e-3)\\n np.testing.assert_allclose(data['g42_data'][i], 0, atol=1.e-3)\\n\\n # I didn't try to figure out what the spin-4 values should be for a Gaussian.\\n # If someone wants to work that out, it would be nice to add a test that they are right.\\n # Empirically, it seems to come out pretty close to 10 x (g1+i g2)^2.\\n # The g^2 bit makes sense, but I can't figure out where the factor of ~10 comes from.\\n print('h4: ', data['h41_data'][i], data['h42_data'][i])\\n\\n # Repeat, adding in raw_moments\\n config['output']['stats'][0]['raw_moments'] = True\\n piff.piffify(config, logger)\\n data = fitsio.read(hsm_file)\\n\\n # Check that the model and data measurements are close\\n for name in ('T', 'g1', 'g2', 'T4', 'h41', 'h42',\\n 'M00', 'M10', 'M01', 'M11', 'M20', 'M02',\\n 'M22', 'M31', 'M13', 'M40', 'M04',\\n 'M22n', 'M33n', 'M44n'):\\n np.testing.assert_allclose(data[name+'_model'], data[name+'_data'], rtol=1.e-4)\\n for name in ('g41', 'g42', 'M21', 'M12', 'M30', 'M03'):\\n # These are close to 0, so use atol, not rtol.\\n np.testing.assert_allclose(data[name+'_model'], data[name+'_data'], atol=1.e-4)\\n\\n # Check that the moment values are what we intend them to be\\n for i, star in enumerate(stars):\\n moments = piff.util.calculate_moments(star, third_order=True, fourth_order=True,\\n radial=True)\\n # Repeat the tests from above to ensure that raw_moments=True doesn't mess up the\\n # fourth_order=True measurements.\\n T = moments['M11']*2\\n shape = galsim.Shear(e1=moments['M20']/moments['M11'],\\n e2=moments['M02']/moments['M11'])\\n np.testing.assert_allclose(data['T_data'][i], T, rtol=1.e-5)\\n np.testing.assert_allclose(data['g1_data'][i], shape.g1, rtol=1.e-5)\\n np.testing.assert_allclose(data['g2_data'][i], shape.g2, rtol=1.e-5)\\n T4 = moments['M22'] / T\\n np.testing.assert_allclose(data['T4_data'][i], moments['M22']/moments['M11'], rtol=1.e-5)\\n np.testing.assert_allclose(data['g41_data'][i],\\n moments['M31']/moments['M11']**2 - 3*shape.e1, atol=1.e-5)\\n np.testing.assert_allclose(data['g42_data'][i],\\n moments['M13']/moments['M11']**2 - 3*shape.e2, atol=1.e-5)\\n np.testing.assert_allclose(data['h41_data'][i],\\n moments['M40']/moments['M11']**2, rtol=1.e-5)\\n np.testing.assert_allclose(data['h42_data'][i],\\n moments['M04']/moments['M11']**2, rtol=1.e-5)\\n np.testing.assert_allclose(data['T4_data'][i], T/(1-shape.e**2)**0.5, rtol=0.05)\\n np.testing.assert_allclose(moments['M31']/moments['M11'], 3*moments['M20'], rtol=1.e-3)\\n np.testing.assert_allclose(moments['M13']/moments['M11'], 3*moments['M02'], rtol=1.e-3)\\n np.testing.assert_allclose(data['g41_data'][i], 0, atol=1.e-3)\\n np.testing.assert_allclose(data['g42_data'][i], 0, atol=1.e-3)\\n\\n for name in moments.keys():\\n # These should be exactly the same.\\n np.testing.assert_allclose(data[name+'_data'][i], moments[name])\\n # And the model ones should be close.\\n np.testing.assert_allclose(data[name+'_model'][i], moments[name], atol=1.e-4)\\n\\n # Finally make sure raw_moments works without fourth_order=True\\n del config['output']['stats'][0]['fourth_order']\\n piff.piffify(config, logger)\\n data = fitsio.read(hsm_file)\\n for i, star in enumerate(stars):\\n moments = piff.util.calculate_moments(star, third_order=True, fourth_order=True,\\n radial=True)\\n for name in moments.keys():\\n # These should be exactly the same.\\n np.testing.assert_allclose(data[name+'_data'][i], moments[name])\\n # And the model ones should be close.\\n np.testing.assert_allclose(data[name+'_model'][i], moments[name], atol=1.e-4)\",\n \"def test_find_dispersion_axis():\\n wavelengths = np.arange(100) * 0.1 + np.exp(0.1) * 13.0\\n # [14.36722193, 14.46722193, 14.56722193, ... 24.16722193, 24.26722193]\\n\\n wavelengths_horizontal = np.tile(wavelengths, 15).reshape(15, 100)\\n assert find_dispersion_axis(wavelengths_horizontal) == 0\\n\\n wavelengths_vertical = np.repeat(wavelengths, 15).reshape(100, 15)\\n assert find_dispersion_axis(wavelengths_vertical) == 1\\n\\n # Make sure it works for decreasing wavelengths\\n assert find_dispersion_axis(np.fliplr(wavelengths_horizontal)) == 0\\n assert find_dispersion_axis(np.flipud(wavelengths_vertical)) == 1\\n\\n # Make sure it works if there are NaNs\\n wavelengths_horizontal[:,0] = np.nan\\n assert find_dispersion_axis(wavelengths_horizontal) == 0\\n\\n wavelengths_vertical[:,0] = np.nan\\n assert find_dispersion_axis(wavelengths_vertical) == 1\\n\\n # Make sure if wavelengths don't change it produces an error\\n wavelengths_zeros = np.zeros((15, 100))\\n with pytest.raises(RuntimeError):\\n find_dispersion_axis(wavelengths_zeros)\",\n \"def fiducial_comparison():\\n \\n # observed gd1\\n g = Table(fits.getdata('/home/ana/projects/GD1-DR2/output/gd1_members.fits'))\\n \\n # fiducial model\\n wangle = 180*u.deg\\n pk = pickle.load(open('../data/gd1_fiducial.pkl', 'rb'))\\n xi, eta = pk['xi'], pk['eta']\\n \\n plt.close()\\n fig, ax = plt.subplots(2,1,figsize=(7,6), sharex=True)\\n \\n plt.sca(ax[0])\\n plt.scatter(g['phi1']+40, g['phi2'], s=g['pmem']*2, c=g['pmem'], cmap=mpl.cm.binary, vmin=0.5, vmax=1.1, rasterized=True)\\n \\n plt.ylabel('$\\\\phi_2$ [deg]')\\n plt.text(0.05, 0.9, 'Most likely GD-1 members', transform=plt.gca().transAxes, va='top', fontsize=17)\\n plt.xlim(-20,20)\\n plt.ylim(-10,10)\\n plt.gca().set_aspect('equal')\\n \\n plt.sca(ax[1])\\n plt.plot(xi.wrap_at(wangle), eta, 'o', mec='none', color=mpl.cm.Blues(0.9), ms=5)\\n \\n plt.xlabel('$\\\\phi_1$ [deg]')\\n plt.ylabel('$\\\\phi_2$ [deg]')\\n plt.text(0.05, 0.9, 'Simulated GD-1\\\\n0.5 Gyr after subhalo flyby', transform=plt.gca().transAxes, va='top', fontsize=17)\\n plt.ylim(-10,10)\\n plt.gca().set_aspect('equal')\\n \\n plt.tight_layout()\\n plt.savefig('../plots/fiducial_comparison.pdf')\",\n \"def magn(names, values, data, model_key, plot_key=False):\\n # Making sure number of parameters matches number of names given:\\n assert len(names) == len(values), \\\"len(names) != len(values) in datasim.magn\\\"\\n\\n zpicks = data['zpicks']\\n # Corrected absolute magnitude M of SN.\\n M = values[0]\\n\\n# dlpc, da, integrated_zpicks, integrated_dlpc, plot_var = zodesolve.zodesolve(names, values, zpicks, model_key, plot_key)\\n\\n dlpc, da, plot_var = zodesolve.zodesolve(names, values, zpicks, model_key, plot_key)\\n\\n # Calculating apparent magnitudes of supernovae at the simulated\\n # luminosity distances using the distance modulus formula.\\n mag = 5 * np.log10(dlpc/10) + M\\n# integrated_mag = 5 * np.log10(integrated_dlpc/10) + M\\n# print('redshift =',zpicks[-1],'da =', da[-1])\\n\\n# # plotting interpoated data vs input and full\\n# import matplotlib.pyplot as plt\\n# import matplotlib as mpl\\n# #mpl.style.use('default') # has to be switched on to set figure size\\n# mpl.style.use('fivethirtyeight')\\n# plt.rcParams['axes.facecolor'] = 'white'\\n# plt.rcParams['figure.facecolor'] = 'white'\\n# plt.rcParams['grid.color'] = 'white'\\n#\\n# print('integrated_zpicks',integrated_zpicks[0])\\n# print('zpicks', zpicks[0])\\n#\\n# plt.figure()\\n# plt.scatter(integrated_zpicks, integrated_mag, s=70, label='integrated', c=\\\"C{}\\\".format(0))\\n# plt.plot(zpicks, mag, label='interpolated', linestyle='-', c=\\\"C{}\\\".format(1))\\n# plt.legend()\\n\\n if plot_key:\\n # Plotting evolution of parameters in the model.\\n import plots\\n plots.modelcheck(mag, zpicks, plot_var, model_key)\\n\\n return mag, da\",\n \"def main():\\n\\n convergence_rates_e1 = pd.DataFrame(index=['Mean', 'St.D'])\\n convergence_rates_e4 = pd.DataFrame(index=['Mean', 'St.D'])\\n success_rates = pd.DataFrame(index=['1e-1', '1e-2', '1e-3', '1e-4', '1e-5'])\\n peak_ratios = pd.DataFrame(index=['1e-1', '1e-2', '1e-3', '1e-4', '1e-5'])\\n\\n for function in range(1, 21):\\n results = pickle.load(open('results/benchmarking_result_{}.pkl'.format(function), 'rb'))\\n\\n col_name = 'F{}'.format(function)\\n index = function-1\\n\\n convergence_rates_e1.insert(index, col_name, results.ConvergenceRates[0])\\n convergence_rates_e4.insert(index, col_name, results.ConvergenceRates[3])\\n\\n success_rates.insert(index, col_name, results.SuccessRate)\\n peak_ratios.insert(index, col_name, results.PeakRatio)\\n\\n for i in results.SimulationSwarms:\\n\\n x_axis = [k for k, _ in i.items()]\\n y_axis = [v for _, v in i.items()]\\n\\n plt.subplot(4, 5, function) # subplot indexes from 1\\n plt.plot(x_axis, y_axis, 'k-')\\n\\n plt.savefig('results/nmmso_benchmark.png')\\n plt.show()\\n\\n pd.set_option('display.max_columns', None) # make sure all columns are printed below\\n print(convergence_rates_e1)\\n print(convergence_rates_e4)\\n print(success_rates)\\n print(peak_ratios)\\n\\n # Table V from Fieldsend et al.\\n table4 = pd.Series([\\n peak_ratios.stack().median(),\\n peak_ratios.stack().mean(),\\n peak_ratios.stack().std()\\n ])\\n print(table4)\\n\\n # do we want to reproduce Fig. 3\",\n \"def vsone_matching(metadata, cfgdict={}, verbose=None):\\n # import vtool as vt\\n #assert isinstance(metadata, ut.LazyDict), 'type(metadata)=%r' % (type(metadata),)\\n\\n annot1 = metadata['annot1']\\n annot2 = metadata['annot2']\\n\\n ensure_metadata_feats(annot1, cfgdict=cfgdict)\\n ensure_metadata_feats(annot2, cfgdict=cfgdict)\\n\\n if 'dlen_sqrd' not in annot2:\\n def eval_dlen_sqrd(annot):\\n rchip = annot['rchip']\\n dlen_sqrd = rchip.shape[0] ** 2 + rchip.shape[1] ** 2\\n return dlen_sqrd\\n annot2.set_lazy_func('dlen_sqrd', lambda: eval_dlen_sqrd(annot2))\\n\\n # Exceute relevant dependencies\\n kpts1 = annot1['kpts']\\n vecs1 = annot1['vecs']\\n kpts2 = annot2['kpts']\\n vecs2 = annot2['vecs']\\n dlen_sqrd2 = annot2['dlen_sqrd']\\n flann1 = annot1.get('flann', None)\\n flann2 = annot2.get('flann', None)\\n\\n matches, output_metdata = vsone_feature_matching(\\n kpts1, vecs1, kpts2, vecs2, dlen_sqrd2, cfgdict=cfgdict,\\n flann1=flann1, flann2=flann2, verbose=verbose)\\n metadata.update(output_metdata)\\n return matches, metadata\",\n \"def plot_feeding_zones_and_power_law_fit_MMEN_per_system_observed_and_physical(sssp_per_sys, sssp, n_mult_min=2, n_mult_max=10, max_core_mass=10., prescription='CL2013', n=10., a0=1., p0=1., p1=-1.5, scale_up=False, N_sys=10):\\n y_sym_star = '*' if scale_up else ''\\n assert 2 <= n_mult_min <= n_mult_max\\n count = 0\\n for i,det_sys in enumerate(sssp_per_sys['det_all']):\\n if count >= N_sys:\\n break\\n if n_mult_min <= np.sum(det_sys) <= n_mult_max:\\n count += 1\\n print('##### System %s (i=%s):' % (count, i))\\n\\n Mstar = sssp['Mstar_all'][i]\\n Mp_sys = sssp_per_sys['mass_all'][i]\\n core_mass_sys = np.copy(Mp_sys) # all planet masses including padded zeros\\n core_mass_sys[core_mass_sys > max_core_mass] = max_core_mass\\n R_sys = sssp_per_sys['radii_all'][i] # all planet radii including padded zeros\\n a_sys = sssp_per_sys['a_all'][i] # all semimajor axes including padded zeros\\n\\n core_mass_sys_obs = np.copy(Mp_sys)[det_sys == 1] # masses of observed planets\\n core_mass_sys_obs[core_mass_sys_obs > max_core_mass] = max_core_mass\\n R_sys_obs = R_sys[det_sys == 1] # radii of observed planets\\n a_sys_obs = a_sys[det_sys == 1] # semimajor axes of observed planets\\n core_mass_sys = core_mass_sys[a_sys > 0] # masses of all planets\\n R_sys = R_sys[a_sys > 0] # radii of all planets\\n a_sys = a_sys[a_sys > 0] # semimajor axes of all planets\\n\\n sigma_sys = solid_surface_density_prescription(core_mass_sys, R_sys, a_sys, Mstar=Mstar, n=n, prescription=prescription) # using all planets\\n sigma_sys_obs = solid_surface_density_prescription(core_mass_sys_obs, R_sys_obs, a_sys_obs, Mstar=Mstar, n=n, prescription=prescription) # using observed planets only\\n\\n if scale_up:\\n sigma0, beta, scale_factor_sigma0 = fit_power_law_and_scale_up_MMEN(a_sys, sigma_sys, a0=a0, p0=p0, p1=p1)\\n sigma0_obs, beta_obs, scale_factor_sigma0_obs = fit_power_law_and_scale_up_MMEN(a_sys_obs, sigma_sys_obs, a0=a0, p0=p0, p1=p1)\\n else:\\n sigma0, beta = fit_power_law_MMEN(a_sys, sigma_sys, a0=a0, p0=p0, p1=p1)\\n scale_factor_sigma0 = 1.\\n sigma0_obs, beta_obs = fit_power_law_MMEN(a_sys_obs, sigma_sys_obs, a0=a0, p0=p0, p1=p1)\\n scale_factor_sigma0_obs = 1.\\n\\n # Plot the system:\\n a_array = np.linspace(1e-3,2,1001)\\n sigma_MMSN = MMSN(a_array)\\n\\n delta_a_sys_S2014 = feeding_zone_S2014(core_mass_sys, R_sys, a_sys, Mstar=Mstar)\\n delta_a_sys_nHill = feeding_zone_nHill(core_mass_sys, a_sys, Mstar=Mstar, n=n)\\n delta_a_sys_RC2014, a_bounds_sys = feeding_zone_RC2014(a_sys)\\n\\n fig = plt.figure(figsize=(12,8))\\n plot = GridSpec(1,1,left=0.1,bottom=0.15,right=0.95,top=0.95,wspace=0,hspace=0)\\n ax = plt.subplot(plot[0,0])\\n plt.scatter(a_sys, np.log10(sigma_sys), marker='o', s=100.*R_sys**2., facecolors='none', edgecolors='k', label='All planets')\\n plt.scatter(a_sys_obs, np.log10(sigma_sys_obs), marker='o', s=100.*R_sys_obs**2., color='k', label='Observed planets')\\n for j,a in enumerate(a_sys):\\n # Plot various feeding zones for each planet:\\n da_S2014 = delta_a_sys_S2014[j]\\n da_nHill = delta_a_sys_nHill[j]\\n #da_RC2014 = delta_a_sys_RC2014[j]\\n #plt.plot([0.5*a, 1.5*a], [np.log10(1.15*sigma_sys[j])]*2, lw=1, color='k')\\n #plt.plot([a - da_S2014/2., a + da_S2014/2.], [np.log10(1.05*sigma_sys[j])]*2, lw=1, color='r')\\n #plt.plot([a - da_nHill/2., a + da_nHill/2.], [np.log10(0.95*sigma_sys[j])]*2, lw=1, color='b')\\n #plt.plot([a_bounds_sys[j], a_bounds_sys[j+1]], [np.log10(0.85*sigma_sys[j])]*2, lw=1, color='m')\\n #plt.plot([a_bounds_sys[j], a_bounds_sys[j+1]], [np.log10(sigma_sys[j])]*2, lw=2, color='k') # lines for feeding zones\\n plt.axvspan(a_bounds_sys[j], a_bounds_sys[j+1], alpha=0.2 if j%2==0 else 0.1, ec=None, fc='k')\\n\\n # To compare the planet masses to the integrated disk masses:\\n Mp_core = core_mass_sys[j]\\n plt.annotate(r'${:0.1f} M_\\\\oplus$'.format(Mp_core), (a, np.log10(1.5*sigma_sys[j])), ha='center', fontsize=16)\\n if prescription == 'CL2013':\\n Mp_intdisk = solid_mass_integrated_r0_to_r_given_power_law_profile(1.5*a, 0.5*a, sigma0, beta, a0=a0)\\n print('Planet (core) mass: {:0.2f} M_earth --- Integrated disk mass (CL2013): {:0.2f} M_earth'.format(Mp_core, Mp_intdisk))\\n elif prescription == 'S2014':\\n Mp_intdisk = solid_mass_integrated_r0_to_r_given_power_law_profile(a + da_S2014/2., a - da_S2014/2., sigma0, beta, a0=a0)\\n print('Planet (core) mass: {:0.2f} M_earth --- Integrated disk mass (S2014): {:0.2f} M_earth'.format(Mp_core, Mp_intdisk))\\n elif prescription == 'nHill':\\n Mp_intdisk = solid_mass_integrated_r0_to_r_given_power_law_profile(a + da_nHill/2., a - da_nHill/2., sigma0, beta, a0=a0)\\n print('Planet (core) mass: {:0.2f} M_earth --- Integrated disk mass (nHill): {:0.2f} M_earth'.format(Mp_core, Mp_intdisk))\\n elif prescription == 'RC2014':\\n Mp_intdisk = solid_mass_integrated_r0_to_r_given_power_law_profile(a_bounds_sys[j+1], a_bounds_sys[j], sigma0, beta, a0=a0)\\n print('Planet (core) mass: {:0.2f} M_earth --- Integrated disk mass (RC2014): {:0.2f} M_earth'.format(Mp_core, Mp_intdisk))\\n\\n plt.plot(a_array, np.log10(MMEN_power_law(a_array, sigma0, beta, a0=a0)), lw=3, ls='-', color='r', label=r'Fit to all planets ($\\\\Sigma_0^%s = {:0.0f}$, $\\\\beta = {:0.2f}$)'.format(sigma0, beta) % y_sym_star)\\n plt.plot(a_array, np.log10(MMEN_power_law(a_array, sigma0_obs, beta_obs, a0=a0)), lw=3, ls='--', color='r', label=r'Fit to observed planets ($\\\\Sigma_0^%s = {:0.0f}$, $\\\\beta = {:0.2f}$)'.format(sigma0_obs, beta_obs) % y_sym_star)\\n plt.plot(a_array, np.log10(sigma_MMSN), lw=3, color='g', label=r'MMSN ($\\\\Sigma_0 = {:0.0f}$, $\\\\beta = {:0.2f}$)'.format(MMSN(a0), -1.5))\\n ax.tick_params(axis='both', labelsize=20)\\n plt.gca().set_xscale(\\\"log\\\")\\n plt.xticks([0.05, 0.1, 0.2, 0.4, 0.8])\\n ax.get_xaxis().set_major_formatter(ticker.ScalarFormatter())\\n plt.xlim([0.04,0.9])\\n plt.ylim([-0.5,5.5])\\n plt.xlabel(r'Semimajor axis, $a$ (AU)', fontsize=20)\\n plt.ylabel(r'Surface density, $\\\\log_{10}(\\\\Sigma/{\\\\rm g\\\\,cm}^{-2})$', fontsize=20)\\n plt.legend(loc='lower left', bbox_to_anchor=(0.,0.), ncol=1, frameon=False, fontsize=16)\\n\\n plt.show()\",\n \"def IR():\\n s = np.array(\\n [2.40774137,2.287696084,2.203613927,2.048710132,1.899829585,1.591776247,\\n 2.021218754,2.572949552,3.298381484,3.635993426,3.788266224,3.8307278,3.834208811]\\n )\\n\\n TI = np.array([50, 75, 100, 150, 200, 300, 400, 500, 750, 1000, 1500, 2000, 3000])\\n\\n comp1 = s * np.array([-159.1,-134.2,-109.1,-64.7,25.0,40.1,88.6,126.8,187.6,219.4,245.4,253.6,256.1])\\n comp2 = s * np.array([-368.3,-356.9,-343.8,-318.1,-292.0,-242.5,-199.3,-158.4,-68.8,14.2,131.9,219.5,333.5])\\n comp3 = s * np.array([-77.5,-51.9,-29.8,9.9,40.2,85.7,115.4,135.1,160.1,167.6,172.3,171.7,171.8])\\n comp4 = s * np.array([-265.0,-240.6,-216.7,-170.5,-128.2,-53.5,9.6,62.3,159.7,223.8,296.5,328.3,346.7])\\n comp5 = s * np.array([-346.5,-328.9,-312.1,-278.5,-244.4,-182.3,-128.0,-80.0,30.8,109.3,225.1,299.5,372.2])\\n\\n comp = [comp1, comp2, comp3, comp4, comp5]\\n MSE = []\\n colors = [\\\"#1f77b4\\\", \\\"#ff7f0e\\\", \\\"#2ca02c\\\", \\\"#d62728\\\", \\\"#9467bd\\\"]\\n x_new = np.linspace(0, 3000, 10000)\\n for i, j, k in zip(comp, colors, np.arange(1, 6)):\\n plt.scatter(TI, i, c=j)\\n # popt, _ = curve_fit(MZ, TI, i, p0=np.array([200, 220, 300]))\\n popt, _ = curve_fit(MZ, TI, i, p0=np.array([300, 220]))\\n # M_z0, T1, M0 = popt\\n M0, T1 = popt\\n y_new = MZ(x_new, *popt)\\n plt.plot(x_new, y_new, \\\"--\\\", c=j, label=f\\\"Fit Comp. {k:d} : $T_1$={T1:3.2f}\\\")\\n MSE.append(mean_squared_error(i,y_new[TI]))\\n print(MSE)\\n print(np.mean(MSE))\\n plt.grid()\\n plt.legend(loc=\\\"best\\\")\\n plt.xlabel(\\\"TI\\\")\\n plt.ylabel(r\\\"Singal Intensity $M_z$\\\")\\n plt.show()\",\n \"def compare_winds(mr1='waroona_run2', mr2='waroona_run2uc', \\n hour=datetime(2016,1,5,15),\\n extent=None,\\n subsubdir=None):\\n extentname = mr1.split('_')[0]\\n if extent is None:\\n extent = constants.extents[extentname]\\n \\n\\n cubes1 = fio.read_model_run(mr1, hour, extent=extent, add_winds=True)\\n cubes2 = fio.read_model_run(mr2, hour, extent=extent, add_winds=True)\\n \\n # pull out horizontal winds\\n u,v,s,wd = cubes1.extract(['u','v','s','wind_direction'])\\n cu,cv,cs,cwd = cubes2.extract(['u','v','s','wind_direction'])\\n dates = utils.dates_from_iris(u)\\n height = utils.height_from_iris(s)#.coord('level_height').points\\n lats = s.coord('latitude').points\\n lons = s.coord('longitude').points\\n clats = cs.coords('latitude').points\\n clons = cs.coords('longitude').points\\n\\n ff1,ff2=None,None\\n if fio.run_info[mr1]['hasfire']:\\n ff1, = fio.read_fire(mr1,dtimes=dates,extent=extent,firefront=True)\\n if fio.run_info[mr2]['hasfire']:\\n ff2, = fio.read_fire(mr2,dtimes=dates,extent=extent,firefront=True)\\n \\n # density plot arguments\\n bandwidth=1\\n # x axis for wind speed\\n xs = np.linspace(0,20,100)\\n # x axis for wind dir\\n xwd = np.linspace(0,360,100)\\n # x axis for vert wind speed\\n xw = np.linspace(-32,32,100)\\n \\n ## Colourmap setup for contourf plots\\n # Horizontal wind colorbar should be the same for both runs\\n hmaxthresh=[5,10,15,20,25,30,35]\\n hcmap=plotting._cmaps_['windspeed']\\n # vertical wind colourbar is constant\\n wcmap=plotting._cmaps_['verticalvelocity']\\n wnorm=colors.SymLogNorm(0.25,base=2.) # linear to +- 0.25, then log scale\\n wcontours=np.union1d(np.union1d(2.0**np.arange(-2,6),-1*(2.0**np.arange(-2,6))),np.array([0]))\\n \\n # make 4 vertical bins\\n row1 = (0<=height) * (height<500)\\n row2 = (500<=height) * (height<2000)\\n row3 = (2000<=height) * (height<5000)\\n row4 = (5000<=height) * (height<9000)\\n \\n # loop over datetimes:\\n for di, date in enumerate(dates):\\n \\n s1, s2, s3, s4 = [np.mean(s[di,row,:,:].data, axis=0) for row in [row1,row2,row3,row4]]\\n u1, u2, u3, u4 = [np.mean(u[di,row,:,:].data, axis=0) for row in [row1,row2,row3,row4]]\\n v1, v2, v3, v4 = [np.mean(v[di,row,:,:].data, axis=0) for row in [row1,row2,row3,row4]]\\n wd1, wd2, wd3, wd4 = [np.mean(wd[di,row,:,:].data, axis=0) for row in [row1,row2,row3,row4]]\\n \\n cs1, cs2, cs3, cs4 = [np.mean(cs[di,row,:,:].data, axis=0) for row in [row1,row2,row3,row4]]\\n cu1, cu2, cu3, cu4 = [np.mean(cu[di,row,:,:].data, axis=0) for row in [row1,row2,row3,row4]]\\n cv1, cv2, cv3, cv4 = [np.mean(cv[di,row,:,:].data, axis=0) for row in [row1,row2,row3,row4]]\\n cwd1, cwd2, cwd3, cwd4 = [np.mean(cwd[di,row,:,:].data, axis=0) for row in [row1,row2,row3,row4]]\\n \\n \\n # Plotting\\n plt.close()\\n fig, axes = plt.subplots(4,4,figsize=[12,12])\\n for i, (si, ui, vi, wdi, csi, cui, cvi, cwdi) in \\\\\\n enumerate(zip([s1,s2,s3,s4],[u1,u2,u3,u4],[v1,v2,v3,v4],[wd1,wd2,wd3,wd4],\\n [cs1,cs2,cs3,cs4],[cu1,cu2,cu3,cu4],[cv1,cv2,cv3,cv4],[cwd1,cwd2,cwd3,cwd4])):\\n ## Show contourf of wind speed\\n plt.sca(axes[0,i])\\n \\n # first determine colourmap contours so that they are the same between plots (and useful)\\n hmax_index=np.sum(np.max(np.max(si),np.max(csi))>hmaxthresh)\\n hcontours=np.linspace(0,hmaxthresh[hmax_index],20)\\n \\n # plot the filled contour for h-wind speeds\\n plotting.map_contourf(extent, si, lats, lons, cmap=hcmap,\\n clabel=\\\"\\\", cbar=False,\\n cbarform=None,\\n levels=hcontours)\\n # overlaid with quiver of wind dir\\n #plotting.map_quiver(ui,vi,lats,lons,nquivers=7)\\n plt.streamplot(lons,lats,ui,vi,color='grey',minlength=0.5)\\n # set limits back to latlon limits\\n plt.ylim(lats[0],lats[-1])\\n plt.xlim(lons[0],lons[-1])\\n \\n # Add locations and fire\\n plotting.map_add_locations_extent(extentname, \\n hide_text=True,\\n color='k')\\n if ff1 is not None:\\n plotting.map_fire(ff1[di].data,lats,lons)\\n # Add ylabel on left most plot\\n if i==0: plt.ylabel(mr1)\\n # add title along top row\\n plt.title(['<500m','500m-2000m','2km-5km','5km-9km'][i])\\n \\n ## for comparison model also\\n plt.sca(axes[1,i])\\n img,_ = plotting.map_contourf(extent, csi, clats, clons, cmap=hcmap, \\n clabel=\\\"\\\", \\n cbar=False, cbarform=None,\\n levels=hcontours,)\\n \\n # overlaid with quiver of wind dir\\n #plotting.map_quiver(cui,cvi,lats,lons,nquivers=7)\\n \\n plt.streamplot(clons,clats,cui,cvi,color='grey',minlength=0.5)\\n # set limits back to latlon limits\\n plt.ylim(lats[0],lats[-1])\\n plt.xlim(lons[0],lons[-1])\\n \\n plotting.map_add_locations_extent(extentname, \\n hide_text=True,\\n color='k')\\n # add fire\\n if ff2 is not None:\\n plotting.map_fire(ff2[di].data,clats,clons)\\n # add label on leftmost\\n if i==0: plt.ylabel(mr2)\\n \\n ## Add colourbar for column\\n cbar_ax = fig.add_axes([0.14+0.2025*i, 0.508, 0.14, 0.01])# X Y Width Height\\n cbar=fig.colorbar(img, cax=cbar_ax, format=ticker.ScalarFormatter(), pad=0,\\n orientation='horizontal')\\n cbar.set_ticks(np.arange(0,hmaxthresh[hmax_index]+1,5))\\n cbar.set_ticklabels(np.arange(0,hmaxthresh[hmax_index]+1,5))\\n \\n ## add density plot for wind speed\\n plt.sca(axes[2,i])\\n # density function:\\n sdens = gaussian_kde(si.flatten(),bw_method=bandwidth)\\n plt.plot(xs,sdens(xs), label=mr1,linewidth=2)\\n csdens = gaussian_kde(csi.flatten(),bw_method=bandwidth)\\n plt.plot(xs,csdens(xs), label=mr2)\\n plt.yticks([],[])\\n if i==0: plt.ylabel('wind speed density')\\n if i==3: plt.legend()\\n \\n \\n ## add density plot for wind dir\\n plt.sca(axes[3,i])\\n # density function:\\n wddens = gaussian_kde(wdi.flatten(),bw_method=bandwidth)\\n plt.plot(xwd,wddens(xwd), label=mr1, linewidth=2)\\n cwddens = gaussian_kde(cwdi.flatten(),bw_method=bandwidth)\\n plt.plot(xwd,cwddens(xwd), label=mr2, linewidth=2, linestyle='--')\\n plt.yticks([],[])\\n if i==0: plt.ylabel('wind dir density')\\n if i==3: plt.legend()\\n \\n plt.suptitle(date.strftime(\\\"%Y%m%d %H:%M(UTC)\\\"))\\n subdir='horizontal'\\n if subsubdir is not None:\\n subdir += '/'+subsubdir\\n fio.save_fig(mr2, _sn_, date, plt, subdir=subdir)\\n \\n ## Also want to look at vertical winds\\n w, = cubes1.extract(['upward_air_velocity'])\\n cw, = cubes2.extract(['upward_air_velocity'])\\n \\n w1, w2, w3, w4 = [np.mean(w[di,row,:,:].data, axis=0) for row in [row1,row2,row3,row4]]\\n cw1, cw2, cw3, cw4 = [np.mean(cw[di,row,:,:].data, axis=0) for row in [row1,row2,row3,row4]]\\n \\n # Plotting\\n plt.close()\\n fig, axes = plt.subplots(3,4,figsize=[12,12])\\n for i, (wi, cwi) in enumerate(zip([w1,w2,w3,w4],[cw1,cw2,cw3,cw4])):\\n ## Show contourf of wind speed\\n plt.sca(axes[0,i])\\n plotting.map_contourf(extent, wi, lats,lons,cmap=wcmap,clabel=\\\"\\\",levels=wcontours,norm=wnorm,cbar=False,cbarform=None)\\n plotting.map_add_locations_extent(extentname, \\n hide_text=True,\\n color='k')\\n if ff1 is not None:\\n plotting.map_fire(ff1[di].data,lats,lons)\\n if i==0: plt.ylabel(mr1)\\n plt.title(['<500m','500m-2000m','2km-5km','5km-9km'][i])\\n \\n ## for comparison model also\\n plt.sca(axes[1,i])\\n img,_=plotting.map_contourf(extent, cwi, clats,clons,cmap=wcmap,clabel=\\\"\\\",levels=wcontours,norm=wnorm,cbar=False,cbarform=None)\\n plotting.map_add_locations_extent(extentname, \\n hide_text=True,\\n color='k')\\n if ff2 is not None:\\n plotting.map_fire(ff2[di].data,clats,clons)\\n if i==0: plt.ylabel(mr2)\\n \\n ## add density plot for wind speed\\n plt.sca(axes[2,i])\\n ## density function:\\n #wdens = gaussian_kde(wi.flatten(),bw_method=bandwidth)\\n #plt.plot(xw,wdens(xw), label=mr1, linewidth=2)\\n #cwdens = gaussian_kde(cwi.flatten(),bw_method=bandwidth)\\n #plt.plot(xw,cwdens(xw), label=mr2, linewidth=2, linestyle='--')\\n ## cumulative frequency\\n wcdf = cumfreq(wi.flatten(), numbins=len(xw), defaultreallimits=(min(xw),max(xw)))\\n plt.plot(xw,wcdf.cumcount,label=mr1, linewidth=2)\\n cwcdf = cumfreq(cwi.flatten(), numbins=len(xw), defaultreallimits=(min(xw),max(xw)))\\n plt.plot(xw,cwcdf.cumcount,label=mr2, linewidth=2, linestyle='--')\\n plt.yticks([],[])\\n if i==0: plt.ylabel('wind speed cdf')\\n if i==3: plt.legend()\\n ## Add colourbar\\n cbar_ax = fig.add_axes([.35, 0.37, 0.3, 0.015])# X Y Width Height\\n cbar=fig.colorbar(img, cax=cbar_ax, format=ticker.ScalarFormatter(), pad=0,\\n orientation='horizontal')\\n cbar.set_ticks([-32,-8,-2,0,2,8,32])\\n cbar.set_ticklabels([-32,-8,-2,0,2,8,32])\\n # title and save\\n plt.suptitle(date.strftime(\\\"%Y%m%d %H:%M(UTC)\\\"))\\n \\n subdir='vertical'\\n if subsubdir is not None:\\n subdir += '/'+subsubdir\\n fio.save_fig(mr2, _sn_, date, plt, subdir=subdir)\",\n \"def plot_hist_snfit_meta(self): \\n \\n self.read_meta()\\n self.read_snfit_results()\\n\\n \\n self.diff_x0 = []\\n self.diff_x0_err = []\\n self.diff_x1 = []\\n self.diff_x1_err = [] \\n self.diff_c = []\\n self.diff_c_err = [] \\n self.diff_mb = []\\n self.diff_mb_err = [] \\n self.diff_cov_x0_x1 = []\\n self.diff_cov_x0_c = []\\n self.diff_cov_x1_c = []\\n self.diff_cov_mb_x1 = []\\n self.diff_cov_mb_c = []\\n\\n for i in range (len(self.sn_name)):\\n for j in range (len(self.meta_sn_name_list)):\\n if self.sn_name[i] == self.meta_sn_name_list[j]:\\n if np.abs(self.mb[i] - self.meta_mb[j]) < 0.0001:\\n self.diff_x0.append(self.x0[i] - self.meta_x0[j])\\n self.diff_x0_err.append(self.x0_err[i] - self.meta_x0_err[j])\\n self.diff_x1.append(self.x1[i] - self.meta_x1[j])\\n self.diff_x1_err.append(self.x1_err[i] - self.meta_x1_err[j]) \\n self.diff_c.append(self.c[i] - self.meta_c[j])\\n self.diff_c_err.append(self.c_err[i] - self.meta_c_err[j]) \\n self.diff_mb.append(self.mb[i] - self.meta_mb[j])\\n self.diff_mb_err.append(self.mb_err[i] - self.meta_mb_err[j])\\n# self.diff_cov_x0_x1.append()\\n# self.diff_cov_x0_c.append()\\n# self.diff_cov_x1_c.append()\\n# self.diff_cov_mb_x1.append()\\n# self.diff_cov_mb_c.append()\\n else:\\n print self.x1[i] - self.meta_x1[j], self.sn_name[i],self.meta_sn_name_list[j], self.x1[i], self.meta_x1[j]\\n\\n\\n fig = plt.figure(figsize=(8.,8.)) \\n \\n gs = gridspec.GridSpec(2, 1) #subplots ratio\\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\\n f.subplots_adjust(hspace = 0.5)\\n ax0_1 = plt.subplot(gs[0, 0])\\n ax0_2 = plt.subplot(gs[1, 0])\\n \\n ax0_1.hist(self.diff_x0,25,label='$\\\\Delta$ X0')\\n ax0_2.hist(self.diff_x0_err,25,label='$\\\\Delta$ X0 error')\\n ax0_1.legend()\\n ax0_2.legend()\\n ax0_1.set_ylabel('N')\\n ax0_2.set_ylabel('N')\\n pdffile = '../sugar_analysis_data/results/x0_plot_meta_snfit.pdf'\\n plt.savefig(pdffile, bbox_inches='tight')\\n plt.show()\\n \\n gs = gridspec.GridSpec(2, 1) #subplots ratio\\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\\n f.subplots_adjust(hspace = 0.5)\\n ax0_1 = plt.subplot(gs[0, 0])\\n ax0_2 = plt.subplot(gs[1, 0])\\n \\n ax0_1.hist(self.diff_x1,25,label='$\\\\Delta$ X1')\\n ax0_2.hist(self.diff_x1_err,25,label='$\\\\Delta$ X1 error')\\n ax0_1.legend()\\n ax0_2.legend()\\n ax0_1.set_ylabel('N')\\n ax0_2.set_ylabel('N')\\n pdffile = '../sugar_analysis_data/results/x1_plot_meta_snfit.pdf'\\n plt.savefig(pdffile, bbox_inches='tight')\\n plt.show()\\n \\n gs = gridspec.GridSpec(2, 1) #subplots ratio\\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\\n f.subplots_adjust(hspace = 0.5)\\n ax0_1 = plt.subplot(gs[0, 0])\\n ax0_2 = plt.subplot(gs[1, 0])\\n \\n ax0_1.hist(self.diff_c,25,label='$\\\\Delta$ Color')\\n ax0_2.hist(self.diff_c_err,25,label='$\\\\Delta$ Color error')\\n ax0_1.legend()\\n ax0_2.legend()\\n ax0_1.set_ylabel('N')\\n ax0_2.set_ylabel('N')\\n pdffile = '../sugar_analysis_data/results/color_plot_meta_snfit.pdf'\\n plt.savefig(pdffile, bbox_inches='tight')\\n plt.show()\\n\\n gs = gridspec.GridSpec(2, 1) #subplots ratio\\n f, (ax0_1, ax0_2) = plt.subplots(2, sharex=True)\\n f.subplots_adjust(hspace = 0.5)\\n ax0_1 = plt.subplot(gs[0, 0])\\n ax0_2 = plt.subplot(gs[1, 0])\\n \\n ax0_1.hist(self.diff_mb,50,label='$\\\\Delta$ mb')\\n ax0_2.hist(self.diff_mb_err,50,label='$\\\\Delta$ mb error')\\n ax0_1.legend()\\n ax0_2.legend()\\n ax0_1.set_ylabel('N')\\n ax0_2.set_ylabel('N')\\n pdffile = '../sugar_analysis_data/results/mb_plot_meta_snfit.pdf'\\n plt.savefig(pdffile, bbox_inches='tight')\\n plt.show()\",\n \"def parameter_checks():\\n \\n with open (datafile, 'r') as yaml_datafile: \\n #Load as python object \\n yaml_datafile = yaml.load(yaml_datafile, Loader=yaml.FullLoader)\\n #Organize by layers\\n df = pd.json_normalize(yaml_datafile)\\n\\n comp_df = df.iloc[0]['component']\\n comp_df = pd.DataFrame(comp_df)\\n comp_df.to_csv('component.csv')\\n\\n error_count = 0\\n\\n #Check spans in each direction is greater than 0\\n for i in range(len(comp_df)):\\n if comp_df.loc[i,'x_span']<0:\\n print (\\\"ERROR: Component x_span has a value of less than 0\\\")\\n error_count+=1\\n if comp_df.loc[i,'y_span']<0:\\n print (\\\"ERROR: Component y_span has a value of less than 0\\\")\\n error_count+=1\\n if comp_df.loc[i,'z_span']<0:\\n print (\\\"ERROR: Component z_span has a value of less than 0\\\")\\n error_count+=1\\n \\n comp_df = comp_df.set_index('name')\\n #check that components need to be mirrored at the y-axis\\n\\n x_coord_in = comp_df.loc['input_wg','x']\\n x_coord_out = comp_df.loc['output_wg_top','x']\\n\\n if x_coord_in >0 or x_coord_out<0:\\n print (\\\"ERROR: components are not mirrored on the Y axis\\\")\\n\\n #check distance between input and output waveguides in the x direction\\n\\n distance_x = (comp_df.loc['output_wg_top','x']-(comp_df.loc['output_wg_top','x_span']/2))-(comp_df.loc['input_wg','x']+(comp_df.loc['input_wg','x_span']/2))\\n if distance_x < 0:\\n print (\\\"ERROR: distance between input and output waveguides (\\\" +str(distance_x)+\\\") is less than 0, Y-Branch has insufficent spacing to be created\\\")\\n error_count+=1\\n\\n #check distance between two waveguides is greater than 0 in y axis\\n \\n distance_y = (comp_df.loc['output_wg_top','y']-(comp_df.loc['output_wg_top','y_span']/2))-(comp_df.loc['output_wg_bottom','y']+(comp_df.loc['output_wg_bottom','y_span']/2))\\n if distance_y < 0:\\n print (\\\"ERROR: distance between top and bottom waveguides(\\\" +str(distance_y)+\\\") is less than 0, output waveguides need to be separated more\\\")\\n error_count+=1\\n\\n #check if output waveguides if they're aligned on the same axis\\n\\n alignment_output_wg = (comp_df.loc['output_wg_top','x']-(comp_df.loc['output_wg_top','x_span']/2))-(comp_df.loc['output_wg_bottom','x']-(comp_df.loc['output_wg_bottom','x_span']/2))\\n if alignment_output_wg != 0:\\n print (\\\"ERROR: output waveguides are not aligned along y axis, has an alignment mismatch of \\\"+ str(alignment_output_wg))\\n error_count+=1\\n\\n if error_count == 0:\\n print (\\\"No errors detected, datafile can be used for simulations/optimizations\\\")\\n else:\\n print (\\\"Please revise YAML file, \\\" + str(error_count) + \\\"errors detected\\\")\",\n \"def main():\\n\\n # Create model_dict from arguments\\n model_dict = model_dict_create()\\n\\n # No. of deviations to consider\\n no_of_mags = 50\\n dev_list = np.linspace(0.1, 5.0, no_of_mags)\\n\\n # Load dataset specified in model_dict\\n print('Loading data...')\\n dataset = model_dict['dataset']\\n if (dataset == 'MNIST'):\\n X_train, y_train, X_val, y_val, X_test, y_test = load_dataset(model_dict)\\n # rd_list = [None, 784, 331, 200, 100, 90, 80, 70, 60, 50, 40, 30, 20, 10]\\n rd_list = [None, 331, 100, 80, 60, 40, 20]\\n # rd_list = [None,784,100]\\n elif dataset == 'GTSRB':\\n X_train, y_train, X_val, y_val, X_test, y_test = load_dataset(model_dict)\\n rd_list = [1024, 338, 200, 100, 90, 80, 70, 60, 50, 40, 33, 30, 20, 10]\\n elif dataset == 'HAR':\\n X_train, y_train, X_test, y_test = load_dataset(model_dict)\\n # rd_list = [561, 200, 100, 90, 80, 70, 60, 50, 40, 30, 20, 10]\\n rd_list = [561]\\n X_val = None\\n y_val = None\\n\\n mean = np.mean(X_train, axis=0)\\n X_train -= mean\\n X_test -= mean\\n if (dataset == 'MNIST') or (dataset == 'GTSRB'): X_val -= mean\\n\\n # fig, ax = plt.subplots(nrows=1, ncols=1)\\n\\n # for rd in rd_list:\\n # model_setup_carlini(model_dict, X_train, y_train, X_test, y_test, X_val, y_val, mean, rd, ax)\\n\\n partial_carlini = partial(model_setup_carlini, model_dict=model_dict, X_train=X_train, y_train=y_train, X_test=X_test, y_test=y_test, X_val=X_val, y_val=y_val,\\n mean=mean)\\n pool=multiprocessing.Pool(processes=8)\\n pool.map(partial_carlini,rd_list,1)\\n pool.close()\\n pool.join()\\n\\n # dim_red = model_dict['dim_red']\\n # plt.legend()\\n # plt.savefig('carlini_l2_hist_'+dim_red+'.png')\",\n \"def upscaled_rdirs_with_and_without_tarasov_upscaled_north_america_only_data_ALG4_corr_orog_downscaled_ls_mask_0k_FlowMap_comparison(self):\\n\\n data_label=\\\"20170511_230901\\\"\\n ref_label=\\\"20170507_135726\\\"\\n ref_filename=os.path.join(self.plots_data_dir,\\n 'flowmap_ICE5G_data_ALG4_sinkless_downscaled_ls_mask_0k_upscale'\\n '_rdirs_{0}_updated.nc'.format(ref_label))\\n data_filename=os.path.join(self.plots_data_dir,\\n 'flowmap_ICE5G_and_tarasov_upscaled_srtm30plus_north_america_only_data_ALG4_sinkless'\\n '_downscaled_ls_mask_0k_upscale_rdirs_' + data_label + '_updated.nc')\\n lsmask_filename=os.path.join(self.plots_data_dir,\\n \\\"ls_mask_extract_ls_mask_from_corrected_\\\"\\n \\\"HD_rdirs_20160504_142435.nc\\\")\\n corrected_hd_rdirs_rmouthoutflow_file = os.path.join(self.plots_data_dir,\\n \\\"rmouthflows_ICE5G_data_ALG4_sinkless_downscaled_ls_mask_0k_upscale_rdirs\\\"\\n \\\"_{0}_updated.nc\\\".format(ref_label))\\n upscaled_rdirs_rmouthoutflow_file = os.path.join(self.plots_data_dir,\\n \\\"rmouthflows_ICE5G_and_tarasov_upscaled_srtm30plus_north_america_only_\\\"\\n \\\"data_ALG4_sinkless_\\\"\\n \\\"downscaled_ls_mask_0k_upscale_rdirs_\\\" + data_label + \\\"_updated.nc\\\")\\n self.FlowMapTwoColourComparisonWithCatchmentsHelper(ref_flowmap_filename=ref_filename,\\n data_flowmap_filename=data_filename,\\n ref_catchment_filename=\\\\\\n \\\"catchmentmap_ICE5G_data_ALG4_\\\"\\n \\\"sinkless_downscaled_ls_mask_0k_upscale_rdirs_{0}_updated.nc\\\"\\\\\\n .format(ref_label),\\n data_catchment_filename=\\\"catchmentmap_ICE5G_and_tarasov_upscaled_\\\"\\n \\\"srtm30plus_north_america_only_data_ALG4_sinkless_downscaled_ls_\\\"\\n \\\"mask_0k_upscale_rdirs_\\\" + data_label + \\\"_updated.nc\\\",\\n ref_rdirs_filename=\\\"upscaled_rdirs_ICE5G_data\\\"\\n \\\"_ALG4_sinkless_downscaled_\\\"\\n \\\"ls_mask_0k_upscale_rdirs_{0}_updated.nc\\\".format(ref_label),\\n data_rdirs_filename=None,\\n reference_rmouth_outflows_filename=\\\\\\n corrected_hd_rdirs_rmouthoutflow_file,\\n data_rmouth_outflows_filename=\\\\\\n upscaled_rdirs_rmouthoutflow_file,\\n lsmask_filename=lsmask_filename,\\n minflowcutoff=50,flip_data=False,\\n rotate_data=True,flip_ref=False,rotate_ref=True,\\n lsmask_has_same_orientation_as_ref=False,\\n invert_ls_mask=False,\\n first_datasource_name=\\\"Reference\\\",\\n matching_parameter_set='magnitude_extensive',\\n use_single_color_for_discrepancies=True,\\n second_datasource_name=\\\"Data\\\",grid_type='HD')\",\n \"def dorv(visitfiles) :\\n # last list elements has configuration variables in a tuple\\n allvisit = visitfiles[0]\\n load = visitfiles[1]\\n field=visitfiles[-1][0]\\n obj=visitfiles[-1][1].decode('UTF-8')\\n clobber=visitfiles[-1][2]\\n verbose=visitfiles[-1][3]\\n tweak=visitfiles[-1][4]\\n plot=visitfiles[-1][5]\\n windows=visitfiles[-1][6]\\n #rvrange=visitfiles[-1][7]\\n if tweak: suffix='_tweak'\\n else : suffix='_out'\\n outdir = os.path.dirname(load.filename('Star',field=field,obj=obj))\\n outdir = outdir.replace('/stars/','/rv/')\\n\\n if os.path.exists(outdir+'/'+obj+suffix+'.pkl') and not clobber:\\n print(obj,' already done')\\n fp=open(outdir+'/'+obj+suffix+'.pkl','rb')\\n try: \\n out=pickle.load(fp)\\n fp.close()\\n return out\\n except: \\n print('error loading: ', obj+suffix+'.pkl')\\n pass\\n\\n speclist=[]\\n pixelmask=bitmask.PixelBitMask()\\n badval=pixelmask.badval()|pixelmask.getval('SIG_SKYLINE')|pixelmask.getval('LITTROW_GHOST')\\n \\n # if we have a significant number of low S/N visits, combine first using\\n # barycentric correction only, use that to get an estimate of systemic\\n # velocity, then do RV determination restricting RVs to within 50 km/s\\n # of estimate. This seems to help significant for faint visits\\n lowsnr_visits=np.where(allvisit['SNR']<10)[0]\\n if (len(lowsnr_visits) > 1) & (len(lowsnr_visits)/len(allvisit) > 0.1) :\\n try :\\n apstar_bc=visitcomb(allvisit,bconly=True,load=load,write=False,dorvfit=False) \\n apstar_bc.setmask(badval)\\n spec=doppler.Spec1D(apstar_bc.flux[0,:],err=apstar_bc.err[0,:],bitmask=apstar_bc.bitmask[0,:],\\n mask=apstar_bc.mask[0,:],wave=apstar_bc.wave,lsfpars=np.array([0]),\\n lsfsigma=apstar_bc.wave/22500/2.354,instrument='APOGEE',\\n filename=apstar_bc.filename)\\n print('running BC jointfit for :',obj)\\n out= doppler.rv.jointfit([spec],verbose=verbose,plot=plot,tweak=tweak,maxvel=[-500,500])\\n rvrange=[out[1][0]['vrel']-50,out[1][0]['vrel']+50]\\n except :\\n print(' BC jointfit failed')\\n rvrange=[-500,500]\\n elif allvisit['H'].max() > 13.5 : \\n # if it's faint, restrict to +/- 500 km/s\\n rvrange=[-500,500]\\n else :\\n # otherwise, restrict to +/ 1000 km/s\\n rvrange=[-1000,1000]\\n\\n for i in range(len(allvisit)) :\\n\\n # load all of the visits into doppler Spec1D objects\\n if load.telescope == 'apo1m' :\\n visitfile= load.allfile('Visit',plate=allvisit['PLATE'][i],\\n mjd=allvisit['MJD'][i],reduction=allvisit['APOGEE_ID'][i])\\n else :\\n visitfile= load.allfile('Visit',plate=int(allvisit['PLATE'][i]),\\n mjd=allvisit['MJD'][i],fiber=allvisit['FIBERID'][i])\\n spec=doppler.read(visitfile,badval=badval)\\n\\n if windows is not None :\\n # if we have spectral windows to mask, do so here\\n for ichip in range(3) :\\n mask = np.full_like(spec.mask[:,ichip],True)\\n gd = []\\n for window in windows :\\n gd.extend(np.where((spec.wave[:,ichip] > window[0]) & (spec.wave[:,ichip] < window[1]))[0])\\n mask[gd] = False\\n spec.mask[:,ichip] |= mask\\n \\n if spec is not None : speclist.append(spec)\\n\\n # now do the doppler jointfit to get RVs\\n # dump empty pickle to stand in case of failure (to prevent redo if not clobber)\\n try:\\n # dump empty pickle to stand in case of failure (to prevent redo if not clobber)\\n fp=open(outdir+'/'+obj+suffix+'.pkl','wb')\\n pickle.dump(None,fp)\\n fp.close()\\n print('running jointfit for : {:s} rvrange:[{:.1f},{:.1f}] nvisits: {:d}'.format(obj,*rvrange,len(speclist)))\\n out= doppler.rv.jointfit(speclist,maxvel=rvrange,verbose=verbose,\\n plot=plot,saveplot=plot,outdir=outdir+'/',tweak=tweak)\\n print('running decomp for :',obj)\\n gout = gauss_decomp(out[1],phase='two',filt=True)\\n fp=open(outdir+'/'+obj+suffix+'.pkl','wb')\\n pickle.dump([out,gout],fp)\\n fp.close()\\n print('running plots for :',obj,outdir)\\n try : os.makedirs(outdir+'/plots/')\\n except : pass\\n dop_plot(outdir+'/plots/',obj,out,decomp=gout)\\n except KeyboardInterrupt : \\n raise\\n except ValueError as err:\\n print('Exception raised in dorv for: ', field, obj)\\n print(\\\"ValueError: {0}\\\".format(err))\\n return\\n except RuntimeError as err:\\n print('Exception raised in dorv for: ', field, obj)\\n print(\\\"Runtime error: {0}\\\".format(err))\\n return\\n except :\\n raise\\n print('Exception raised in dorv for: ', field, obj)\\n return\\n\\n # return summary RV info, visit RV info, decomp info \\n return [out[0:2],gout]\",\n \"def main_multimodal_fusion(im_vis, im_ir, kernel, levels, window_size):\\n\\n im_vis = convert_image_to_floats(im_vis)\\n im_ir = convert_image_to_floats(im_ir)\\n\\n im_vis_hsv = rgb2hsv(im_vis)\\n value_channel = im_vis_hsv[:, :, 2]\\n\\n plt.subplot(1, 2, 1)\\n plt.imshow(value_channel, cmap='gray')\\n plt.subplot(1, 2, 2)\\n plt.imshow(im_ir, cmap='gray')\\n plt.show()\\n\\n # kernels to compute visibility\\n kernel1 = classical_gaussian_kernel(5, 2)\\n kernel2 = classical_gaussian_kernel(5, 2)\\n\\n # Computation of local entropy, local contrast and visibility for value channel\\n local_entropy_value = normalized_local_entropy(value_channel, window_size)\\n local_contrast_value = local_contrast(value_channel, window_size)\\n visibility_value = visibility(value_channel, kernel1, kernel2)\\n # Combination of local entropy, local contrast and visibility for value channel\\n weight_value = weight_combination(local_entropy_value, local_contrast_value, visibility_value, 1, 1, 1)\\n\\n # Computation of local entropy, local contrast and visibility for IR image\\n local_entropy_ir = normalized_local_entropy(im_ir, window_size)\\n local_contrast_ir = local_contrast(im_ir, window_size)\\n visibility_ir = visibility(im_ir, kernel1, kernel2)\\n # Combination of local entropy, local contrast and visibility for IR image\\n weight_ir = weight_combination(local_entropy_ir, local_contrast_ir, visibility_ir, 1, 1, 1)\\n\\n plt.subplot(2, 3, 1)\\n plt.imshow(local_entropy_value, cmap='gray')\\n plt.subplot(2, 3, 2)\\n plt.imshow(local_contrast_value, cmap='gray')\\n plt.subplot(2, 3, 3)\\n plt.imshow(visibility_value, cmap='gray')\\n plt.subplot(2, 3, 4)\\n plt.imshow(local_entropy_ir, cmap='gray')\\n plt.subplot(2, 3, 5)\\n plt.imshow(local_contrast_ir, cmap='gray')\\n plt.subplot(2, 3, 6)\\n plt.imshow(visibility_ir, cmap='gray')\\n plt.show()\\n\\n # Normalising weights of value channel and IR image\\n weightN_value, weightN_ir = weight_normalization(weight_value, weight_ir)\\n\\n plt.subplot(1, 2, 1)\\n plt.imshow(weightN_value, cmap='gray')\\n plt.subplot(1, 2, 2)\\n plt.imshow(weightN_ir, cmap='gray')\\n plt.show()\\n\\n # Creating Gaussian pyramids of the weights maps of respectively the value channel and IR image\\n gauss_pyr_value_weights = gaussian_pyramid(weightN_value, kernel, levels)\\n gauss_pyr_ir_weights = gaussian_pyramid(weightN_ir, kernel, levels)\\n\\n # Creating Laplacian pyramids of respectively the value channel and IR image\\n lap_pyr_value = laplacian_pyramid(value_channel, kernel, levels)\\n lap_pyr_ir = laplacian_pyramid(im_ir, kernel, levels)\\n\\n # Creating the fused Laplacian of the two modalities\\n lap_pyr_fusion = fused_laplacian_pyramid(gauss_pyr_value_weights, gauss_pyr_ir_weights, lap_pyr_value, lap_pyr_ir)\\n\\n i = 1\\n for l in lap_pyr_fusion:\\n plt.subplot(1, len(lap_pyr_fusion), i)\\n plt.imshow(l, cmap='gray')\\n i += 1\\n plt.show()\\n\\n # Creating the Gaussian pyramid of value channel in order to collapse the fused Laplacian pyramid\\n gauss_pyr_value = gaussian_pyramid(value_channel, kernel, levels)\\n collapsed_image = collapse_pyramid(lap_pyr_fusion, gauss_pyr_value)\\n\\n # Replacing the value channel in HSV visible image by the collapsed image\\n im_vis_hsv_fusion = im_vis_hsv.copy()\\n im_vis_hsv_fusion[:, :, 2] = collapsed_image\\n im_vis_rgb_fusion = hsv2rgb(im_vis_hsv_fusion)\\n\\n plt.subplot(1, 2, 1)\\n plt.imshow(im_vis)\\n plt.subplot(1, 2, 2)\\n plt.imshow(im_vis_rgb_fusion)\\n plt.show()\",\n \"def analyse_colour_mag_diagrams(params,star_catalog,catalog_header,\\n target,source,blend,RC,\\n det_idx,cat_idx,close_cat_idx,log):\\n\\n tol = 2.0\\n\\n filters = { 'ip': 'SDSS-i', 'rp': 'SDSS-r', 'gp': 'SDSS-g' }\\n\\n inst_i = star_catalog['cal_ref_mag_ip'][det_idx]\\n inst_r = star_catalog['cal_ref_mag_rp'][det_idx]\\n inst_g = star_catalog['cal_ref_mag_gp'][det_idx]\\n cal_i = star_catalog['imag'][cat_idx]\\n cal_r = star_catalog['rmag'][cat_idx]\\n cal_g = star_catalog['gmag'][cat_idx]\\n inst_ri = inst_r - inst_i # Catalogue column order is red -> blue\\n inst_gr = inst_g - inst_r\\n inst_gi = inst_g - inst_i\\n cal_ri = cal_r - cal_i\\n cal_gr = cal_g - cal_r\\n cal_gi = cal_g - cal_i\\n\\n linst_i = star_catalog['cal_ref_mag_ip'][close_cat_idx]\\n linst_r = star_catalog['cal_ref_mag_rp'][close_cat_idx]\\n linst_g = star_catalog['cal_ref_mag_gp'][close_cat_idx]\\n lcal_i = star_catalog['imag'][close_cat_idx]\\n lcal_r = star_catalog['rmag'][close_cat_idx]\\n lcal_g = star_catalog['gmag'][close_cat_idx]\\n linst_ri = linst_r - linst_i # Catalogue column order is red -> blue\\n linst_gr = linst_g - linst_r\\n linst_gi = linst_g - linst_i\\n lcal_ri = lcal_r - lcal_i\\n lcal_gr = lcal_g - lcal_r\\n lcal_gi = lcal_g - lcal_i\\n\\n plot_colour_mag_diagram(params,inst_i, inst_ri, linst_i, linst_ri, target,\\n source, blend, RC, 'r', 'i', 'i', tol, log)\\n\\n plot_colour_mag_diagram(params,inst_r, inst_ri, linst_r, linst_ri, target,\\n source, blend, RC, 'r', 'i', 'r', tol, log)\\n\\n plot_colour_mag_diagram(params,inst_g, inst_gr, linst_g, linst_gr, target,\\n source, blend, RC, 'g', 'r', 'g', tol, log)\\n\\n plot_colour_mag_diagram(params,inst_g, inst_gi, linst_g, linst_gi, target,\\n source, blend, RC, 'g', 'i', 'g', tol, log)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6051346","0.5975104","0.59319794","0.58609855","0.58517313","0.5824497","0.5738534","0.5730661","0.57001823","0.5671502","0.5662626","0.56435794","0.5638238","0.56128585","0.56081694","0.56056607","0.55639225","0.5549855","0.554532","0.55445826","0.55290365","0.55254817","0.5525267","0.5520366","0.550799","0.5494048","0.54905665","0.54653275","0.5434908","0.54179794","0.5408877","0.54025","0.5398858","0.53856957","0.5384653","0.5378507","0.5374338","0.5368508","0.536495","0.53627855","0.5360395","0.5358579","0.5353869","0.5339835","0.53339595","0.5323249","0.5320311","0.53102815","0.5308652","0.5296817","0.52878135","0.5285232","0.52852285","0.52837384","0.528165","0.52807546","0.5279183","0.5270517","0.5270375","0.524475","0.52434283","0.5239387","0.52331567","0.52295935","0.5223676","0.522011","0.52159446","0.5212198","0.52120674","0.52101773","0.52061975","0.52043676","0.51981014","0.5195997","0.51916677","0.5190856","0.51908046","0.5187448","0.51840854","0.51777166","0.5165257","0.5160355","0.5157383","0.5151142","0.5150162","0.51478904","0.51456994","0.5140671","0.51401323","0.5138466","0.51376456","0.51329374","0.5131978","0.5130648","0.5130396","0.5130203","0.5129458","0.5128344","0.5125934","0.51210827"],"string":"[\n \"0.6051346\",\n \"0.5975104\",\n \"0.59319794\",\n \"0.58609855\",\n \"0.58517313\",\n \"0.5824497\",\n \"0.5738534\",\n \"0.5730661\",\n \"0.57001823\",\n \"0.5671502\",\n \"0.5662626\",\n \"0.56435794\",\n \"0.5638238\",\n \"0.56128585\",\n \"0.56081694\",\n \"0.56056607\",\n \"0.55639225\",\n \"0.5549855\",\n \"0.554532\",\n \"0.55445826\",\n \"0.55290365\",\n \"0.55254817\",\n \"0.5525267\",\n \"0.5520366\",\n \"0.550799\",\n \"0.5494048\",\n \"0.54905665\",\n \"0.54653275\",\n \"0.5434908\",\n \"0.54179794\",\n \"0.5408877\",\n \"0.54025\",\n \"0.5398858\",\n \"0.53856957\",\n \"0.5384653\",\n \"0.5378507\",\n \"0.5374338\",\n \"0.5368508\",\n \"0.536495\",\n \"0.53627855\",\n \"0.5360395\",\n \"0.5358579\",\n \"0.5353869\",\n \"0.5339835\",\n \"0.53339595\",\n \"0.5323249\",\n \"0.5320311\",\n \"0.53102815\",\n \"0.5308652\",\n \"0.5296817\",\n \"0.52878135\",\n \"0.5285232\",\n \"0.52852285\",\n \"0.52837384\",\n \"0.528165\",\n \"0.52807546\",\n \"0.5279183\",\n \"0.5270517\",\n \"0.5270375\",\n \"0.524475\",\n \"0.52434283\",\n \"0.5239387\",\n \"0.52331567\",\n \"0.52295935\",\n \"0.5223676\",\n \"0.522011\",\n \"0.52159446\",\n \"0.5212198\",\n \"0.52120674\",\n \"0.52101773\",\n \"0.52061975\",\n \"0.52043676\",\n \"0.51981014\",\n \"0.5195997\",\n \"0.51916677\",\n \"0.5190856\",\n \"0.51908046\",\n \"0.5187448\",\n \"0.51840854\",\n \"0.51777166\",\n \"0.5165257\",\n \"0.5160355\",\n \"0.5157383\",\n \"0.5151142\",\n \"0.5150162\",\n \"0.51478904\",\n \"0.51456994\",\n \"0.5140671\",\n \"0.51401323\",\n \"0.5138466\",\n \"0.51376456\",\n \"0.51329374\",\n \"0.5131978\",\n \"0.5130648\",\n \"0.5130396\",\n \"0.5130203\",\n \"0.5129458\",\n \"0.5128344\",\n \"0.5125934\",\n \"0.51210827\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5733137"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":21285,"cells":{"query":{"kind":"string","value":"Convert Pylith output to InSAR LOS and plot data, model in map view"},"document":{"kind":"string","value":"def data_model_residual(surface, dem, unw, incidence):\n los,fem_los,residual = pu.los2pylith(surface,dem,unw,incidence)\n\n # Using image_grid\n fig = plt.figure()\n grid = ImageGrid(fig, 111, # similar to subplot(111)\n nrows_ncols = (1, 3),\n direction=\"row\",\n axes_pad = 0.05,\n add_all=True,\n label_mode = \"1\",\n share_all = True,\n cbar_location=\"top\",\n cbar_mode=\"each\", #\"single\"\n cbar_size=\"5%\",\n cbar_pad=0.05,\n )\n #grid[0].set_xlabel(\"X\")\n #grid[0].set_ylabel(\"Y\")\n #grid2[0].set_xticks([-2, 0])\n #grid2[0].set_yticks([-2, 0, 2])\n\n #NOTE: could find global min/max from three arrays here\n norm = Normalize(vmin=np.nanmin(los), vmax=np.nanmax(los))\n #for ax,data in zip(grid,[los,fem_los,residual]):\n im = grid[0].imshow(los,origin='upper',norm=norm,cmap=plt.cm.jet)\n grid[0].axhline(100,color='m') #show profile\n cax = grid.cbar_axes[0]\n cax.colorbar(im)\n grid[1].axhline(100,color='k') #show profile\n im1 = grid[1].imshow(fem_los,origin='upper',norm=norm,cmap=plt.cm.jet)\n\n cax = grid.cbar_axes[1]\n cax.colorbar(im1)\n\n im2 = grid[2].imshow(residual,origin='upper',cmap=plt.cm.jet)\n cax = grid.cbar_axes[2]\n cax.colorbar(im2)\n\n # Add letter labels\n for ax, label in zip(grid,['A', 'B', 'C']):\n ax.text(0.05, 0.95, label, transform=ax.transAxes,\n fontsize=16, fontweight='bold', va='top')\n\n # Annotate\n # NOTE: way too high!\n #plt.suptitle('FEM Results')\n\n # Add profile\n # NOTE: for now EW, but would be easy to do arbitrary line, and convert to km\n fig = plt.figure()\n #x = arange(los.shape[0])\n plt.axhline(color='k',ls='--')\n plt.plot(los[100],'m.',label='data')\n plt.plot(fem_los[100],'k-',lw=2,label='model')\n plt.xlabel('Distance [km]')\n plt.ylabel('Distance [km]')\n plt.legend(loc='upper left')\n\n plt.show()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def plot_LvsL(modeldata,line1='CIV1548',line2='CIII1908',plotname='./TESTPLOT.pdf',\n Zgas=False,logU=False,xid=0.3,nh=100,COratio=0.38,Mcutoff=100,\n logx=False,logy=False,logp1=False,logp2=False,fixxrange=False,fixyrange=False,\n showobs=None,noobserr=False,verbose=True):\n NFalse = 0\n freeparam = []\n inforstr = \"\"\n # - - - - - - - - - - - - - - - - - - - - - - - -\n legenddic = {}\n legenddic['Zgas'] = r'Z$_\\textrm{gas}$'\n legenddic['logUs'] = r'log$_\\textrm{10}$(U)'\n legenddic['xid'] = r'$\\xi_\\textrm{d}$'\n legenddic['nh'] = r'n$_\\textrm{H}$ / [cm$^3$]'\n legenddic['COCOsol'] = r'C/O / [C/O]$_\\textrm{sun}$'\n legenddic['mup'] = r'M$_\\textrm{cut IMF}$ / [M$_\\textrm{sun}]$'\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not Zgas:\n Zgasrange = [0.0,1.0]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' Zgas:vary, '\n freeparam.append('Zgas')\n else:\n Zgasrange = [Zgas-1e-6,Zgas+1e-6]\n inforstr = inforstr+' '+legenddic['Zgas']+'='+str(Zgas)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not logU:\n logUrange = [-5.0,0.0]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' logU:vary, '\n freeparam.append('logUs')\n else:\n logUrange = [logU-0.1,logU+0.1]\n inforstr = inforstr+' '+legenddic['logUs']+'='+str(logU)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not xid:\n xidrange = [0.0,0.6]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' xid:vary, '\n freeparam.append('xid')\n else:\n xidrange = [xid-0.01,xid+0.01]\n inforstr = inforstr+' '+legenddic['xid']+'='+str(xid)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not nh:\n nhrange = [0.0,1.0e6]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' nH:vary, '\n freeparam.append('nh')\n else:\n nhrange = [nh-1.0,nh+1.0]\n inforstr = inforstr+' '+legenddic['nh']+'='+str(nh)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not COratio:\n COratiorange = [0.0,2.0]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' C/O:vary, '\n freeparam.append('COCOsol')\n else:\n COratiorange = [COratio-0.001,COratio+0.001]\n inforstr = inforstr+' '+legenddic['COCOsol']+'='+str(COratio)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not Mcutoff:\n Mcutoffrange = [0.0,400.0]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' Mcutoff:vary, '\n freeparam.append('mup')\n else:\n Mcutoffrange = [Mcutoff-1.0,Mcutoff+1.0]\n inforstr = inforstr+' '+legenddic['mup']+'='+str(Mcutoff)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n\n if NFalse != 2:\n sys.exit(' Two and only two of the model parameters (Zgas,logU,xid,nh,COratio,Mcutoff) '\n 'should be set to Flase to define the model grid; however it appears '+str(NFalse)+\n ' parameters where not set')\n\n goodent = np.where( (modeldata['Zgas'] > Zgasrange[0]) & (modeldata['Zgas'] < Zgasrange[1]) &\n (modeldata['logUs'] > logUrange[0]) & (modeldata['logUs'] < logUrange[1]) &\n (modeldata['xid'] > xidrange[0]) & (modeldata['xid'] < xidrange[1]) &\n (modeldata['nh'] > nhrange[0]) & (modeldata['nh'] < nhrange[1]) &\n (modeldata['COCOsol'] > COratiorange[0]) & (modeldata['COCOsol'] < COratiorange[1]) &\n (modeldata['mup'] > Mcutoffrange[0]) & (modeldata['mup'] < Mcutoffrange[1]) )\n\n Ngoodent = len(goodent[0])\n\n if Ngoodent > 1:\n if verbose: print(' - Getting data for '+str(Ngoodent)+' data points satisfying model selection ')\n param1 = modeldata[freeparam[0]][goodent]\n if logp1:\n param1 = np.log10(param1)\n\n param2 = modeldata[freeparam[1]][goodent]\n if logp2:\n param2 = np.log10(param2)\n\n lum1 = modeldata[line1][goodent]\n lum2 = modeldata[line2][goodent]\n else:\n if verbose: print(' WARNING: Less than 2 model grid points to plot; no output generated')\n return\n\n # - - - - - - - - - - - PLOTTING - - - - - - - - - - -\n if verbose: print(' - Setting up and generating plot')\n plotname = plotname\n fig = plt.figure(figsize=(9, 5))\n fig.subplots_adjust(wspace=0.1, hspace=0.1,left=0.1, right=0.99, bottom=0.10, top=0.95)\n Fsize = 10\n lthick = 1\n marksize = 3\n plt.rc('text', usetex=True)\n plt.rc('font', family='serif',size=Fsize)\n plt.rc('xtick', labelsize=Fsize)\n plt.rc('ytick', labelsize=Fsize)\n plt.clf()\n plt.ioff()\n plt.title(inforstr[:-2],fontsize=Fsize)\n\n margin = 0.1\n dx = np.abs(np.max(lum1)-np.min(lum1))\n dy = np.abs(np.max(lum2)-np.min(lum2))\n\n\n if fixxrange:\n xrange = fixxrange\n else:\n if logx:\n xrange = [np.min(lum1)-np.min(lum1)/2.,np.max(lum1)+np.max(lum1)/2.]\n else:\n xrange = [np.min(lum1)-dx*margin,np.max(lum1)+dx*margin]\n\n if fixyrange:\n yrange = fixyrange\n else:\n if logy:\n yrange = [np.min(lum2)-np.min(lum2)/2.,np.max(lum2)+np.max(lum2)/2.]\n else:\n yrange = [np.min(lum2)-dy*margin,np.max(lum2)+dy*margin]\n\n # ------------ PARAM1 ------------\n cmap = plt.cm.get_cmap('winter')\n cmin = np.min(param1)\n cmax = np.max(param1)\n colnorm = matplotlib.colors.Normalize(vmin=cmin,vmax=cmax)\n cmaparr = np.linspace(cmin, cmax, 30) #cmax-cmin)\n mm = plt.cm.ScalarMappable(cmap=cmap)\n mm.set_array(cmaparr)\n cb1 = plt.colorbar(mm)#shrink=0.25\n\n pstr1 = legenddic[freeparam[0]]\n if logp1:\n pstr1 = r'log$_\\textrm{10}$('+pstr1+')'\n\n cb1.set_label(pstr1+' (outer circle) - Fixed: black line')\n\n for p1 in np.unique(param1):\n p1col = cmap(colnorm(p1))\n p1ent = np.where(param1 == p1)\n\n plt.plot(lum1[p1ent],lum2[p1ent],'-',lw=lthick, color='k',zorder=1)\n\n plt.errorbar(lum1[p1ent],lum2[p1ent],xerr=None,yerr=None,\n marker='o',lw=0, markersize=marksize*3,\n markerfacecolor=p1col,ecolor=p1col,markeredgecolor = 'k',zorder=10)\n\n # ------------ PARAM2 ------------\n cmap = plt.cm.get_cmap('spring')\n cmin = np.min(param2)\n cmax = np.max(param2)\n colnorm = matplotlib.colors.Normalize(vmin=cmin,vmax=cmax)\n cmaparr = np.linspace(cmin, cmax, 30) #cmax-cmin)\n mm = plt.cm.ScalarMappable(cmap=cmap)\n mm.set_array(cmaparr)\n cb2 = plt.colorbar(mm)#shrink=0.25\n\n pstr2 = legenddic[freeparam[1]]\n if logp2:\n pstr2 = 'log10('+pstr2+')'\n\n cb2.set_label(pstr2+' (inner circle) - Fixed: gray line')\n\n for p2 in np.unique(param2):\n p2col = cmap(colnorm(p2))\n p2ent = np.where(param2 == p2)\n\n plt.plot(lum1[p2ent],lum2[p2ent],'-',lw=lthick, color='gray',zorder=2)\n\n plt.errorbar(lum1[p2ent],lum2[p2ent],xerr=None,yerr=None,\n marker='o',lw=0, markersize=marksize*1.5,\n markerfacecolor=p2col,ecolor=p2col,markeredgecolor = 'k',zorder=20)\n\n if showobs != None:\n for ii, objid in enumerate(showobs[:,0]):\n if (showobs[:,7][ii] > xrange[0]) & (showobs[:,7][ii] < xrange[1]) & \\\n (showobs[:,9][ii] > yrange[0]) & (showobs[:,9][ii] < yrange[1]):\n\n if noobserr:\n obsxerr = None\n obsyerr = None\n else:\n obsxerr = showobs[:,8][ii]\n obsyerr = showobs[:,10][ii]\n plt.errorbar(showobs[:,7][ii],showobs[:,9][ii],xerr=obsxerr,yerr=obsyerr,\n marker='*',lw=lthick, markersize=marksize*2,\n markerfacecolor='k',ecolor='k',markeredgecolor = 'k',zorder=30)\n\n plt.xlabel(r'L$_\\textrm{'+line1+r'}$ / [3.826$\\times$1e33 erg/s]/[Msun/yr]')\n plt.ylabel(r'L$_\\textrm{'+line2+r'}$ / [3.826$\\times$1e33 erg/s]/[Msun/yr]')\n\n plt.xlim(xrange)\n plt.ylim(yrange)\n\n if logx:\n plt.xscale('log')\n if logy:\n plt.yscale('log')\n\n #--------- LEGEND ---------\n # plt.errorbar(-1,-1,xerr=None,yerr=None,fmt='o',lw=lthick,ecolor='white', markersize=marksize*2,\n # markerfacecolor='white',markeredgecolor = 'k',label='Ground-based spec')\n #\n # leg = plt.legend(fancybox=True, loc='upper center',prop={'size':Fsize},ncol=1,numpoints=1)\n # #bbox_to_anchor=(1.25, 1.03)) # add the legend\n # leg.get_frame().set_alpha(0.7)\n #--------------------------\n\n if verbose: print(' Saving plot to'+plotname)\n plt.savefig(plotname)\n plt.clf()\n plt.close('all')","def label_2d_latent(model,data_loader,embeddings=False):\n model.eval()\n plt.style.use('seaborn')\n fig, ax = plt.subplots(dpi=100)\n for batch_idx, (data,target) in enumerate(data_loader):\n data = data.float()\n z, recon_batch, mu, logvar = model(data.view(-1,numpy.prod(data.shape[-2:])))\n z = z.data.cpu().numpy()\n plt.scatter(z[:,0],z[:,1],s=10,c=target,cmap='cool',alpha=0.5)\n if embeddings:\n for i,img in enumerate(data):\n imagebox = OffsetImage(data[i,0], zoom=0.4)\n ab = AnnotationBbox(imagebox, (z[i,0], z[i,1]),frameon=False)\n ax.add_artist(ab)\n plt.xlabel('Latent variable 1')\n plt.ylabel('Latent variable 2')\n plt.tight_layout()","def convert_mel_spectrogram_to_linear(self, mel: 'torch.tensor', **kwargs) -> 'torch.tensor':","def plot_lshell_map(self, fitResultsDF,\\\n baseDir=\"/home/bharat/Documents/code/new-vel-data/fit-figs/\"):\n import seaborn as sns\n import matplotlib.pyplot as plt\n from matplotlib.colors import ListedColormap\n from matplotlib.colors import Normalize\n # Seaborn styling\n sns.set_style(\"darkgrid\")\n sns.set_context(\"paper\")\n seaMap = ListedColormap(sns.color_palette(\"RdPu\"))\n vLosSeaMap = ListedColormap(sns.color_palette(\"Spectral\"))\n # Plot using matplotlib\n fig = plt.figure()\n ax1 = fig.add_subplot(211)\n self.sapsVelsDF.plot( kind='scatter',\n x='normMLT',\n y='MLAT',\n c='vLos',\n s=20., cmap=vLosSeaMap, ax=ax1)\n ax1.set_ylabel(\"MLAT\")\n ax1.set_xlabel(\"MLT\", fontsize=12)\n ax1.set_title( \"Velocities\" )\n velScaleMax = 2000.\n velScaleMin = 0.\n colNorm = Normalize( vmin=velScaleMin, vmax=velScaleMax )\n for frRows in fitResultsDF.iterrows():\n # Plot Velocity vectors\n currCol = seaMap( colNorm(frRows[1][\"velSAPS\"]) )\n if frRows[1][\"goodFit\"]:\n \n ax1.plot( [ frRows[1][\"normMlt\"] , frRows[1][\"endPtNormMLT\"] ],\\\n [ frRows[1][\"mlat\"], frRows[1][\"endPtMLAT\"] ],\\\n color=currCol ) \n ax1.arrow( frRows[1][\"normMlt\"], frRows[1][\"mlat\"], \\\n frRows[1][\"endPtNormMLT\"]-frRows[1][\"normMlt\"],\\\n frRows[1][\"endPtMLAT\"]-frRows[1][\"mlat\"],\\\n head_width=0.1, head_length=0.2, fc=currCol,\\\n ec=currCol)\n else:\n ax1.plot( [ frRows[1][\"normMlt\"] , frRows[1][\"endPtNormMLT\"] ],\\\n [ frRows[1][\"mlat\"], frRows[1][\"endPtMLAT\"] ],\\\n color=currCol, linestyle='dotted') \n ax1.arrow( frRows[1][\"normMlt\"], frRows[1][\"mlat\"], \\\n frRows[1][\"endPtNormMLT\"]-frRows[1][\"normMlt\"],\\\n frRows[1][\"endPtMLAT\"]-frRows[1][\"mlat\"],\\\n head_width=0.1, head_length=0.2, fc=currCol,\\\n ec=currCol, linestyle='dotted')\n # Plot azim\n ax2 = fig.add_subplot(212)\n self.sapsVelsDF.plot( kind='scatter',\n x='normMLT',\n y='MLAT',\n c=self.fitAzmType,\n s=20., cmap=seaMap, ax=ax2)\n ax2.set_ylabel(\"MLAT\")\n ax2.set_xlabel(\"MLT\", fontsize=12)\n ax2.set_title( \"Azim\" )\n figName = baseDir + \"lmap-\" + pandas.to_datetime(str(self.inpTime)).strftime(\"%Y%m%d\") +\\\n \"-\" + pandas.to_datetime(str(self.inpTime)).strftime(\"%H%M\") + \".pdf\"\n fig.savefig( figName,bbox_inches='tight' ) \n plt.close('all')","def make_kin_summary(loess=False, contours=\"vband\", format=\"png\",\r\n sn_lims=None, sn_loess=None, sn_sig=True):\r\n ##########################################################################\r\n # Set the limits for the S/N in case it is not defined by the user\r\n # sn_cut is defined in the setup_n3311 file\r\n if sn_lims == None:\r\n sn_lims = [sn_cut] * 4\r\n ##########################################################################\r\n # In case of LOESS smoothing, set the smoothing region (S/N < sn_loess)\r\n if sn_loess == None:\r\n sn_loess = [25, 25, 25, 25]\r\n ##########################################################################\r\n # Read data values for Lick indices\r\n data = np.loadtxt(outtable, usecols=(5, 7, 9, 11)).T\r\n # Read spectra name\r\n s = np.genfromtxt(outtable, usecols=(0,), dtype=None).tolist()\r\n ########################################################\r\n # Read coords and S/N\r\n xall, yall, sn = np.loadtxt(outtable, usecols=(1, 2, 14)).T\r\n ##########################################################\r\n # If using S/N / sigma instead of S/N\r\n if sn_sig == True:\r\n sn /= data[1] / 100.\r\n ########################################################\r\n # Read values of other authors\r\n tab1a, tab1b = get_richtler()\r\n tab2 = get_ventimiglia()\r\n ###############################################\r\n # Details of the maps\r\n # Name to be displayed during processing\r\n titles = [r\"velocity\", r\"sigma\", r\"h3\", r\"h4\"]\r\n # Tex strings to be used in labels\r\n cb_label = [r\"V$_{\\rm LOS}$ [km/s]\", r\"$\\sigma_{\\rm LOS}$ [km/s]\",\r\n r\"$h_3$\", r\"$h_4$\"]\r\n # Ranges of the plots\r\n # lims = [[3750, 4000], [200, 500], [None, None], [None, None]]\r\n lims = [[3700, 4100], [180, 500], [-0.08, 0.08], [-0.05, 0.11]]\r\n # Position of the colorbars\r\n xcb = [0.075, 0.555]\r\n xcb = xcb + xcb\r\n yc1 = 0.56\r\n yc2 = 0.085\r\n ycb = [yc1, yc1, yc2, yc2]\r\n # Colormap\r\n cmap = \"Spectral_r\"\r\n ylabels = [1, 0, 1, 0]\r\n xlabels = [0, 0, 1, 1]\r\n cb_fmts = [\"%d\", \"%d\", \"%.2f\", \"%.2f\"]\r\n ###############################################\r\n # Initialize figure and subplots\r\n fig = plt.figure(figsize=(12.5, 12))\r\n gs = gridspec.GridSpec(2, 2)\r\n gs.update(left=0.045, right=0.988, bottom=0.05, top=0.99, hspace=0.03,\r\n wspace=0.03)\r\n # Loop for figures\r\n for i, vector in enumerate(data):\r\n print \"Producing figure for {0}...\".format(titles[i])\r\n good = np.where(((~np.isnan(vector)) & (sn > sn_lims[i])))[0]\r\n if loess:\r\n sn_high = np.where(((~np.isnan(vector)) & (sn >= sn_loess[i])))[0]\r\n sn_low = np.delete(good, sn_high)\r\n vector_low = ll.loess_2d(xall[sn_low], yall[sn_low],\r\n vector[sn_low], frac=frac_loess)\r\n vector_high = vector[sn_high]\r\n good = np.hstack((sn_high, sn_low))\r\n v = np.hstack((vector_high, vector_low))\r\n else:\r\n v = vector[good]\r\n mad = 1.4826 * np.median(np.abs(v - np.median(v)))\r\n ######################################################################\r\n # Set limits according to median deviation if not defined in lims\r\n vmin = np.median(v) - 1.5 * mad if lims[i][0] == None else lims[i][0]\r\n vmax = np.median(v) + 1.5 * mad if lims[i][0] == None else lims[i][1]\r\n norm = Normalize(vmin=vmin, vmax=vmax)\r\n ######################################################################\r\n ax = plt.subplot(gs[i])\r\n coll = PolyCollection(polygons_bins[good], array=v, cmap=cmap,\r\n edgecolors='w', norm=norm)\r\n draw_map(fig, ax, coll)\r\n draw_contours(contours, fig, ax)\r\n plt.gca().add_patch(Rectangle((18, -36), 20, 10, alpha=1, zorder=1000,\r\n color=\"w\"))\r\n draw_colorbar(fig, ax, coll, cblabel=cb_label[i],\r\n cbar_pos=[xcb[i], ycb[i], 0.09, 0.02],\r\n ticks=np.linspace(vmin, vmax, 4), cb_fmt=cb_fmts[i],\r\n labelsize=12)\r\n xylabels(ax, y=ylabels[i], x=xlabels[i])\r\n if i not in [0, 2]:\r\n ax.set_yticklabels([])\r\n if i < 2:\r\n ax.set_xticklabels([])\r\n #####################################################\r\n # Draw long slits of other papers\r\n #####################################################\r\n if i > 1:\r\n continue\r\n bc = [\"g\", \"g\", \"b\", \"b\"]\r\n for k, tab in enumerate([tab1a, tab1b, tab2[4:], tab2[:4]]):\r\n norm = Normalize(vmin=vmin, vmax=vmax)\r\n idx = np.argsort(tab[:, 0])\r\n points = np.array([tab[:, 0][idx], tab[:, 1][idx]]).T.reshape(-1,\r\n 1, 2)\r\n segments = np.concatenate([points[:-1], points[1:]],\r\n axis=1)\r\n lc = LineCollection(segments, array=tab[:, i + 2],\r\n cmap=\"cubelaw\", norm=norm, lw=5)\r\n ax.add_collection(lc)\r\n add_borders(ax, points, c=bc[k])\r\n nloess = \"_loess\" if loess else \"\"\r\n plt.savefig(\"figs/kinmaps{0}_{1}.{2}\".format(nloess, contours, format),\r\n dpi=100)\r\n return","def embedding_plot(model,datapath,img_size=100,stride=10,sample_size=1,nrand=None,adjust=True,show_images=True):\n data = set_creation(datapath,img_size,stride,sample_size,nrand=nrand,adjust=adjust)\n model.eval()\n z = model(data[:nrand].float())[-1]\n z = z.data.cpu().numpy()\n plt.style.use('seaborn')\n fig, ax = plt.subplots(dpi=100)\n plt.scatter(z[:,0,0], z[:,0,1])\n if show_images:\n for i in range(len(z)):\n imagebox = OffsetImage(data[i,0], zoom=0.4)\n ab = AnnotationBbox(imagebox, (z[i,0,0], z[i,0,1]),frameon=False)\n ax.add_artist(ab)\n plt.xlabel('Latent variable 1')\n plt.ylabel('Latent variable 2')\n plt.tight_layout()","def LLEEmbedding(TurosR=10,Torusr=4,Classes=[3,5,7],nei=[5,10,20], DataSet = {'Turos', 'Digits'}):\n\n S, dig = CreateDS_Torus_Digits(TurosR=TurosR,Torusr=Torusr,Classes=[3,5,7])\n ### ------ LLE ------###\n nei = nei\n\n if 'Turos' in DataSet:\n # Plotting Torus\n fig = plt.figure(figsize=(30, 10))\n for i,j in enumerate(nei):\n Torus_LLE = LLE(S,2,j)\n neighbors = j\n method = 'Torus LLE'\n ax = fig.add_subplot(1, len(nei), i + 1)\n scatter = ax.scatter(Torus_LLE[:, 0], Torus_LLE[:, 1], c=S[:, 0:1], cmap=plt.cm.Spectral)\n # legend = ax.legend(*scatter.legend_elements(), loc=\"lower left\", title=\"Classes\")\n # ax.add_artist(legend)\n # ax.legend()\n ax.set_title('{} with {} Neighbours'.format(method, neighbors))\n # making_plot(Torus_LLE, pallete=S[:, 0:1], neighbors=j, method='Torus LLE') #An option to plot single graphs\n plt.savefig('Torus LLE embbeding for {} neighbour'.format(neighbors))\n\n if 'Digits' in DataSet:\n #Plotting Digits\n for Argclass, Specificcalss in enumerate(dig):\n fig = plt.figure(figsize=(30,10))\n for i,j in enumerate(nei):\n neighbors = j\n Digit_LLE = LLE(Specificcalss[0],2,j)\n method = 'Digit LLE'\n ax = fig.add_subplot(1, len(nei), i + 1)\n scatter = ax.scatter(Digit_LLE[:, 0], Digit_LLE[:, 1], c=Specificcalss[1], cmap=plt.cm.Spectral)\n legend = ax.legend(*scatter.legend_elements(), loc=\"lower left\", title=\"Classes\")\n ax.add_artist(legend)\n ax.legend()\n ax.set_title('{} with {} Neighbours'.format(method, neighbors))\n # making_plot(Digit_isomap, Specificcalss[1], neighbors=j, method='Digit ISOMAP') #An option to plot single graphs\n plt.savefig('Digits up to {} - LLE embbeding for {} neighbour'.format(Classes[Argclass], nei))","def parse_lsg_model(lsg_model, plot_it=True):\n df = pd.DataFrame(lsg_model.train_history_)\n if plot_it:\n ggplot(aes(x='epoch', y='valid_loss'), data=df) + geom_line()\n return df","def plot_lasso_path(df, resp_var, exp_vars):\n import numpy as np\n import pandas as pd\n import matplotlib.pyplot as plt\n import mpld3\n from mpld3 import plugins\n from sklearn.preprocessing import StandardScaler\n from sklearn.linear_model import lasso_path\n\n # Standardise the feature data and response\n feat_std = StandardScaler().fit_transform(df[[resp_var,] + exp_vars])\n \n # Calculate lasso path\n alphas, coefs, _ = lasso_path(feat_std[:, 1:], # X\n feat_std[:, 0], # y\n eps=1e-3, # Path length\n fit_intercept=False) # Already centred\n\n # -Log(alphas) is easier for display\n neg_log_alphas = -np.log10(alphas)\n\n # Build df of results\n res_df = pd.DataFrame(data=coefs.T, index=alphas, columns=exp_vars)\n \n # Plot\n fig, ax = plt.subplots()\n\n for coef, name in zip(coefs, exp_vars):\n line = ax.plot(neg_log_alphas, coef, label=name)\n plugins.connect(fig, plugins.LineLabelTooltip(line[0], label=name))\n\n plt.xlabel('-Log(alpha)')\n plt.ylabel('Coefficients')\n plt.title('Lasso paths')\n plt.legend(loc='best', title='', ncol=3) \n \n return res_df, fig","def visualize_model():\n dictionary_vis = gensim.corpora.Dictionary.load('dictionary.gensim')\n corpus_vis = pickle.load(open('corpus.pkl', 'rb'))\n lda = gensim.models.ldamodel.LdaModel.load('model5.gensim')\n lda_display = pyLDAvis.gensim.prepare(lda, corpus_vis, dictionary_vis,\n sort_topics=False)\n pyLDAvis.display(lda_display)","def plot_latents(model, data, mode='ae'):\n latents = []\n labels = []\n for i, batch in enumerate(data):\n imgs, digits = batch \n imgs = imgs.squeeze(1).reshape(-1, 28*28)\n if mode == 'ae':\n embeds, _ = model(imgs)\n if mode == 'vae':\n embeds, _,_,_ = model(imgs)\n embeds = embeds.detach().numpy().tolist()\n digits = digits.detach().numpy().tolist()\n latents.extend(embeds)\n labels.extend(digits)\n latents = np.asarray(latents)\n print(f\"Labels:{len(labels)}, Data:{len(latents)}\")\n plt.scatter(latents[:,0], latents[:,1], c=labels, cmap='tab10')\n plt.colorbar()","def make_los_velocity_map(time: u.s, field, instr, **kwargs):\n plot_settings = {'cmap': cm.get_cmap('bwr'),\n 'norm': colors.SymLogNorm(10, vmin=-1e8, vmax=1e8)}\n plot_settings.update(kwargs.get('plot_settings', {}))\n\n bins, bin_range = instr.make_detector_array(field)\n visible = is_visible(instr.total_coordinates, instr.observer_coordinate)\n hist_coordinates, _, _ = np.histogram2d(instr.total_coordinates.Tx.value,\n instr.total_coordinates.Ty.value,\n bins=(bins.x.value, bins.y.value),\n range=(bin_range.x.value, bin_range.y.value),\n weights=visible)\n with h5py.File(instr.counts_file, 'r') as hf:\n try:\n i_time = np.where(u.Quantity(hf['time'],\n get_keys(hf['time'].attrs), ('unit', 'units')) == time)[0][0]\n except IndexError:\n raise IndexError(f'{time} is not a valid time in observing time for {instr.name}')\n v_x = u.Quantity(hf['velocity_x'][i_time, :],\n get_keys(hf['velocity_x'].attrs, ('unit', 'units')))\n v_y = u.Quantity(hf['velocity_y'][i_time, :],\n get_keys(hf['velocity_y'].attrs, ('unit', 'units')))\n v_z = u.Quantity(hf['velocity_z'][i_time, :],\n get_keys(hf['velocity_z'].attrs, ('unit', 'units')))\n v_los = instr.los_velocity(v_x, v_y, v_z)\n\n hist, _, _ = np.histogram2d(instr.total_coordinates.Tx.value,\n instr.total_coordinates.Ty.value,\n bins=(bins.x.value, bins.y.value),\n range=(bin_range.x.value, bin_range.y.value),\n weights=v_los.value * visible)\n hist /= np.where(hist_coordinates == 0, 1, hist_coordinates)\n meta = instr.make_fits_header(field, instr.channels[0])\n del meta['wavelnth']\n del meta['waveunit']\n meta['bunit'] = v_los.unit.to_string()\n meta['detector'] = 'LOS Velocity'\n meta['comment'] = 'LOS velocity calculated by synthesizAR'\n\n return GenericMap(hist.T, meta, plot_settings=plot_settings)","def main():\n\n \"\"\"\n Initialize Parameters\n \"\"\"\n src_path_map = '../data/map/wean.dat'\n src_path_log = '../data/log/robotdata1.log'\n\n map_obj = MapReader(src_path_map)\n occupancy_map = map_obj.get_map()\n logfile = open(src_path_log, 'r')\n\n motion_model = MotionModel()\n params = {\n 'z_max': 8000,\n 'lambda_short': 0.1,\n 'sigma_hit': 20,\n\n 'z_pHit': 0.95,\n 'z_pShort': 0.01,\n 'z_pMax': 0.05,\n 'z_pRand': 0.05,\n\n 'laser_sensor_offset': 25.0,\n 'ray_step_size': 2,\n 'grid_size': 10,\n 'occ_thrsh': 0.1,\n 'laser_subsample': 30,\n\n 'rayCast_vis': False,\n 'map_vis': True\n }\n sensor_model = SensorModel(occupancy_map, params)\n resampler = Resampling()\n\n num_particles = 1500\n X_bar = init_particles_freespace(num_particles, occupancy_map)\n vis_flag = 1\n\n \"\"\"\n Monte Carlo Localization Algorithm : Main Loop\n \"\"\"\n if vis_flag:\n visualize_map(occupancy_map)\n\n first_time_idx = True\n for time_idx, line in enumerate(logfile):\n\n # Read a single 'line' from the log file (can be either odometry or laser measurement)\n meas_type = line[0] # L : laser scan measurement, O : odometry measurement\n meas_vals = np.fromstring(line[2:], dtype=np.float64,\n sep=' ') # convert measurement values from string to double\n\n odometry_robot = meas_vals[0:3] # odometry reading [x, y, theta] in odometry frame\n time_stamp = meas_vals[-1]\n\n # if ((time_stamp <= 0.0) | (meas_type == \"O\")): # ignore pure odometry measurements for now (faster debugging) \n # continue\n\n if (meas_type == \"L\"):\n odometry_laser = meas_vals[3:6] # [x, y, theta] coordinates of laser in odometry frame\n ranges = meas_vals[6:-1] # 180 range measurement values from single laser scan\n\n print(\"Processing time step \" + str(time_idx) + \" at time \" + str(time_stamp) + \"s\")\n\n if (first_time_idx):\n u_t0 = odometry_robot\n first_time_idx = False\n continue\n\n X_bar_new = np.zeros((num_particles, 4), dtype=np.float64)\n u_t1 = odometry_robot\n for m in range(0, num_particles):\n\n \"\"\"\n MOTION MODEL\n \"\"\"\n x_t0 = X_bar[m, 0:3]\n x_t1 = motion_model.update(u_t0, u_t1, x_t0)\n\n \"\"\"\n SENSOR MODEL\n \"\"\"\n if (meas_type == \"L\"):\n z_t = ranges\n w_t = sensor_model.beam_range_finder_model(z_t, x_t1)\n # w_t = 1/num_particles\n X_bar_new[m, :] = np.hstack((x_t1, w_t))\n else:\n X_bar_new[m, :] = np.hstack((x_t1, X_bar[m, 3]))\n\n X_bar = X_bar_new\n u_t0 = u_t1\n\n \"\"\"\n RESAMPLING\n \"\"\"\n X_bar = resampler.low_variance_sampler(X_bar)\n if vis_flag:\n visualize_timestep(X_bar)","def make_kinematics():\r\n # Read data values for vel, sigma, h3, h4\r\n data = np.loadtxt(outtable, usecols=(5, 7, 9, 11)).T\r\n xall, yall, sn = np.loadtxt(outtable, usecols=(1, 2, 14,)).T\r\n ###########################################################################\r\n # Details of the maps\r\n names = [r\"vel\", r\"sigma\", r\"h3\", r\"h4\"]\r\n cb_label = [r\"V$_{\\rm LOS}$ (km/s)\", r\"$\\sigma_{\\rm LOS}$ (km/s)\",\r\n r\"$h_3$\", r\"$h_4$\"]\r\n # lims = [[3750,4000], [150,500], [-0.08, 0.08], [-0.15, 0.15] ]\r\n lims = [[3640, 4040], [220, 500], [-0.08, 0.08], [-0.11, 0.11]]\r\n xcb = [0.068, 0.385, 0.705]\r\n ###########################################################################\r\n # Set the threshold S/N for smoothing\r\n # Higher values than this values are not smoothed\r\n sn_thres = [50, 50, 1000, 1000]\r\n ###########################################################################\r\n # Read values of other authors\r\n tab1a, tab1b = get_richtler()\r\n tab2 = get_ventimiglia()\r\n ###########################################################################\r\n # Set the colormap\r\n cmap = \"Spectral_r\"\r\n ###########################################################################\r\n # Loop for figures\r\n for i, vector in enumerate(data):\r\n print \"Producing figure for {0}...\".format(names[i])\r\n good = np.where(((~np.isnan(vector)) & (sn > sn_cut)))[0]\r\n sn_high = np.where(((~np.isnan(vector)) & (sn >= sn_thres[i])))[0]\r\n sn_low = np.delete(good, sn_high)\r\n vector_low = ll.loess_2d(xall[sn_low], yall[sn_low], vector[sn_low],\r\n frac=frac_loess)\r\n vector_high = vector[sn_high]\r\n good = np.hstack((sn_high, sn_low))\r\n v_loess = np.hstack((vector_high, vector_low))\r\n v = vector[good]\r\n vmin = lims[i][0] if lims[i][0] else v_loess.min()\r\n vmax = lims[i][1] if lims[i][1] else v_loess.max()\r\n fig = plt.figure(figsize=(15, 5.1))\r\n gs = gridspec.GridSpec(1, 3)\r\n gs.update(left=0.051, right=0.985, bottom=0.11, top=0.975, hspace=0.06,\r\n wspace=0.06)\r\n vs = [v, v_loess, v_loess]\r\n ylabels = [1, 0, 0]\r\n contours = [\"vband\", \"vband\", \"residual\"]\r\n cb_fmts = [\"%i\", \"%i\", \"%.2f\", \"%.2f\"]\r\n ####################################################\r\n # Produces pannels\r\n ####################################################\r\n for j in range(3):\r\n ax = plt.subplot(gs[j])\r\n # if i <1:\r\n # norm = LogNorm(vmin=vmin, vmax=vmax)\r\n # else:\r\n # norm = Normalize(vmin=vmin, vmax=vmax)\r\n norm = Normalize(vmin=vmin, vmax=vmax)\r\n coll = PolyCollection(polygons_bins[good], array=vs[j],\r\n cmap=cmap, edgecolors='w', norm=norm,\r\n linewidths=0.4)\r\n draw_map(fig, ax, coll)\r\n draw_contours(contours[j], fig, ax)\r\n plt.gca().add_patch(\r\n Rectangle((18, -36), 20, 10, alpha=1, zorder=10000,\r\n color=\"w\"))\r\n draw_colorbar(fig, ax, coll, cblabel=cb_label[i],\r\n cbar_pos=[xcb[j], 0.18, 0.08, 0.04],\r\n ticks=np.linspace(vmin, vmax, 4), cb_fmt=cb_fmts[i])\r\n xylabels(ax, y=ylabels[j])\r\n if j > 0:\r\n ax.set_yticklabels([])\r\n #####################################################\r\n # Draw long slits of other papers\r\n #####################################################\r\n if i > 1:\r\n continue\r\n bc = [\"g\", \"g\", \"b\", \"b\"]\r\n for k, tab in enumerate([tab1a, tab1b, tab2[4:], tab2[:4]]):\r\n norm = Normalize(vmin=vmin, vmax=vmax)\r\n idx = np.argsort(tab[:, 0])\r\n points = np.array([tab[:, 0][idx], tab[:, 1][idx]]).T.reshape(\r\n -1, 1, 2)\r\n segments = np.concatenate([points[:-1], points[1:]],\r\n axis=1)\r\n lc = LineCollection(segments, array=tab[:, i + 2],\r\n cmap=cmap, norm=norm, lw=5)\r\n ax.add_collection(lc)\r\n add_borders(ax, points, c=bc[k])\r\n # plt.savefig(\"figs/{0}.pdf\".format(names[i]))\r\n plt.savefig(\"figs/{0}.png\".format(names[i]))\r\n # plt.savefig(\"figs/{0}.eps\".format(names[i]), fmt=\"eps\")\r","def plot_NHI_model(lls_dict, ax, lsz=12., touch=False, scl=1., csz=10.):\n from linetools.spectra.plotting import get_flux_plotrange\n\n spec, xspec, gdp, NHI, tau0 = setup_lls_fit_analy(lls_dict['spec_fil'], lls_dict['z'], lls_dict['windows'], lls_dict['NHI_mnx'])\n # Scale\n xspec.data['flux'] *= scl\n # Limits\n xmnx = [lls_dict['windows'][0][0], 940.*(1+lls_dict['z'])]\n if lls_dict['cdict']['type'] == 'Gaussian':\n ymnx = [-1*lls_dict['cdict']['sig'], lls_dict['cdict']['best']+4*lls_dict['cdict']['sig']]\n elif lls_dict['cdict']['type'] == 'Fixed':\n ymnx = [-0.1*lls_dict['cdict']['value'], 1.5*lls_dict['cdict']['value']]\n elif lls_dict['cdict']['type'] == 'Fit_const':\n ymnx = [-1*(lls_dict['cdict']['fit_val'][0]-lls_dict['cdict']['fit_val'][1]),\n 3*(lls_dict['cdict']['fit_val'][2]-lls_dict['cdict']['fit_val'][0])+\n lls_dict['cdict']['fit_val'][0]]\n elif lls_dict['cdict']['type'] == 'Fit_line':\n if gdp is None:\n gdp = (xspec.wavelength>xmnx[0]*u.AA) & (xspec.wavelength<xmnx[1]*u.AA)\n conti = lls_dict['cdict']['best'][0] + lls_dict['cdict']['best'][1]*(\n xspec.wavelength[gdp].value-lls_dict['cdict']['slope_pivot']*(1+lls_dict['z']))\n mx = np.max(conti)\n ymnx = [-0.1*mx, mx*1.3]\n else:\n raise ValueError(\"Need to setup this continuum model\")\n # Extend xmnx\n if lls_dict['cdict']['type'] in ['Fit_line', 'Fit_const']:\n xmx = 0.\n for rng in lls_dict['cdict']['analy']:\n xmx = max(xmx, rng[1])\n xmnx[1] = xmx+3.\n # Scale\n ymnx = np.array(ymnx)*scl\n # Finally\n #idx = (xspec.wavelength > xmnx[0]*u.AA) & (xspec.wavelength < xmnx[1]*u.AA)\n idx = gdp\n f_ymnx = get_flux_plotrange(xspec.flux[idx].value)\n ymnx[1] = max(ymnx[1],f_ymnx[1])\n\n\n # Axes\n #ax.xaxis.set_minor_locator(plt.MultipleLocator(0.5))\n ax.xaxis.set_major_locator(plt.MultipleLocator(20.))\n #ax.yaxis.set_minor_locator(plt.MultipleLocator(0.1))\n #ax.yaxis.set_major_locator(plt.MultipleLocator(0.2))\n ax.set_xlim(xmnx)\n ax.set_ylim(ymnx)\n if scl == 1.:\n ax.set_ylabel(r'$f_\\lambda$ (cgs)', size=lsz)\n else:\n ax.set_ylabel(r'$f_\\lambda$ ($10^{-15}$ cgs)', size=lsz)\n\n\n # Plot data\n ax.plot(xspec.wavelength, xspec.flux, color='black', drawstyle='steps-mid',\n zorder=2)\n try:\n ax.plot(xspec.wavelength, scl*xspec.sig, ':', color='red', zorder=1)\n except ValueError:\n pdb.set_trace()\n\n # Binned\n if False:\n binsz = 5.\n binwv = np.arange(1040., 1200., binsz)*u.AA\n binspec = xspec.rebin(binwv)\n gdp = binspec.wavelength.value < 910.*(1+lls_dict['z'])\n ax.scatter(binspec.wavelength.value[gdp]+binsz/2., binspec.flux[gdp],\n color='yellow', zorder=300)\n #edgecolor='none')#, alpha=0.5)\n\n # Best continuum\n if lls_dict['cdict']['type'] == 'Gaussian':\n conti = lls_dict['cdict']['best']*np.ones_like(xspec.flux.value)\n elif lls_dict['cdict']['type'] == 'Fixed':\n conti = lls_dict['cdict']['value']*np.ones_like(xspec.flux.value)\n elif lls_dict['cdict']['type'] == 'Fit_const':\n conti = lls_dict['cdict']['fit_val'][0]*np.ones_like(xspec.flux.value)\n elif lls_dict['cdict']['type'] == 'Fit_line':\n conti = lls_dict['cdict']['best'][0] + lls_dict['cdict']['best'][1]*(\n xspec.wavelength.value-lls_dict['cdict']['slope_pivot']*(1+lls_dict['z']))\n ax.plot(xspec.wavelength, conti*scl, '--', color='green', zorder=3)\n ax.minorticks_on()\n if touch is True:\n pass\n #ax.get_xaxis().set_ticks([])\n else:\n ax.set_xlabel('Wavelength (Ang)', size=lsz)\n\n # Best Model\n mclr = 'lightblue'\n wv_rest = xspec.wavelength / (lls_dict['z']+1)\n energy = wv_rest.to(u.eV, equivalencies=u.spectral())\n tau0 = (10.**lls_dict['fit_NHI'][0] / u.cm**2) * ltaa.photo_cross(1, 1, energy)\n if lls_dict['analy_type'] in ['Fit_Conti', 'Vary_Conti']:\n if lls_dict['fit_NHI'][0] != lls_dict['fit_NHI'][2]:\n best_model = scl*conti * np.exp(-1*tau0)\n abs = tau0 > 0.\n ax.plot(xspec.wavelength[abs], best_model[abs], color=mclr, zorder=100)\n\n # Continuum Error\n clr_ce = 'lightgreen'\n alpha_ce = 0.4\n if lls_dict['cdict']['type'] == 'Gaussian':\n cwv = tau0 == 0.\n npix = np.sum(cwv)\n ax.fill_between(xspec.wavelength.value[cwv],\n [scl*lls_dict['cdict']['best']+lls_dict['cdict']['sig']]*npix,\n [scl*lls_dict['cdict']['best']-lls_dict['cdict']['sig']]*npix,\n color=clr_ce, alpha=alpha_ce, zorder=50)\n elif lls_dict['cdict']['type'] == 'Fit_const':\n for rng in lls_dict['cdict']['analy']:\n idx = ((xspec.wavelength > rng[0]*u.AA) &\n (xspec.wavelength < rng[1]*u.AA) &\n (xspec.sig > 0))\n gdC = np.where(idx)[0]\n ax.fill_between(xspec.wavelength.value[gdC],\n [scl*lls_dict['cdict']['fit_val'][1]]*gdC.size,\n [scl*lls_dict['cdict']['fit_val'][2]]*gdC.size,\n color=clr_ce, alpha=alpha_ce, zorder=50)\n elif lls_dict['cdict']['type'] == 'Fit_line':\n #xdb.set_trace()\n if 'fit_val' in lls_dict['cdict']:\n for rng in lls_dict['cdict']['analy']:\n idx = ((xspec.wavelength > rng[0]*u.AA) &\n (xspec.wavelength < rng[1]*u.AA) &\n (xspec.sig > 0))\n gdC = np.where(idx)[0]\n #\n sig0 = (lls_dict['cdict']['fit_val'][0][2]-lls_dict['cdict']['fit_val'][0][1])/2.\n sig1 = (lls_dict['cdict']['fit_val'][1][2]-lls_dict['cdict']['fit_val'][1][1])/2.\n sigl = np.sqrt(sig0**2 +\n sig1**2*(lls_dict['cdict']['slope_pivot']*(1+lls_dict['z'])-\n xspec.wavelength.value[gdC])**2)\n ax.fill_between(xspec.wavelength.value[gdC],\n scl*(conti[gdC] + sigl),\n scl*(conti[gdC] - sigl),\n color=clr_ce, alpha=alpha_ce, zorder=50)\n\n # Model with error (limits too)\n taulow = (10.**lls_dict['fit_NHI'][1] / u.cm**2) * ltaa.photo_cross(1, 1, energy)\n try:\n low_model = scl*conti * np.exp(-1*taulow)\n except ValueError:\n pdb.set_trace()\n tauhi = (10.**lls_dict['fit_NHI'][2] / u.cm**2) * ltaa.photo_cross(1, 1, energy)\n hi_model = scl*conti * np.exp(-1*tauhi)\n mwv = tau0 > 0.\n ax.fill_between(xspec.wavelength.value[mwv], low_model[mwv],\n hi_model[mwv], color=mclr, alpha=0.3, zorder=100)\n\n # Finish\n ax.plot(xmnx, [0.,0.], '--', color='gray')","def spore_integrals():\n\n path_tops = os.path.join(path_to_here, '../data/landscape_visualizations/DMSO/{}/{}_hours')\n idx_epochs = [25, 30]\n repeat_names = ['original', 'repeat_a', 'repeat_b']\n pList_data = os.path.join(path_to_here, '../data/embeddings/lims13/lims13_DMSO.pickle')\n pList_data = _load_and_resize_list(pList_data)\n\n\n def _plot_from_idx_repeat(ax, repeat_name, idx_epoch, color, linewidth = 0.6, linestyle = '-'):\n if os.path.isfile(path_tops.format(repeat_name, idx_epoch) + '/p_list_0.pickle'):\n p_list_NN = _load_and_resize_list(path_tops.format(repeat_name, idx_epoch) + '/p_list_0.pickle')\n NN_spore_integrals = [np.sum(i[427:442, 182:196])*(26**2)/(1000**2) for i in p_list_NN]\n ax.plot([1, 2, 3, 4, 5, 6, 7, 8], NN_spore_integrals[1:], c = color, linewidth = linewidth)\n\n\n data_spore_integrals = [np.sum(i[427:442, 182:196])*(26**2)/(1000**2) for i in pList_data]\n\n fig = plt.figure(figsize = (2.3, 1.5))\n for i, idx_epoch in enumerate(idx_epochs):\n ax = fig.add_subplot(len(idx_epochs), 1, i+1)\n ax.plot([1, 2, 3, 4, 5, 6, 7, 8], data_spore_integrals[1:], linewidth = 1, c = 'red')\n if idx_epoch is not idx_epochs[-1]:\n ax.set_xticks([])\n for repeat_name, color in zip(repeat_names, ['blue', 'green', 'orange']):\n _plot_from_idx_repeat(ax = ax, repeat_name = repeat_name, idx_epoch = idx_epoch, color = color)\n if idx_epoch == idx_epochs[-1]:\n _plot_from_idx_repeat(ax = ax, repeat_name = 'original', idx_epoch = 60, color = 'black', linewidth = 1, linestyle = '--')\n\n ax.set_ylabel(r'$\\approx \\int_{spore} \\hat{p}(\\mathbf{x},t)$', fontsize = 6, labelpad = 1)\n ax.set_xlabel('Snapshot', fontsize = 6, labelpad = 1)\n for ax in fig.axes:\n ax.tick_params(axis = 'both', labelsize = 6)\n\n plt.subplots_adjust(hspace = 0)\n plt.tight_layout()\n plt.savefig(path_to_here+'/../outputs/'+'spore_integrals.png', dpi = 1200)","def process_dl_model(self, raw_dl_model, roi_scale=0.75, input_size=(28, 28)):\n # Redirect the information to console\n start_console()\n\n # Receive model\n raw_dl_model = raw_dl_model.split(\",\")[-1]\n raw_dl_model_bytes = raw_dl_model.encode('ascii')\n raw_dl_model_bytes = base64.b64decode(raw_dl_model_bytes)\n\n # Load ONNX model\n ort_session = None\n try:\n with open(self.aux_model_fname, \"wb\") as f:\n f.write(raw_dl_model_bytes)\n ort_session = onnxruntime.InferenceSession(self.aux_model_fname)\n except Exception:\n exc_type, exc_value, exc_traceback = sys.exc_info()\n print(str(exc_value))\n print(\"ERROR: Model couldn't be loaded\")\n\n try:\n # Init auxiliar variables used for stabilized predictions\n previous_pred = 0\n previous_established_pred = \"-\"\n count_same_digit = 0\n while not self.reload:\n start_time = datetime.now()\n start = time.time()\n\n # Get input webcam image\n input_image = self.hal.getImage()\n input_image_gray = np.mean(input_image, axis=2).astype(np.uint8)\n\n # Get original image and ROI dimensions\n h_in, w_in = input_image.shape[:2]\n min_dim_in = min(h_in, w_in)\n h_roi, w_roi = (int(min_dim_in * roi_scale), int(min_dim_in * roi_scale))\n h_border, w_border = (int((h_in - h_roi) / 2.), int((w_in - w_roi) / 2.))\n\n # Extract ROI and convert to tensor format required by the model\n roi = input_image_gray[h_border:h_border + h_roi, w_border:w_border + w_roi]\n roi_norm = (roi - np.mean(roi)) / np.std(roi)\n roi_resized = cv2.resize(roi_norm, input_size)\n input_tensor = roi_resized.reshape((1, 1, input_size[0], input_size[1])).astype(np.float32)\n\n # Inference\n ort_inputs = {ort_session.get_inputs()[0].name: input_tensor}\n output = ort_session.run(None, ort_inputs)[0]\n pred = int(np.argmax(output, axis=1)) # get the index of the max log-probability\n\n end = time.time()\n frame_time = round(end-start, 3)\n fps = 1.0/frame_time\n # number of consecutive frames that must be reached to consider a validprediction\n n_consecutive_frames = int(fps/2)\n\n # For stability, only show digit if detected in more than n consecutive frames\n if pred != previous_established_pred:\n if count_same_digit < n_consecutive_frames:\n if previous_pred == pred:\n count_same_digit += 1\n else:\n count_same_digit = 0\n previous_established_pred = \"-\" # no prediction\n else:\n print(\"Digit found: {}\".format(pred))\n previous_established_pred = pred\n count_same_digit = 0\n previous_pred = pred\n\n # Show region used as ROI\n cv2.rectangle(input_image,pt2=(w_border, h_border),pt1=(w_border + w_roi, h_border + h_roi),color=(255, 0, 0),thickness=3)\n # Show FPS count\n cv2.putText(input_image, \"FPS: {}\".format(int(fps)), (7,25), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255), 1)\n\n # Send result\n self.gui.showResult(input_image, str(previous_established_pred))\n\n # Template specifics to run!\n finish_time = datetime.now()\n dt = finish_time - start_time\n ms = (dt.days * 24 * 60 * 60 + dt.seconds) * 1000 + dt.microseconds / 1000.0\n\n self.iteration_counter += 1\n\n # The code should be run for atleast the target time step\n # If it's less put to sleep\n if (ms < self.time_cycle):\n time.sleep((self.time_cycle - ms) / 1000.0)\n\n close_console()\n print(\"Current Thread Joined!\")\n\n # To print the errors that the user submitted through the Javascript editor (ACE)\n except Exception:\n exc_type, exc_value, exc_traceback = sys.exc_info()\n print(str(exc_value))","def plotFilterOutputs(laplace_in=None, time_domain_fn=None, \n lp_range=(0,1e-3), hp_range=(0,1e-3), points=1e3,\n input_name=\"Input\"):\n \n t_lp = linspace(*lp_range,points)\n t_hp = linspace(*hp_range,points)\n\n \n if laplace_in != None:\n \n A,b,V_lowpass = lowpass(Vi=laplace_in)\n t_lp,y_lp = inverseLaplace(V_lowpass[-1],t=t_lp)\n \n \n A,b,V_highpass = highpass(Vi=laplace_in)\n t_hp,y_hp = inverseLaplace(V_highpass[-1],t=t_hp)\n \n elif time_domain_fn != None:\n \n A,b,V_lowpass = lowpass()\n lowsys = symToTransferFn(V_lowpass[-1])\n t_lp,y_lp,svec = sp.lsim(lowsys, time_domain_fn(t_lp), t_lp)\n \n \n A,b,V_highpass = highpass()\n highsys = symToTransferFn(V_highpass[-1])\n t_hp,y_hp,svec = sp.lsim(highsys, time_domain_fn(t_hp), t_hp)\n \n else:\n print(\"No input given.\")\n \n \n fig,axes = plt.subplots(1,2,figsize=(18,6))\n ax1,ax2 = axes[0],axes[1]\n \n # low pass response plot\n ax1.set_ylabel('$V_o$')\n ax1.set_xlabel('$t$')\n ax1.plot(t_lp,y_lp)\n ax1.grid()\n ax1.set_title(\"Response of low pass filter to {}\".format(input_name))\n \n # high pass response plot\n ax2.set_ylabel('$V_o$')\n ax2.set_xlabel('$t$')\n ax2.plot(t_hp,y_hp)\n ax2.grid()\n ax2.set_title(\"Response of high pass filter to {}\".format(input_name))\n \n plt.show()\n return t_lp,y_lp, t_hp,y_hp","def img_lex_disp(data_word,search):\n\n x_vals, y_vals = lex_disp(data_word,search)\n\n imgdata = BytesIO()\n fig, ax = plt.subplots()\n ax.plot(x_vals,y_vals,\"rx\")\n plt.ioff()\n plt.yticks(range(len(search)), search)\n plt.ylim(-1, len(search))\n plt.xlim(-1, len(data_word))\n plt.title(\"Lexical Dispersion Plot\")\n plt.xlabel(\"Word Offset\")\n plt.tight_layout()\n fig.savefig(imgdata, format = 'png', dpi = 200)\n\n return imgdata","def plot_visualization(path_results, x_data, y_data, variant_mode, nb_classes, signal_test, args):\n\n\t#path_tsne = path_results + \"/Visualization/train/\" + str(args.step) + \"_2d.csv\"\n\t#data_frame = pd.read_csv(path_tsne)\n\t\n\tpath_maping = path_results + \"/Maping/\" + str(args.subject).split(\".txt\")[0] + \"/\"\n\tfilename = path_maping + \"maping_\" + str(args.step) + \"_\" + str(args.subject).split(\".txt\")[0] + \"_stick\" + str(args.stick) + \".png\"\n\n\tprint(\"path_save maping\", path_maping)\n\n\tif not os.path.exists(path_maping):\n\t\tos.makedirs(path_maping)\n\n\t#print(\"path_tsne\", path_tsne)\n\n\tlabel_maping = np.array([10])\n\n\tx_data = np.concatenate((x_data,signal_test),axis=0)\n\ty_data = np.concatenate((y_data,label_maping),axis=0)\n\n\tprint(\"x_data concatenate\",x_data.shape)\n\tprint(\"y_data concatenate\",y_data.shape)\n\n\tdata_frame = tsne_2d(x_data, y_data)\n\n\t\n\t\n\tgroups = data_frame.groupby('label')\n\n\tcluster_names, cluster_colors = get_target_names_dr(nb_classes, args.mode, args, variant_mode)\n\n\tfig = plt.figure(figsize=(20, 10))\n\tax = fig.add_subplot(111)\n\tax.margins(0.05) # Optional, just adds 5% padding to the autoscaling\n\tfor name, group in groups:\n\t\t\n\t\tif cluster_names[name] == str(args.subject):\n\t\t\tax.scatter(group.x, group.y, marker='D', s=150, edgecolors = 'face',label=cluster_names[name], color=cluster_colors[name])\n\t\telse:\n\t\t\tax.scatter(group.x, group.y, marker='o', label=cluster_names[name], color=cluster_colors[name])\n\n\tax.legend(numpoints=1) #show legend with only 1 point\n\tplt.savefig(filename) #save the plot","def display4(*args):\n #-------------------- unpack\n twiss_func = args[0]\n cos_like = args[1]\n sin_like = args[2]\n lat_plot = args[3]\n #-------------------- beta x,y & dispersion x\n s = [twiss_func(i,'s') for i in range(twiss_func.nbpoints)] # Abszisse\n bx = [twiss_func(i,'bx') for i in range(twiss_func.nbpoints)] # beta x\n by = [twiss_func(i,'by') for i in range(twiss_func.nbpoints)] # beta y\n dx = [twiss_func(i,'dx') for i in range(twiss_func.nbpoints)] # dispersion x\n#-------------------- longitudinal trajectories\n z1= [cos_like(i,'s') for i in range(cos_like.nbpoints)]\n cz= [cos_like(i,'cz') for i in range(cos_like.nbpoints)]\n cdp= [cos_like(i,'cdp') for i in range(cos_like.nbpoints)]\n\n z2= [sin_like(i,'s') for i in range(sin_like.nbpoints)]\n sz= [sin_like(i,'sz') for i in range(sin_like.nbpoints)]\n sdp= [sin_like(i,'sdp') for i in range(sin_like.nbpoints)]\n #-------------------- lattice viseo\n vzero = [0. for i in range(lat_plot.nbpoints)] # zero line\n vis_abszisse = [lat_plot(i,'s') for i in range(lat_plot.nbpoints)]\n vis_ordinate = [lat_plot(i,'viseo') for i in range(lat_plot.nbpoints)]\n #-------------------- figure frame\n width=14; height=7.6\n # fighdr = 'lattice version = {}, input file = {}'.format(PARAMS['lattice_version'],PARAMS['input_file'])\n fig = plt.figure(num=1,figsize=(width,height),facecolor='#eaecef',tight_layout=False)\n\n #-------------------- beta functions\n splot211=plt.subplot(211)\n splot211.set_title('beta x,y')\n # mapping box\n splot211.text(0.01, 1.1, UTIL.FLAGS.get('mapping'),transform=splot211.transAxes,fontsize=8,bbox=dict(boxstyle='round',facecolor='wheat',alpha=0.5),verticalalignment='top')\n # function plots\n plt.plot(s,bx, label=r\"$\\beta$x [m]\", color='black', linestyle='-')\n plt.plot(s,by, label=r\"$\\beta$y [m]\", color='red', linestyle='-')\n plt.plot(s,dx, label=r'$\\eta_x$ [m]' , color='green', linestyle='-') # dispersion x\n vscale=splot211.axis()[3]*0.25\n viseoz = [x*vscale for x in vis_ordinate]\n plt.plot(vis_abszisse,viseoz,label='',color='black')\n plt.plot(vis_abszisse,vzero,color='green',linestyle='--')\n # zero line\n splot211.plot(vis_abszisse,vzero,color='green',linestyle='--')\n plt.legend(loc='lower right',fontsize='x-small')\n\n #-------------------- longitudinal tracks z, dP/P\n # ax_l = left abszisse\n ax_l=plt.subplot(212)\n # ax_l=plt.subplot(10,1,(7,9))\n ax_l.set_title('synchrotron oscillation')\n ax_l.set_ylabel(r\"z [mm]\")\n ax_l.tick_params(axis='y', colors='green')\n ax_l.yaxis.label.set_color('green')\n ax_l.plot(z1,cz,label='C',color='green')\n ax_l.plot(z2,sz,label='S',color='green',linestyle=':')\n plt.legend(loc='lower left',fontsize='x-small')\n # ax_r = right abszisse\n ax_r = ax_l.twinx()\n ax_r.set_ylabel(r'$\\Delta$p/p [%]')\n ax_r.tick_params(axis='y', colors='red')\n ax_r.yaxis.label.set_color('red')\n ax_r.plot(z2,cdp,label='C',color='red')\n ax_r.plot(z2,sdp,label='S',color='red',linestyle=':')\n ax_r.plot(vis_abszisse,vzero,color='red', linestyle='--')\n plt.legend(loc='lower right',fontsize='x-small')\n # lattice elements\n vscale=ax_l.axis()[3]*0.25\n viseoz = [x*vscale for x in vis_ordinate]\n ax_l.plot(vis_abszisse,viseoz,label='',color='black')\n ax_l.plot(vis_abszisse,vzero,color='green',linestyle='--')","def __init__(self, obj_top, goal_top, las_top, invertX=False, invertY=False):\n\n rospy.init_node('create_map', anonymous=True)\n\n # Topics\n self._objectTopic = obj_top\n self._goalTopic = goal_top\n self._laserTopic = las_top\n\n # Stores position of Robot and Goal\n self._Position = Position(orientation=0.0, xPos=0.0, zPos=0.0)\n self._goalPosition = Position()\n\n # Scatter Plot\n self._fig, self._scatPlot = plt.subplots()\n\n # Inverters\n self._invertX = invertX\n self._invertY = invertY\n\n # =========================================\n # Lists for storing data\n # =========================================\n\n self._summitX, self._summitZ = [], []\n self._laserX, self._laserZ = [], []\n self._goalX, self._goalZ = [], []\n self._objectX, self._objectZ = [], []\n self._objectNames = []\n self._objectDetected = False\n # =========================================\n # Create Plots\n # =========================================\n\n self._summitPoints = self._scatPlot.scatter(\n self._summitX, self._summitZ, c='green', edgecolors='none', s=100, marker=\"s\")\n\n self._laserPoints = self._scatPlot.scatter(\n self._laserX, self._laserZ, c='red', edgecolors='none')\n\n self._goalPoints = self._scatPlot.scatter(\n self._goalX, self._goalZ, c='blue', edgecolors='none', s=150, marker=\"*\")\n\n self._objectPoints = self._scatPlot.scatter(\n self._laserX, self._laserZ, c='magenta', edgecolors='none')\n\n # =========================================\n # Lists for Annotation Objects\n # =========================================\n self._summitAnnotation = None\n self._goalAnnotation = None\n self._objectAnnotations = []\n\n # Set Limits\n self._set_plot_limits(4)\n\n self._get_position()","def main():\n \n data_base = '/local/duman/SIMULATIONS/many_polymers_5/'\n save_base = '/usr/users/iff_th2/duman/RolfData/many_polymers_5'\n \n \n ## Index the data\n# density = [0.08, 0.2, 0.4]\n# xi_L = [0.05, 0.1, 0.2, 1.0, 2.5, 5.0, 8.0, 16.0]\n# Pe = [3.0, 7.0, 15.0, 50.0, 150.0, 500.0, 750.0, 1500.0, 4375.0, 8000.0, 10000.0]\n# kappa = [1.25, 2.5, 5.0, 25.0, 62.5, 125.0, 200.0, 400.0]\n# fp = [0.0, 0.0048, 0.0112, 0.024, 0.08, 0.24, 0.8, 1.2, 2.4, 7.0]\n \n density = [0.2]\n kappa = [1.25, 2.5, 5.0, 25.0, 62.5, 125.0, 200.0, 400.0]\n xi_L = [0.05, 0.1, 0.2, 1.0, 2.5, 5.0, 8.0, 16.0]\n fp = [0.0048, 0.0112, 0.024, 0.08, 0.24, 0.8, 1.2, 2.4, 7.0]\n Pe = [3.0, 7.0, 15.0, 50.0, 150.0, 500.0, 750.0, 1500.0, 4375.0]\n \n ## Create points\n points = []\n for i, x in enumerate(xi_L):\n for j, p in enumerate(Pe):\n points.append( Phase(x, p, kappa[i], fp[j], 'short') ) \n \n for point in points:\n point.analyse_type()\n point.set_plot_props()\n \n long_xil = [0.05, 0.2, 1.0, 2.5, 16.0]\n long_pe = [3.0, 150.0, 750.0, 8000.0, 10000.0]\n long_kappa = [5.0, 20.0, 100.0, 250.0, 1600.0]\n long_fp = [0.0003, 0.015, 0.075, 0.0, 0.0]\n long_points = []\n for i, x in enumerate(long_xil):\n for j, p in enumerate(long_pe):\n long_points.append( Phase(x, p, long_kappa[i], long_fp[j], 'long') ) \n \n for point in long_points:\n point.determine_type()\n point.set_plot_props()\n \n plot_data(points, long_points, save_base, xi_L, Pe)","def ols_data():\n\n xs = [35.3, 29.7, 30.8, 58.8, 61.4, 71.3, 74.4, 76.7, 70.7, 57.5,\n 46.4, 28.9, 28.1, 39.1, 46.8, 48.5, 59.3, 70, 70, 74.5, 72.1,\n 58.1, 44.6, 33.4, 28.6]\n ys = [10.98, 11.13, 12.51, 8.4, 9.27, 8.73, 6.36, 8.50,\n 7.82, 9.14, 8.24, 12.19, 11.88, 9.57, 10.94, 9.58,\n 10.09, 8.11, 6.83, 8.88, 7.68, 8.47, 8.86, 10.36, 11.08]\n\n\n # self.Xk = 28.6\n # self.ypred_k = 0.3091\n solution = {'slope': -0.0798,\n 'y_intercept': 13.623,\n 'n': len(xs),\n 'pred_x': 28.6,\n 'pred_error': 0.309}\n\n return xs, ys, solution","def lstm():\n if request.method == 'POST':\n return jsonify(message='Post message')\n elif request.method == 'GET':\n data = plots.lstm_df\n data['ds'] = data['ds'].astype(str)\n data = {'ds': data['ds'].tolist(),\n 'yhat': data['yhat'].tolist(),\n 'y_actual': data['y_actual'].tolist(),\n 'yhat_lower': data['yhat_lower'].tolist(),\n 'yhat_upper': data['yhat_upper'].tolist()\n }\n\n return jsonify(isError=False,\n message=\"Success\",\n statusCode=200,\n data=data), 200","def ISOMAPEmbbeding(TurosR=10,Torusr=4,Classes=[3,5,7],nei=[5,10,20], DataSet = {'Turos', 'Digits'}):\n\n S, dig = CreateDS_Torus_Digits(TurosR=TurosR,Torusr=Torusr,Classes=[3,5,7])\n ### ------ Isomap ------###\n nei = nei\n\n if 'Turos' in DataSet:\n # Ploting Torus Isomapping\n fig = plt.figure(figsize=(30, 10))\n for i, j in enumerate(nei):\n Torus_isomap = Isomap(S, 2, j)\n neighbors = j\n method = 'Torus ISOMAP'\n ax = fig.add_subplot(1, len(nei), i + 1)\n scatter = ax.scatter(Torus_isomap[:, 0], Torus_isomap[:, 1], c=S[:, 0:1], cmap=plt.cm.Spectral)\n # legend = ax.legend(*scatter.legend_elements(), loc=\"lower left\", title=\"Classes\")\n # ax.add_artist(legend)\n # ax.legend()\n ax.set_title('{} with {} Neighbours'.format(method, neighbors))\n # making_plot(Torus_isomap, pallete=S[:, 0:1], neighbors=j, method='Torus ISOMAP') #An option to plot single graphs\n plt.savefig('Torus ISOMAP embbeding for {} neighbour'.format(nei))\n\n if 'Digits' in DataSet:\n # Plotting Digits Isomapping\n for Argclass, Specificcalss in enumerate(dig):\n fig = plt.figure(figsize=(30, 10))\n for i, j in enumerate(nei):\n neighbors = j\n Digit_isomap = Isomap(Specificcalss[0], 2, j)\n method = 'Digit ISOMAP'\n ax = fig.add_subplot(1, len(nei), i + 1)\n scatter = ax.scatter(Digit_isomap[:, 0], Digit_isomap[:, 1], c=Specificcalss[1], cmap=plt.cm.Spectral)\n legend = ax.legend(*scatter.legend_elements(), loc=\"lower left\", title=\"Classes\")\n ax.add_artist(legend)\n ax.legend()\n ax.set_title('{} with {} Neighbours'.format(method, neighbors))\n # making_plot(Digit_isomap, Specificcalss[1], neighbors=j, method='Digit ISOMAP') #An option to plot single graphs\n plt.savefig('Digits up to {} - ISOMAP embbeding for {} neighbour'.format(Classes[Argclass], nei))","def lcfig( z=7 ):\n\n for modelname in ['z15G','z25G','z40G'] :\n\n # initialize a supernova model :\n snmodel = sncosmo.Model(source=modelname)\n\n # Fix the redshift for this instantiation of the model\n # (NOTE: this does not apply any cosmological dimming. It only\n # shifts the wavelengths)\n snmodel.set( z = z )\n\n # generate the H band light curve\n tobs = np.arange( 0, 1000, 10 )\n M160 = snmodel.bandmag( 'f160w', 'ab', tobs ) # Absolute Magnitude\n m160 = M160 + cosmo.distmod( z ).value # apparent magnitude\n\n pl.plot( tobs, m160 )\n ax = pl.gca()\n ax.invert_yaxis()\n ax.set_xlabel('Time (observer-frame days)')\n ax.set_ylabel('Apparent Magnitude in F160W')\n ax.set_xlim( 0, 1000 )\n ax.set_ylim( 36, 28 )\n\n pl.draw()","def morph_CII(**kwargs):\n\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n GR = glo.global_results()\n \n L_line = np.log10(getattr(GR,'L_'+p.line+'_sun'))\n SFR = np.log10(getattr(GR,'SFR'))\n\n fig,ax = plt.subplots(figsize=(20,16))\n\n for i in range(len(L_line)):\n \n im = mpimg.imread('plots/sim_data/stamps/%s%s_G%i.png' % (p.sim_name,p.sim_run,i))\n imbox = OffsetImage(im, zoom=0.02)\n ab = AnnotationBbox(imbox, (SFR[i],L_line[i]), pad=0, frameon=False)\n ax.add_artist(ab)\n\n ax.set_xlabel('log ' + getlabel('SFR'))\n ax.set_ylabel('log ' + getlabel(p.line))\n\n if not p.xlim: p.xlim = np.array([-3,4])\n if not p.ylim: \n p.ylim = [np.median(L_line)-6,np.median(L_line)+4]\n ax.set_xlim(p.xlim)\n ax.set_ylim(p.ylim)\n\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \n plt.savefig(p.d_plot + 'luminosity/morph_CII_%s%s' % (p.sim_name,p.sim_run),dpi=350)","def run_laser_predictor(self, laser_arr):","def visualize(self):\n # TODO\n #pyLDAvis.enable_notebook()\n #vis = pyLDAvis.gensim.prepare(self.lda_model, self.stemmed_corpus)\n return","def lens_model_plot(ax, lensModel, kwargs_lens, numPix=500, deltaPix=0.01, sourcePos_x=0, sourcePos_y=0, point_source=False, with_caustics=False):\n from lenstronomy.SimulationAPI.simulations import Simulation\n simAPI = Simulation()\n kwargs_data = simAPI.data_configure(numPix, deltaPix)\n data = Data(kwargs_data)\n _frame_size = numPix * deltaPix\n _coords = data._coords\n x_grid, y_grid = data.coordinates\n lensModelExt = LensModelExtensions(lensModel)\n\n #ra_crit_list, dec_crit_list, ra_caustic_list, dec_caustic_list = lensModelExt.critical_curve_caustics(\n # kwargs_lens, compute_window=_frame_size, grid_scale=deltaPix/2.)\n x_grid1d = util.image2array(x_grid)\n y_grid1d = util.image2array(y_grid)\n kappa_result = lensModel.kappa(x_grid1d, y_grid1d, kwargs_lens)\n kappa_result = util.array2image(kappa_result)\n im = ax.matshow(np.log10(kappa_result), origin='lower',\n extent=[0, _frame_size, 0, _frame_size], cmap='Greys', vmin=-1, vmax=1) #, cmap=self._cmap, vmin=v_min, vmax=v_max)\n if with_caustics is True:\n ra_crit_list, dec_crit_list = lensModelExt.critical_curve_tiling(kwargs_lens, compute_window=_frame_size,\n start_scale=deltaPix, max_order=10)\n ra_caustic_list, dec_caustic_list = lensModel.ray_shooting(ra_crit_list, dec_crit_list, kwargs_lens)\n plot_line_set(ax, _coords, ra_caustic_list, dec_caustic_list, color='g')\n plot_line_set(ax, _coords, ra_crit_list, dec_crit_list, color='r')\n if point_source:\n from lenstronomy.LensModel.Solver.lens_equation_solver import LensEquationSolver\n solver = LensEquationSolver(lensModel)\n theta_x, theta_y = solver.image_position_from_source(sourcePos_x, sourcePos_y, kwargs_lens)\n mag_images = lensModel.magnification(theta_x, theta_y, kwargs_lens)\n x_image, y_image = _coords.map_coord2pix(theta_x, theta_y)\n abc_list = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K']\n for i in range(len(x_image)):\n x_ = (x_image[i] + 0.5) * deltaPix\n y_ = (y_image[i] + 0.5) * deltaPix\n ax.plot(x_, y_, 'dk', markersize=4*(1 + np.log(np.abs(mag_images[i]))), alpha=0.5)\n ax.text(x_, y_, abc_list[i], fontsize=20, color='k')\n x_source, y_source = _coords.map_coord2pix(sourcePos_x, sourcePos_y)\n ax.plot((x_source + 0.5) * deltaPix, (y_source + 0.5) * deltaPix, '*k', markersize=10)\n ax.get_xaxis().set_visible(False)\n ax.get_yaxis().set_visible(False)\n ax.autoscale(False)\n #image_position_plot(ax, _coords, self._kwargs_else)\n #source_position_plot(ax, self._coords, self._kwargs_source)\n return ax","def visualize(self):\n\n self.check_model()\n show(prepare(self.model, self.vectorized_data, self.vectorizer, mds='tsne'))","def plot_MDS():\n lds = {} #lds is a dictionary of dictionaries: {\"slovenian.txt\": {\"abc\":3,\"efg\":4...}, \"macedonian.txt\":{\"abc\":5,\"efg\":6...},...}\n for fn in listdir(\"clustering\"):\n if fn.lower().endswith(\".txt\"):\n with open(join(\"clustering\", fn), encoding=\"utf8\") as f:\n text = f.read()\n nter = terke(text, n=3)\n lds[fn] = nter\n \n distances={} #a dictionary of dictionaries that saves the distances between a language and all other languages\n \n for x in lds.keys():\n distances[x]={}\n for y in lds.keys():\n if x == y: distances[x][y]=0.0\n else: distances[x][y]=cosine_dist(lds[x],lds[y])\n\n dst=np.zeros([len(lds.keys()), len(lds.keys())])\n i=0\n j=0\n for x in lds.keys():\n j=0\n for y in lds.keys():\n dst[i,j]=distances[x][y]\n j+=1\n i+=1\n\n X, languages = prepare_data_matrix()\n\n transformer = MDS(n_components=2, dissimilarity='precomputed')\n transformed = transformer.fit_transform(dst)\n\n plt.scatter(transformed [:,0], transformed [:,1])\n for i in range(len(transformed)):\n plt.text(transformed[i,0], transformed[i,1], languages[i][:3])\n plt.show()","def ISM_lums(line,**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n GR = glo.global_results()\n\n L_tot = getattr(GR,'L_%s_sun' % line)\n L_H2 = getattr(GR,'L_%s_H2_sun' % line)\n L_HI = getattr(GR,'L_%s_HI_sun' % line)\n L_HII = getattr(GR,'L_%s_HII_sun' % line)\n fig, ax = plt.subplots(figsize=(8, 6 ),facecolor='w')\n x=ax.hist(np.log10(L_tot[L_tot > 0]),bins=100,alpha=0.6,label='tot',color='grey')\n x=ax.hist(np.log10(L_H2[L_H2 > 0]),bins=100,alpha=0.6,label='H2',color='r')\n x=ax.hist(np.log10(L_HI[L_HI > 0]),bins=100,alpha=0.8,label='HI',color='orange')\n x=ax.hist(np.log10(L_HII[L_HII > 0]),bins=100,alpha=0.5,label='HII',color='b')\n ax.set_xlabel(getlabel('l'+line))\n ax.set_ylabel('Number of galaxies')\n plt.legend()\n if p.savefig:\n plt.savefig(p.d_plot + 'luminosity/ISM_lums_%s.png' % line)","def plot_lineratios(modeldata,modeldata2='None',line1='CIV1551',line2='CIII1908',line3='CIV1551',line4='HeII1640',\n plotname='./TESTPLOT.pdf',Zgas=False,logU=False,xid=0.3,nh=100,COratio=0.38,Mcutoff=100,\n logx=True,logy=True,logp1=False,logp2=False,fixxrange=False,fixyrange=False,\n showobs=None,noobserr=False,verbose=True):\n NFalse = 0\n freeparam = []\n inforstr = \"\"\n # - - - - - - - - - - - - - - - - - - - - - - - -\n legenddic = {}\n legenddic['Zgas'] = r'Z$_\\textrm{gas}$'\n legenddic['logUs'] = r'log$_\\textrm{10}$(U)'\n legenddic['xid'] = r'$\\xi_\\textrm{d}$'\n legenddic['nh'] = r'n$_\\textrm{H}$ / [cm$^3$]'\n legenddic['COCOsol'] = r'C/O / [C/O]$_\\textrm{sun}$'\n legenddic['mup'] = r'M$_\\textrm{cut IMF}$ / [M$_\\textrm{sun}]$'\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not Zgas:\n Zgasrange = [0.0,1.0]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' Zgas:vary, '\n freeparam.append('Zgas')\n else:\n Zgasrange = [Zgas-1e-6,Zgas+1e-6]\n inforstr = inforstr+' '+legenddic['Zgas']+'='+str(Zgas)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not logU:\n logUrange = [-5.0,0.0]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' logU:vary, '\n freeparam.append('logUs')\n else:\n logUrange = [logU-0.1,logU+0.1]\n inforstr = inforstr+' '+legenddic['logUs']+'='+str(logU)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not xid:\n xidrange = [0.0,0.6]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' xid:vary, '\n freeparam.append('xid')\n else:\n xidrange = [xid-0.01,xid+0.01]\n inforstr = inforstr+' '+legenddic['xid']+'='+str(xid)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not nh:\n nhrange = [0.0,1.0e6]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' nH:vary, '\n freeparam.append('nh')\n else:\n nhrange = [nh-1.0,nh+1.0]\n inforstr = inforstr+' '+legenddic['nh']+'='+str(nh)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not COratio:\n COratiorange = [0.0,2.0]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' C/O:vary, '\n freeparam.append('COCOsol')\n else:\n COratiorange = [COratio-0.001,COratio+0.001]\n inforstr = inforstr+' '+legenddic['COCOsol']+'='+str(COratio)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not Mcutoff:\n Mcutoffrange = [0.0,400.0]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' Mcutoff:vary, '\n freeparam.append('mup')\n else:\n Mcutoffrange = [Mcutoff-1.0,Mcutoff+1.0]\n inforstr = inforstr+' '+legenddic['mup']+'='+str(Mcutoff)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n\n if NFalse != 2:\n sys.exit(' Two and only two of the model parameters (Zgas,logU,xid,nh,COratio,Mcutoff) '\n 'should be set to Flase to define the model grid; however it appears '+str(NFalse)+\n ' parameters where not set')\n\n # - - - - - - - - - - - - - - - - - - - - - - - -\n goodent = np.where( (modeldata['Zgas'] > Zgasrange[0]) & (modeldata['Zgas'] < Zgasrange[1]) &\n (modeldata['logUs'] > logUrange[0]) & (modeldata['logUs'] < logUrange[1]) &\n (modeldata['xid'] > xidrange[0]) & (modeldata['xid'] < xidrange[1]) &\n (modeldata['nh'] > nhrange[0]) & (modeldata['nh'] < nhrange[1]) &\n (modeldata['COCOsol'] > COratiorange[0]) & (modeldata['COCOsol'] < COratiorange[1]) &\n (modeldata['mup'] > Mcutoffrange[0]) & (modeldata['mup'] < Mcutoffrange[1]) )\n\n Ngoodent = len(goodent[0])\n\n if Ngoodent > 1:\n if verbose: print(' - Getting data for '+str(Ngoodent)+' data points satisfying (SFR)model selection ')\n param1_1 = modeldata[freeparam[0]][goodent]\n if logp1:\n param1_1 = np.log10(param1_1)\n\n param1_2 = modeldata[freeparam[1]][goodent]\n if logp2:\n param1_2 = np.log10(param1_2)\n\n ratio1_1 = modeldata[line1][goodent]/modeldata[line2][goodent]\n ratio1_2 = modeldata[line3][goodent]/modeldata[line4][goodent]\n else:\n if verbose: print(' WARNING: Less than 2 (SFR)model grid points to plot; no output generated')\n return\n\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if modeldata2 != 'None':\n goodent2 = np.where( (modeldata2['Zgas'] > Zgasrange[0]) & (modeldata2['Zgas'] < Zgasrange[1]) &\n (modeldata2['logUs'] > logUrange[0]) & (modeldata2['logUs'] < logUrange[1]) &\n (modeldata2['xid'] > xidrange[0]) & (modeldata2['xid'] < xidrange[1]) &\n (modeldata2['nh'] > nhrange[0]) & (modeldata2['nh'] < nhrange[1]) )\n\n Ngoodent2 = len(goodent2[0])\n\n if Ngoodent > 1:\n if verbose: print(' - Getting data for '+str(Ngoodent2)+' data points satisfying (AGN)model selection ')\n param2_1 = modeldata2[freeparam[0]][goodent2]\n if logp1:\n param2_1 = np.log10(param2_1)\n\n param2_2 = modeldata2[freeparam[1]][goodent2]\n if logp2:\n param2_2 = np.log10(param2_2)\n\n l2s = ['x','x','x','x'] # line names to use for Feltre+16 file\n for ll, linestr in enumerate([line1,line2,line3,line4]):\n if '1908' in linestr:\n l2 = linestr.replace('1908','1907')\n else:\n l2 = linestr\n\n l2s[ll] = l2\n\n ratio2_1 = modeldata2[l2s[0]][goodent2]/modeldata2[l2s[1]][goodent2]\n ratio2_2 = modeldata2[l2s[2]][goodent2]/modeldata2[l2s[3]][goodent2]\n else:\n if verbose: print(' WARNING: Less than 2 (AGN)model grid points to plot; no output generated')\n return\n\n # - - - - - - - - - - - PLOTTING - - - - - - - - - - -\n if verbose: print(' - Setting up and generating plot')\n plotname = plotname\n fig = plt.figure(figsize=(9, 5))\n fig.subplots_adjust(wspace=0.1, hspace=0.1,left=0.1, right=0.99, bottom=0.10, top=0.95)\n Fsize = 10\n lthick = 1\n marksize = 3\n plt.rc('text', usetex=True)\n plt.rc('font', family='serif',size=Fsize)\n plt.rc('xtick', labelsize=Fsize)\n plt.rc('ytick', labelsize=Fsize)\n plt.clf()\n plt.ioff()\n plt.title(inforstr[:-2],fontsize=Fsize)\n\n margin = 0.1\n dx = np.abs(np.max(ratio1_1)-np.min(ratio1_1))\n dy = np.abs(np.max(ratio1_2)-np.min(ratio1_2))\n\n\n if fixxrange:\n xrange = fixxrange\n else:\n if logx:\n xrange = [np.min(ratio1_1)-np.min(ratio1_1)/2.,np.max(ratio1_1)+np.max(ratio1_1)/2.]\n else:\n xrange = [np.min(ratio1_1)-dx*margin,np.max(ratio1_1)+dx*margin]\n\n if fixyrange:\n yrange = fixyrange\n else:\n if logy:\n yrange = [np.min(ratio1_2)-np.min(ratio1_2)/2.,np.max(ratio1_2)+np.max(ratio1_2)/2.]\n else:\n yrange = [np.min(ratio1_2)-dy*margin,np.max(ratio1_2)+dy*margin]\n\n # ------------ PARAM1 ------------\n cmap = plt.cm.get_cmap('winter')\n cmin = np.min(param1_1)\n cmax = np.max(param1_1)\n colnorm = matplotlib.colors.Normalize(vmin=cmin,vmax=cmax)\n cmaparr = np.linspace(cmin, cmax, 30) #cmax-cmin)\n mm = plt.cm.ScalarMappable(cmap=cmap)\n mm.set_array(cmaparr)\n cb1 = plt.colorbar(mm)#shrink=0.25\n\n pstr1 = legenddic[freeparam[0]]\n if logp1:\n pstr1 = r'log$_\\textrm{10}$('+pstr1+')'\n\n cb1.set_label(pstr1+' (outer circle) - Fixed: black line')\n\n for p1 in np.unique(param1_1):\n p1col = cmap(colnorm(p1))\n p1ent = np.where(param1_1 == p1)\n\n plt.plot(ratio1_1[p1ent],ratio1_2[p1ent],'-',lw=lthick, color='k',zorder=1)\n\n plt.errorbar(ratio1_1[p1ent],ratio1_2[p1ent],xerr=None,yerr=None,\n marker='o',lw=0, markersize=marksize*3,\n markerfacecolor=p1col,ecolor=p1col,markeredgecolor = 'k',zorder=10)\n\n if modeldata2 is not 'None':\n p1ent = np.where(param2_1 == p1)\n\n plt.plot(ratio2_1[p1ent],ratio2_2[p1ent],'-',lw=lthick, color='k',zorder=1)\n\n plt.errorbar(ratio2_1[p1ent],ratio2_2[p1ent],xerr=None,yerr=None,\n marker='D',lw=0, markersize=marksize*3,\n markerfacecolor=p1col,ecolor=p1col,markeredgecolor = 'k',zorder=10)\n\n\n # ------------ PARAM2 ------------\n cmap = plt.cm.get_cmap('spring')\n cmin = np.min(param1_2)\n cmax = np.max(param1_2)\n colnorm = matplotlib.colors.Normalize(vmin=cmin,vmax=cmax)\n cmaparr = np.linspace(cmin, cmax, 30) #cmax-cmin)\n mm = plt.cm.ScalarMappable(cmap=cmap)\n mm.set_array(cmaparr)\n cb2 = plt.colorbar(mm)#shrink=0.25\n\n pstr2 = legenddic[freeparam[1]]\n if logp2:\n pstr2 = 'log10('+pstr2+')'\n\n cb2.set_label(pstr2+' (inner circle) - Fixed: gray line')\n\n for p2 in np.unique(param1_2):\n p2col = cmap(colnorm(p2))\n p2ent = np.where(param1_2 == p2)\n\n plt.plot(ratio1_1[p2ent],ratio1_2[p2ent],'-',lw=lthick, color='gray',zorder=2)\n\n plt.errorbar(ratio1_1[p2ent],ratio1_2[p2ent],xerr=None,yerr=None,\n marker='o',lw=0, markersize=marksize*1.5,\n markerfacecolor=p2col,ecolor=p2col,markeredgecolor = 'k',zorder=20)\n\n if modeldata2 is not 'None':\n p2ent = np.where(param2_2 == p2)\n\n plt.plot(ratio2_1[p2ent],ratio2_2[p2ent],'-',lw=lthick, color='gray',zorder=2)\n\n plt.errorbar(ratio2_1[p2ent],ratio2_2[p2ent],xerr=None,yerr=None,\n marker='D',lw=0, markersize=marksize*1.5,\n markerfacecolor=p2col,ecolor=p2col,markeredgecolor = 'k',zorder=20)\n\n\n if showobs != None:\n for ii, objid in enumerate(showobs[:,0]):\n if (showobs[:,7][ii] > xrange[0]) & (showobs[:,7][ii] < xrange[1]) & \\\n (showobs[:,9][ii] > yrange[0]) & (showobs[:,9][ii] < yrange[1]):\n\n if noobserr:\n obsxerr = None\n obsyerr = None\n else:\n obsxerr = showobs[:,8][ii]\n obsyerr = showobs[:,10][ii]\n plt.errorbar(showobs[:,7][ii],showobs[:,9][ii],xerr=obsxerr,yerr=obsyerr,\n marker='*',lw=lthick, markersize=marksize*2,\n markerfacecolor='k',ecolor='k',markeredgecolor = 'k',zorder=30)\n\n plt.xlabel(line1+'/'+line2)\n plt.ylabel(line3+'/'+line4)\n\n plt.xlim(xrange)\n plt.ylim(yrange)\n\n if logx:\n plt.xscale('log')\n if logy:\n plt.yscale('log')\n\n #--------- LEGEND ---------\n # plt.errorbar(-1,-1,xerr=None,yerr=None,fmt='o',lw=lthick,ecolor='white', markersize=marksize*2,\n # markerfacecolor='white',markeredgecolor = 'k',label='Ground-based spec')\n #\n # leg = plt.legend(fancybox=True, loc='upper center',prop={'size':Fsize},ncol=1,numpoints=1)\n # #bbox_to_anchor=(1.25, 1.03)) # add the legend\n # leg.get_frame().set_alpha(0.7)\n #--------------------------\n\n if verbose: print(' Saving plot to'+plotname)\n plt.savefig(plotname)\n plt.clf()\n plt.close('all')","def AGN_SB_diagnostic(**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n GR = glo.global_results()\n\n fig,ax = plt.subplots()\n L_CII = getattr(GR,'L_[CII]158_sun')\n\n # x = getattr(GR,'L_[CII]158_sun')/getattr(GR,'L_[NII]122_sun')\n x = getattr(GR,'L_[OIV]25_sun')/getattr(GR,'L_[OIII]88_sun')\n y = getattr(GR,'L_[NeIII]15_sun')/getattr(GR,'L_[NeII]12_sun')\n sc = ax.scatter(x,y,marker='o',s=3,alpha=0.6,c=np.log10(getattr(GR,'SFR')))\n ax.set_xscale('log')\n ax.set_yscale('log')\n ax.set_xlim([8e-5,200])\n ax.set_ylim([0.02,150])\n # ax.set_xlabel('[CII]$_{158}$/[NII]$_{122}$')\n plt.colorbar(sc,label='log(SFR)')\n ax.set_xlabel('[OIV]$_{25.9}$/[OIII]$_{88}$')\n ax.set_ylabel('[NeIII]$_{15.6}$/[NeII]$_{12.8}$')\n if p.savefig:\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \n plt.savefig(p.d_plot + 'luminosity/ratio_%s' % ratio_name,dpi=300)","def test_lrp_svm(self, syn_genomic_data, syn_fm, syn_idx, rep, tmp_path, syn_true_pvalues): \n rep_to_plot = 0\n ttbrs = [0.5, 1,1.5]\n idx = syn_idx[str(rep_to_plot)]\n fig, axes = plt.subplots(len(ttbrs), 5, figsize=[30,15])\n x_3d = syn_fm(\"3d\")[str(rep_to_plot)][:]\n x_2d = syn_fm(\"2d\")[str(rep_to_plot)][:]\n indices_true= [inds_true for inds_true, x in enumerate(syn_true_pvalues[0].flatten()) if x]\n\n for i, ttbr in enumerate(ttbrs):\n print('Using tbrr={}'.format(ttbr))\n labels = generate_syn_phenotypes(tower_to_base_ratio=ttbr, quantity=rep)\n labels_cat = {}\n for key, l in labels.items():\n labels_cat[key] = tensorflow.keras.utils.to_categorical((l+1)/2)\n \n best_params_montaez['n_snps']= x_3d.shape[1]\n \n l_0b=labels_cat[str(rep_to_plot)]\n\n model = create_montaez_dense_model(best_params_montaez)\n y_integers = np.argmax(l_0b[idx.train], axis=1)\n class_weights = class_weight.compute_class_weight('balanced', np.unique(y_integers), y_integers)\n d_class_weights = dict(enumerate(class_weights))\n\n model.fit(x=x_3d[idx.train], y=l_0b[idx.train], validation_data=(x_3d[idx.test], l_0b[idx.test]), epochs=best_params_montaez['epochs'], class_weight=d_class_weights, callbacks=[ ReduceLROnPlateau(monitor='val_loss', factor=best_params_montaez['factor'], patience=best_params_montaez['patience'], mode='min'),],)\n\n model = iutils.keras.graph.model_wo_softmax(model)\n analyzer = innvestigate.analyzer.LRPAlpha1Beta0(model)\n weights = analyzer.analyze(x_3d).sum(0)\n\n top_indices_sorted, filtered_weights = postprocess_weights(weights, top_k, filter_window_size, p_svm, p_pnorm_filter)\n\n complete_pvalues = chi_square(syn_genomic_data[str(rep_to_plot)][:], labels[str(rep_to_plot)])\n \n pvalues_filled_deep = np.ones(n_total_snps)\n pvalues_filled_deep[top_indices_sorted] = complete_pvalues[top_indices_sorted]\n\n # Plot RPVT\n plot_pvalues(complete_pvalues, indices_true, axes[i][0])\n if i==0:\n axes[i][0].set_title('RPVT $-log_{10}$(p-values)', fontsize=22)\n axes[i][0].set_ylabel('$-log_{10}$(p-value)', fontsize=18)\n plt.setp(axes[i][0].get_yticklabels(), fontsize=16)\n plt.setp(axes[i][0].get_xticklabels(), fontsize=16)\n\n # Plot svm weights \n clf = LinearSVC(penalty='l2', loss='hinge', C=0.0022, dual=True, tol=1e-3, verbose=0, class_weight='balanced')\n idx_now, pvalues, raw_weights = combi_method(clf, syn_genomic_data[str(rep_to_plot)][:],x_2d, labels[str(rep_to_plot)], 35, 2, 2, 30)\n #filtered_svm_weights = postprocess_weights_without_avg(raw_weights, p_svm)\n pvalues_filled_combi = np.ones(len(complete_pvalues))\n pvalues_filled_combi[idx_now] = pvalues\n #svm_weights = toy_classifier.fit(x_2d, labels[str(rep_to_plot)]).coef_\n axes[i][1].scatter(range(len(np.absolute(raw_weights).sum(1))), 1000*np.absolute(raw_weights).sum(1), marker='.', color='darkblue')\n axes[i][1].scatter(indices_true,1000*np.absolute(raw_weights).sum(1)[indices_true], color='fuchsia')\n axes[i][1].set_ylim(0,1000*(np.max(np.absolute(raw_weights).sum(1))+0.001))\n if i==0:\n axes[i][1].set_title('Absolute SVM weights * 1000', fontsize=22)\n plt.setp(axes[i][1].get_yticklabels(), fontsize=16)\n plt.setp(axes[i][1].get_xticklabels(), fontsize=16)\n\t\t\t\n # Plot COMBI\n plot_pvalues(pvalues_filled_combi, indices_true, axes[i][2])\n if i==0:\n axes[i][2].set_title('COMBI $-log_{10}$(p-values)', fontsize=22)\n if i==2:\n axes[i][2].set_xlabel('SNP position', fontsize=18)\n plt.setp(axes[i][2].get_yticklabels(), fontsize=16)\n plt.setp(axes[i][2].get_xticklabels(), fontsize=16)\n\t\t\t\n # Plot LRP relevance scores\n axes[i][3].scatter(range(len(np.absolute(weights).reshape(-1, 3).sum(1))), np.absolute(weights).reshape(-1, 3).sum(1), marker='.', color='darkblue')\n axes[i][3].scatter(indices_true,np.absolute(weights).reshape(-1, 3).sum(1)[indices_true], color='fuchsia')\n #axes[i][1].legend()\n axes[i][3].set_ylim(0,np.max(np.absolute(weights).reshape(-1, 3).sum(1))+1)\n if i==0:\n axes[i][3].set_title('LRP relevance scores', fontsize=22)\n plt.setp(axes[i][3].get_yticklabels(), fontsize=16)\n plt.setp(axes[i][3].get_xticklabels(), fontsize=16)\n\t\t\t\n # Plot DeepCOMBI\n plot_pvalues(pvalues_filled_deep, indices_true, axes[i][4])\n if i==0:\n axes[i][4].set_title('DeepCOMBI $-log_{10}$(p-value)', fontsize=22)\n plt.setp(axes[i][4].get_yticklabels(), fontsize=16)\n plt.setp(axes[i][4].get_xticklabels(), fontsize=16)\n\t\t\t\n ## Plot distribution of postprocessed vectors\n #axes[i][2].plot(postprocessed_weights)\n #axes[i][2].set_title('Postprocessed relevance')\n\n fig.savefig(os.path.join(IMG_DIR, 'manhattan-example-toy-NAR.png'), bbox_inches='tight')","def odemisSEM_to_hyperspy(filename='sampledata/cltest.h5') :\r\n\r\n f=h5.File(filename,'r')\r\n shome = 'Acquisition1//ImageData/'\r\n x = f[shome + 'Image']\r\n cdesc =f['Acquisition1/PhysicalData/ChannelDescription'].value[0].decode('utf-8')\r\n #print(cdesc)\r\n\r\n\r\n print('<' + filename + '> original shape :' ,x.shape)\r\n # strip unused dimensions and transpose/ reverse index order\r\n xx=x[0,0,0,:,:].transpose((1,0))\r\n\r\n s = hs.signals.Signal2D(xx)\r\n print('hyperspy shape :' ,s.data.shape)\r\n\r\n\r\n s.metadata.General.title = 'Odemis: ' + cdesc\r\n s.metadata.General.original_filename = filename\r\n #s.metadata.General.notes = cltype\r\n s.axes_manager[0].name = 'pos x'\r\n s.axes_manager[0].scale = f[shome + 'DimensionScaleX'].value * 1e6\r\n s.axes_manager[0].offset = f[shome + 'XOffset'].value * 1e6\r\n s.axes_manager[0].units = 'um'\r\n\r\n\r\n s.axes_manager[1].name = 'pos y'\r\n s.axes_manager[1].scale = f[shome + 'DimensionScaleX'].value * 1e6\r\n s.axes_manager[1].offset = f[shome + 'YOffset'].value * 1e6\r\n s.axes_manager[1].units = 'um'\r\n\r\n\r\n f.close()\r\n return( s )\r\n #end odemisSEM_to_hyperspy\r\n #######################\r","def plot_ablation_losses():\n\n path1 = os.path.join(path_to_here, '../data/landscape_visualizations/DMSO/original/losses00-54.pickle')\n file = open(path1, 'rb')\n losses_array_1 = pickle.load(file)\n losses_array_1 = losses_array_1[1:, :]\n\n path2 = os.path.join(path_to_here, '../data/landscape_visualizations/DMSO/D_t/losses00-44.pickle')\n file = open(path2, 'rb')\n losses_array_2 = pickle.load(file)\n losses_array_2 = losses_array_2\n\n path3 = os.path.join(path_to_here, '../data/landscape_visualizations/DMSO/D_x_y/losses00-44.pickle')\n file = open(path3, 'rb')\n losses_array_3 = pickle.load(file)\n losses_array_3 = losses_array_3\n\n path4 = os.path.join(path_to_here, '../data/landscape_visualizations/DMSO/homog/losses00-76.pickle')\n file = open(path4, 'rb')\n losses_array_4 = pickle.load(file)\n losses_array_4 = losses_array_4[1:, :]\n\n paths = [path1, path2, path3, path4]\n\n\n\n\n # 'pdf', 'BC', 'pde', 'total', 'norm'\n fig = plt.figure(figsize = (2.1, 1.5))\n\n\n for path, losses_array, label in zip(paths, [losses_array_1, losses_array_2, losses_array_3, losses_array_4], ['D(x, y, t)', 'D(t)', 'D(x, y)', 'D']):\n\n print('shape', losses_array.shape)\n\n losses_base = os.path.basename(path)\n total_losses = losses_array[3, :] # total losses are idx 3 for these runs\n idxs = []\n means = []\n for idx in range(len(total_losses)-200):\n num_half_hrs = int(losses_base[6:8]) + idx*(int(losses_base[9:11])-int(losses_base[6:8]))/len(total_losses)\n if num_half_hrs < 55:\n idxs.append(num_half_hrs)\n means.append(np.mean(total_losses[idx:idx+200]))\n\n\n plt.scatter([i/2 for i in idxs], np.log10(means), s = 0.1, label = label)\n\n plt.ylabel(r'$log_{10}L_{total}$', fontsize = 6, labelpad = 1)\n plt.xlabel('Hours trained', fontsize = 6, labelpad = 1)\n plt.tick_params(axis = 'both', labelsize = 6)\n plt.tight_layout()\n plt.legend(fontsize = 6)\n\n\n\n plt.savefig(path_to_here+'/../outputs/ablation.png', dpi = 1200)","def _plot_predictions_one_model(\n top_prediction_dir_name, border_latitudes_deg_n,\n border_longitudes_deg_e, valid_time_string, title_string, font_size,\n figure_object, axes_object, smoothing_radius_px=None):\n\n prediction_file_name = prediction_io.find_file(\n top_directory_name=top_prediction_dir_name,\n valid_date_string=valid_time_string[:10].replace('-', ''),\n radar_number=None, prefer_zipped=True, allow_other_format=True,\n raise_error_if_missing=True\n )\n\n print('Reading data from: \"{0:s}\"...'.format(prediction_file_name))\n prediction_dict = prediction_io.read_file(prediction_file_name)\n\n valid_time_unix_sec = time_conversion.string_to_unix_sec(\n valid_time_string, TIME_FORMAT\n )\n prediction_dict = prediction_io.subset_by_time(\n prediction_dict=prediction_dict,\n desired_times_unix_sec=numpy.array([valid_time_unix_sec], dtype=int)\n )[0]\n\n good_lat_indices = numpy.where(numpy.logical_and(\n prediction_dict[prediction_io.LATITUDES_KEY] >= MIN_PLOT_LATITUDE_DEG_N,\n prediction_dict[prediction_io.LATITUDES_KEY] <= MAX_PLOT_LATITUDE_DEG_N\n ))[0]\n\n good_lng_indices = numpy.where(numpy.logical_and(\n prediction_dict[prediction_io.LONGITUDES_KEY] >=\n MIN_PLOT_LONGITUDE_DEG_E,\n prediction_dict[prediction_io.LONGITUDES_KEY] <=\n MAX_PLOT_LONGITUDE_DEG_E\n ))[0]\n\n prediction_dict[prediction_io.LATITUDES_KEY] = (\n prediction_dict[prediction_io.LATITUDES_KEY][good_lat_indices]\n )\n prediction_dict[prediction_io.LONGITUDES_KEY] = (\n prediction_dict[prediction_io.LONGITUDES_KEY][good_lng_indices]\n )\n\n these_keys = [\n prediction_io.TARGET_MATRIX_KEY, prediction_io.PROBABILITY_MATRIX_KEY\n ]\n for this_key in these_keys:\n prediction_dict[this_key] = (\n prediction_dict[this_key][:, good_lat_indices, ...]\n )\n prediction_dict[this_key] = (\n prediction_dict[this_key][:, :, good_lng_indices, ...]\n )\n\n if smoothing_radius_px is not None:\n prediction_dict = prediction_io.smooth_probabilities(\n prediction_dict=prediction_dict,\n smoothing_radius_px=smoothing_radius_px\n )\n\n model_file_name = prediction_dict[prediction_io.MODEL_FILE_KEY]\n model_metafile_name = neural_net.find_metafile(model_file_name)\n\n print('Reading model metadata from: \"{0:s}\"...'.format(\n model_metafile_name\n ))\n model_metadata_dict = neural_net.read_metafile(model_metafile_name)\n\n mask_matrix = model_metadata_dict[neural_net.FULL_MASK_MATRIX_KEY]\n mask_matrix = mask_matrix[good_lat_indices, :]\n mask_matrix = mask_matrix[:, good_lng_indices]\n\n target_matrix = prediction_dict[prediction_io.TARGET_MATRIX_KEY][0, ...]\n target_matrix[mask_matrix == False] = 0\n probability_matrix = prediction_io.get_mean_predictions(prediction_dict)[\n 0, ...\n ]\n\n latitudes_deg_n = prediction_dict[prediction_io.LATITUDES_KEY]\n longitudes_deg_e = prediction_dict[prediction_io.LONGITUDES_KEY]\n\n plotting_utils.plot_borders(\n border_latitudes_deg_n=border_latitudes_deg_n,\n border_longitudes_deg_e=border_longitudes_deg_e,\n axes_object=axes_object, line_width=BORDER_WIDTH\n )\n\n axes_object.contour(\n longitudes_deg_e, latitudes_deg_n, mask_matrix, numpy.array([0.999]),\n colors=(MASK_OUTLINE_COLOUR,), linewidths=MASK_OUTLINE_WIDTH,\n linestyles='solid'\n )\n\n colour_map_object, colour_norm_object = (\n prediction_plotting.get_prob_colour_scheme(\n max_probability=1., make_lowest_prob_grey=False\n )\n )\n\n prediction_plotting.plot_probabilistic(\n target_matrix=target_matrix, probability_matrix=probability_matrix,\n figure_object=figure_object, axes_object=axes_object,\n min_latitude_deg_n=latitudes_deg_n[0],\n min_longitude_deg_e=longitudes_deg_e[0],\n latitude_spacing_deg=numpy.diff(latitudes_deg_n[:2])[0],\n longitude_spacing_deg=numpy.diff(longitudes_deg_e[:2])[0],\n colour_map_object=colour_map_object,\n colour_norm_object=colour_norm_object\n )\n\n plotting_utils.plot_grid_lines(\n plot_latitudes_deg_n=latitudes_deg_n,\n plot_longitudes_deg_e=longitudes_deg_e, axes_object=axes_object,\n parallel_spacing_deg=2., meridian_spacing_deg=2.,\n font_size=font_size\n )\n\n axes_object.set_title(title_string)\n\n return target_matrix, mask_matrix","def plot_lollipop(clinvar_path_count):\n os.chdir(\"/Users/Files/nogit/generisk/lollipop/figure\")\n app = '/Users/files/work/bin/lollipops'\n for i in x.itertuples(False, None):\n # uid, variants, gn\n os.system(\"%s -domain-labels=fit -U %s -o %s.svg %s\" % (app, i[0], i[2], i[1]))\n # os.system(\"rsvg-convert %s.svg -o %s_rsvg.png\"%(i[2],i[2]))\n os.system(\"convert -density 500 -units pixelsperinch %s.svg %s.png\" % (i[2], i[2]))","def model(Prio: NNEmbeddings, plot_emb: bool = False, pickle_file: str = None):\n # New Predicitons\n df_metrics = Prio.predict(pickle_file=pickle_file)\n plot_single(df_metrics)\n\n if plot_emb:\n # TSNE Plots\n Prio.plot_embeddings()\n Prio.plot_embeddings_labeled(layer='tests')\n Prio.plot_embeddings_labeled(layer='files')\n\n # UMAP Plots\n Prio.plot_embeddings(method='UMAP')\n Prio.plot_embeddings_labeled(layer='tests', method='UMAP')\n Prio.plot_embeddings_labeled(layer='files', method='UMAP')","def odemis_to_hyperspy(filename='sampledata/cltest.h5',specbin=1) :\r\n\r\n f=h5.File(filename,'r')\r\n shome = 'Acquisition2//ImageData/'\r\n x = f[shome + 'Image']\r\n cdesc =f['Acquisition2/PhysicalData/ChannelDescription'].value[0].decode('utf-8')\r\n #print(cdesc)\r\n\r\n cltype = None\r\n if 'Spectrum' in cdesc :\r\n cltype = 'spectrum'\r\n elif 'CL intensity' in cdesc:\r\n cltype = 'panchrom'\r\n\r\n print('<' + filename + '> original shape :' ,x.shape, cltype)\r\n\r\n # strip unused dimensions and transpose/ reverse index order\r\n if cltype == 'panchrom' :\r\n xx=x[0,0,0,:,:].transpose((1,0))\r\n # just an image..\r\n else :\r\n xx=x[:,0,0,:,:].transpose((2,1,0))\r\n\r\n if cltype == 'spectrum' :\r\n #interpolate data to linearize the wavelength scale\r\n w = f[shome + 'DimensionScaleC'].value *1e9\r\n wx = np.linspace(w.min(),w.max(),w.size)\r\n for i in np.arange(xx.shape[0]) :\r\n for k in np.arange(xx.shape[1]) :\r\n xx[i,k,:] = np.interp(wx,w,xx[i,k,:])\r\n\r\n wslope = wx[1]-wx[0]\r\n woffset = wx.min()\r\n #wx = np.arange(w.size)\r\n #wslope,woffset=np.polyfit(wx,w,1)\r\n s = hs.signals.Signal1D(xx)\r\n\r\n elif cltype == 'panchrom' :\r\n s = hs.signals.Signal2D(xx)\r\n else :\r\n print('unknown type')\r\n\r\n print('hyperspy shape :' ,s.data.shape)\r\n\r\n\r\n s.metadata.General.title = 'Odemis: ' + cdesc\r\n s.metadata.General.original_filename = filename\r\n s.metadata.General.notes = cltype\r\n s.axes_manager[0].name = 'pos x'\r\n s.axes_manager[0].scale = f[shome + 'DimensionScaleX'].value * 1e6\r\n s.axes_manager[0].offset = f[shome + 'XOffset'].value * 1e6\r\n s.axes_manager[0].units = 'um'\r\n\r\n\r\n s.axes_manager[1].name = 'pos y'\r\n s.axes_manager[1].scale = f[shome + 'DimensionScaleX'].value * 1e6\r\n s.axes_manager[1].offset = f[shome + 'YOffset'].value * 1e6\r\n s.axes_manager[1].units = 'um'\r\n\r\n if cltype == 'spectrum' :\r\n s.axes_manager[2].name = 'wavelength'\r\n s.axes_manager[2].units = 'nm'\r\n s.axes_manager[2].offset = woffset\r\n s.axes_manager[2].scale = wslope\r\n s.metadata.signal_type = 'CL'\r\n\r\n f.close()\r\n if (specbin > 1) and (cltype == 'spectrum'):\r\n return( s.rebin(scale=[1,1,specbin]) )\r\n else :\r\n return( s )\r\n #end odemis_to_hyperspy\r\n #######################\r","def appelDlr():\n try:\n if os.path.getsize('aspifile/dlr.json'):\n subprocess.call('aspifile/aspidlr.py', shell=True)\n label['text'] = (\"Date: \" + textDate.get() +\" -- \"+ \"Nom: \" + textName.get() +\n \"\\nDouleurs: \" + textDlrs.get())\n except FileNotFoundError as errorgraph7:\n print('Sorry the Dlrs plot doesn\\'t work ! Data missing !', errorgraph7)\n label['text'] = \"Sorry the Dlrs plot doesn\\'t work ! Data missing !\"","def plot_LvsL_multiple(line1='CIV1548',line2='CIII1908',line1range=[1e3,1e8],line2range=[1e0,1e8],\n outputdir='./',verbose=True):\n modeldata = nm.load_model('combined',verbose=verbose)\n\n if verbose: print(' - Putting together permutations of chosen setups for plotting')\n infodic = {}\n infodic['Zgas'] = [False,0.0001,0.006,0.040], True\n infodic['logUs'] = [False,-1.0,-2.5,-4.0] , False\n infodic['xid'] = [False,0.1,0.3,0.5] , False\n infodic['nh'] = [False,10,100,1000,10000] , False\n infodic['CO'] = [False,0.1,0.38,1.4] , False\n infodic['Mcut'] = [False,100,300] , False\n\n variables = [infodic['Zgas'][0],infodic['logUs'][0],infodic['xid'][0],\n infodic['nh'][0],infodic['CO'][0],infodic['Mcut'][0]]\n\n permutations = list(itertools.product(*variables))\n permutations_with2false = [sublist for sublist in permutations if sublist.count(False) == 2.]\n Nplots = len(permutations_with2false)\n\n if verbose: print(' - With the restriction Nfalse=2 the setup will results in '+str(Nplots)+\\\n ' plots (if model data allows)')\n if verbose: print(' - These will be saved to the output directory: '+outputdir)\n for pp, perm in enumerate(permutations_with2false):\n Zval = perm[0]\n Uval = perm[1]\n Xival = perm[2]\n Nhval = perm[3]\n COval = perm[4]\n Mval = perm[5]\n\n plotname = outputdir+'NEOGALmodelgrid_Zgas'+str(Zval).replace('.','p')+\\\n '_logU'+str(Uval).replace('.','p')+\\\n '_xid'+str(Xival).replace('.','p')+\\\n '_nH'+str(Nhval).replace('.','p')+\\\n '_CO'+str(COval).replace('.','p')+\\\n '_Mcut'+str(Mval).replace('.','p')+'.pdf'\n\n plotname = plotname.replace('False','Free')\n\n if verbose:\n plotno = pp+1\n infostr = ' - Generating plot '+str(\"%.4d\" % plotno)+'/'+str(\"%.4d\" % Nplots)+': '+plotname.split('/')[-1]+' '\n sys.stdout.write(\"%s\\r\" % infostr)\n sys.stdout.flush()\n\n if not Zval:\n logp1 = True\n else:\n logp1 = False\n\n nm.plot_LvsL(modeldata,line1=line1,line2=line2,logx=True,logy=True,logp1=logp1,logp2=False,verbose=False,\n Zgas=Zval,logU=Uval,xid=Xival,nh=Nhval,COratio=COval,Mcutoff=Mval,\n fixxrange=line1range,fixyrange=line2range,plotname=plotname)\n\n print('\\n ... done')","def map_plot(self, iter_no):\n \n m = self._m\n n = self._n\n plt.figure()\n label=np.zeros(m*n)\n self._trained = True\n mapped = self.map_vects(datanorm)\n mapped=tuple(map(tuple, mapped))\n c=Counter(mapped)\n \n c= sorted(c.items(), key=itemgetter(1))\n a=[m*n]\n for i in range(0,len(c)):\n x=(((c[i])[0])[0])\n y=(((c[i])[0])[1])\n z=((c[i])[1])\n plt.plot(x, y, 'ro', markersize= z/(2*m*n)) \n plt.savefig('exoplanet{}.png'.format(iter_no))\n p=plt.imread('exoplanet{}.png'.format(iter_no))\n imgs.append(p)\n plt.show()\n plt.close()\n print(c)\n self._trained = False","def main():\n\n # Create argument parser\n parser = ArgumentParser()\n parser.add_argument('datadir', type=str, help='Directory of LC files')\n parser.add_argument('metatable', type=str,\n help='Metatable containing each object, redshift, peak time guess, mwebv, object type')\n parser.add_argument('--zpt', type=float, default=DEFAULT_ZPT, help='Zero point of LCs')\n parser.add_argument('--lm', type=float, default=DEFAULT_LIM_MAG, help='Survey limiting magnitude')\n parser.add_argument('--outdir', type=str, default='./products/',\n help='Path in which to save the LC data (single file)')\n args = parser.parse_args()\n\n objs, redshifts, obj_types, peaks, ebvs = read_in_meta_table(args.metatable)\n\n # Grab all the LC files in the input directory\n file_names = []\n for obj in objs:\n file_name = args.datadir + 'PS1_PS1MD_' + obj + '.snana.dat'\n file_names.append(file_name)\n\n # Create a list of LC objects from the data files\n lc_list = read_in_LC_files(file_names, objs)\n\n # This needs to be redone when retrained\n # TODO: Need to change this whenever you retrain...\n filt_dict = {'g': 0, 'r': 1, 'i': 2, 'z': 3}\n wvs = np.asarray([5460, 6800, 7450, 8700])\n\n # Update the LC objects with info from the metatable\n my_lcs = []\n for i, my_lc in enumerate(lc_list):\n my_lc.add_LC_info(zpt=args.zpt, mwebv=ebvs[i],\n redshift=redshifts[i], lim_mag=args.lm,\n obj_type=obj_types[i])\n my_lc.get_abs_mags()\n my_lc.sort_lc()\n pmjd = my_lc.find_peak(peaks[i])\n my_lc.shift_lc(pmjd)\n my_lc.correct_time_dilation()\n my_lc.filter_names_to_numbers(filt_dict)\n my_lc.correct_extinction(wvs)\n my_lc.cut_lc()\n my_lc.make_dense_LC(4)\n my_lcs.append(my_lc)\n save_lcs(my_lcs, args.outdir)","def litchi(args):\n p = OptionParser(litchi.__doc__)\n opts, args, iopts = p.set_image_options(args, figsize=\"9x6\")\n\n if len(args) != 4:\n sys.exit(not p.print_help())\n\n datafile, bedfile, slayout, switch = args\n fig = plt.figure(1, (iopts.w, iopts.h))\n root = fig.add_axes([0, 0, 1, 1])\n\n Synteny(fig, root, datafile, bedfile, slayout, switch=switch)\n\n # legend showing the orientation of the genes\n draw_gene_legend(root, 0.4, 0.7, 0.82)\n\n # On the left panel, make a species tree\n fc = \"lightslategrey\"\n\n coords = {}\n xs, xp = 0.16, 0.03\n coords[\"lychee\"] = (xs, 0.37)\n coords[\"clementine\"] = (xs, 0.5)\n coords[\"cacao\"] = (xs, 0.6)\n coords[\"strawberry\"] = (xs, 0.7)\n coords[\"grape\"] = (xs, 0.8)\n xs -= xp\n coords[\"Sapindales\"] = join_nodes(root, coords, \"clementine\", \"lychee\", xs)\n xs -= xp\n coords[\"Rosid-II\"] = join_nodes(root, coords, \"cacao\", \"Sapindales\", xs)\n xs -= xp\n coords[\"Rosid\"] = join_nodes(root, coords, \"strawberry\", \"Rosid-II\", xs)\n xs -= xp\n coords[\"crown\"] = join_nodes(root, coords, \"grape\", \"Rosid\", xs, circle=False)\n\n # Names of the internal nodes\n for tag in (\"Rosid\", \"Rosid-II\", \"Sapindales\"):\n nx, ny = coords[tag]\n nx, ny = nx - 0.01, ny - 0.02\n root.text(nx, ny, tag, rotation=90, ha=\"right\", va=\"top\", color=fc)\n\n root.set_xlim(0, 1)\n root.set_ylim(0, 1)\n root.set_axis_off()\n\n pf = \"litchi\"\n image_name = pf + \".\" + iopts.format\n savefig(image_name, dpi=iopts.dpi, iopts=iopts)","def convert_yolo_to_ls(input_dir, out_file,\n to_name='image', from_name='label', out_type=\"annotations\",\n image_root_url='/data/local-files/?d=', image_ext='.jpg'):\n\n tasks = []\n logger.info('Reading YOLO notes and categories from %s', input_dir)\n\n # build categories=>labels dict\n notes_file = os.path.join(input_dir, 'classes.txt')\n with open(notes_file) as f:\n lines = [line.strip() for line in f.readlines()]\n categories = {i: line for i, line in enumerate(lines)}\n logger.info(f'Found {len(categories)} categories')\n\n # generate and save labeling config\n label_config_file = out_file.replace('.json', '') + '.label_config.xml'\n generate_label_config(categories, to_name, from_name, label_config_file)\n\n # labels, one label per image\n labels_dir = os.path.join(input_dir, 'labels')\n logger.info('Converting labels from %s', labels_dir)\n\n for f in os.listdir(labels_dir):\n image_file_base = f[0:-4] + image_ext\n image_file = os.path.join(input_dir, 'images', image_file_base)\n label_file = os.path.join(labels_dir, f)\n\n if not f.endswith('.txt'):\n continue\n\n if not os.path.exists(image_file):\n logger.error(\"Can't convert YOLO to Label Studio JSON without image source: %s\", image_file)\n continue\n\n task = {\n # 'annotations' or 'predictions'\n out_type: [\n {\n \"result\": [],\n \"ground_truth\": False,\n }\n ],\n \"data\": {\n \"image\": os.path.join(image_root_url, image_file_base)\n }\n }\n\n # read image sizes\n im = Image.open(image_file)\n image_width, image_height = im.size\n\n with open(label_file) as file:\n # convert all bounding boxes to Label Studio Results\n lines = file.readlines()\n for line in lines:\n label_id, x, y, width, height = line.split()\n x, y, width, height = float(x), float(y), float(width), float(height)\n item = {\n \"id\": uuid.uuid4().hex[0:10],\n \"type\": \"rectanglelabels\",\n \"value\": {\n \"x\": (x-width/2) * 100,\n \"y\": (y-height/2) * 100,\n \"width\": width * 100,\n \"height\": height * 100,\n \"rotation\": 0,\n \"rectanglelabels\": [\n categories[int(label_id)]\n ]\n },\n \"to_name\": to_name,\n \"from_name\": from_name,\n \"image_rotation\": 0,\n \"original_width\": image_width,\n \"original_height\": image_height\n }\n task['annotations'][0]['result'].append(item)\n\n tasks.append(task)\n\n if len(tasks) > 0:\n logger.info('Saving Label Studio JSON to %s', out_file)\n with open(out_file, 'w') as out:\n json.dump(tasks, out)\n\n print('\\n'\n f' 1. Create a new project in Label Studio\\n'\n f' 2. Use Labeling Config from \"{label_config_file}\"\\n'\n f' 3. Setup serving for images [e.g. you can use Local Storage (or others):\\n'\n f' https://labelstud.io/guide/storage.html#Local-storage]\\n'\n f' 4. Import \"{out_file}\" to the project\\n')\n else:\n logger.error('No labels converted, maybe ')","def dline_dSFR(**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n GR = glo.global_results(sim_run=p.sim_run,nGal=p.nGal)\n \n marker = 'o'\n if p.sim_run == p.sim_runs[0]: marker = '^'\n\n L_line = getattr(GR,'L_'+p.line+'_sun')#[380:400]#[0:100]\n SFR = getattr(GR,'SFR')#[380:400]#[0:100]\n M_star = getattr(GR,'M_star')#[380:400]#[0:100]\n Zsfr = getattr(GR,'Zsfr')#[380:400]#[0:100]\n R_gas = getattr(GR,'R2_gas')#[380:400]#[0:100]\n M_H2 = getattr(GR,'M_H2_R2_gas')#[380:400]#[0:100]\n\n SFR = SFR[L_line > 0]\n M_star = M_star[L_line > 0]\n Zsfr = Zsfr[L_line > 0]\n R_gas = R_gas[L_line > 0]\n M_H2 = M_H2[L_line > 0]\n L_line = L_line[L_line > 0]\n print('%i data points ' % (len(L_line)))\n\n # Distance from MS\n dlSFR = aux.distance_from_salim18(GR.M_star,GR.SFR)\n\n if p.add:\n ax = p.ax\n else:\n fig,ax = plt.subplots(figsize=(8,6))\n\n # Distance from observed relation\n L_obs,SFR_obs,fit,std = add_line_SFR_obs(p.line,[1e6,1e6],ax,plot=False,select=p.select)\n ldL_line = np.log10(L_line) - fit.predict(np.log10(SFR.reshape(-1, 1))).flatten()\n\n labs = {'_M10':'Mach=10 power-law',\\\n '_arepoPDF_ext':'AREPO parametric PDF with extinction',\\\n '_arepoPDF':'SIGAME v3',\\\n '_arepoPDF_CMZ':'SIGAME v3',\\\n '_arepoPDF_M51':'SIGAME v3'}\n lab = labs[p.table_ext]\n\n\n ax.text(0.05,0.9,p.line,transform=ax.transAxes,fontsize=13)\n ax.set_xlabel('log SFR - log SFR$_{MS,Salim+18}$')\n ax.set_ylabel('log L - log L$_{obs}$(SFR)')\n if not p.xlim: p.xlim = np.array([-3,3])\n if not p.ylim: \n p.ylim = [np.median(ldL_line) - 4,np.median(ldL_line) + 3]\n # if p.line == '[OI]63': p.ylim = [np.median(ldL_line) - 5,np.median(ldL_line) + 4]\n # if 'CO' in p.line: p.ylim = [np.median(ldL_line) - 4,np.median(ldL_line) + 4]\n\n ax.set_xlim(p.xlim)\n ax.set_ylim(p.ylim)\n ax.plot([0,0],ax.get_ylim(),'--k',lw=1)\n ax.plot(ax.get_xlim(),[0,0],'--k',lw=1)\n\n if p.select == 'Sigma_M_H2':\n Sigma_M_H2 = M_H2/(np.pi*R_gas**2)/1e6 # per pc^-2\n m = ax.scatter(dlSFR[np.argsort(Sigma_M_H2)],ldL_line[np.argsort(Sigma_M_H2)],marker=marker,s=14,\\\n c=np.log10(Sigma_M_H2[np.argsort(Sigma_M_H2)]),vmin=-2.5,vmax=2.2,label=lab,alpha=0.5,zorder=10)\n if p.cb:\n cbar = plt.colorbar(m,ax=ax)\n cbar.set_label(label=r'log $\\Sigma_{H2}$ [M$_{\\odot}$/pc$^2$]',size=15)","def plot_analysis(opt):\n LOG.debug(\"Plotting GetLLM analysis.\")\n mdl_analysis = opt.subnode in mdl_subnodes\n\n ps.set_style(\"standard\", MANUAL_STYLE)\n xmin = min(opt.xplot_xmin, opt.yplot_xmin)\n xmax = max(opt.xplot_xmax, opt.yplot_xmax)\n\n gs = gridspec.GridSpec(2, 1, height_ratios=[1, 1])\n ax_x = plt.subplot(gs[0])\n ax_y = None\n ir_pos = None\n\n paths = opt.path.split(',')\n\n if opt.label == 'None':\n if mdl_analysis:\n labels = [\"mo_\" + opt.path.rsplit('/', 1)[-1], \"me_\" + opt.path.rsplit('/', 1)[-1]]\n else:\n labels = paths\n else:\n labels = opt.label.split(',')\n\n for idx, path in enumerate(paths):\n data_x, data_y = get_data(path, opt.mainnode, opt.subnode)\n plot_data(ax_x, data_x, labels, idx, opt.change_marker)\n\n if ir_pos is None:\n ir_pos = get_irpos(data_x, opt.accel)\n\n if data_y is not None:\n if ax_y is None:\n ax_x.axes.get_xaxis().set_visible(False)\n ax_y = plt.subplot(gs[1])\n plot_data(ax_y, data_y, labels, idx, opt.change_marker)\n\n ax_x.set_xlim(xmin, xmax)\n ax_x.set_ylim(opt.xplot_ymin, opt.xplot_ymax)\n set_yaxis_label(ax_x, 'x', opt.subnode)\n\n if ax_y is not None:\n ax_y.set_xlim(xmin, xmax)\n ax_y.set_ylim(opt.yplot_ymin, opt.yplot_ymax)\n set_yaxis_label(ax_y, 'y', opt.subnode)\n ps.set_xaxis_label(ax_y)\n if ir_pos:\n ps.show_ir(ir_pos, ax_y, mode='outside')\n ps.show_ir(ir_pos, ax_x, mode='lines')\n else:\n ax_x.axes.get_xaxis().set_visible(True)\n ps.set_xaxis_label(ax_x)\n if ir_pos:\n ps.show_ir(ir_pos, ax_x, mode='outside')\n\n if int(opt.legendh) > 12:\n show_legend(ax_x, int(opt.legendx), int(opt.legendy))\n return gs","def SLTrace(self,NSL=12,Pts=[]):\n \n #Grid edge\n Bound_vert=[(0,0),(1,0),(1,1),(0,1),(0,0)]\n Bound_vert_phy=[]\n for i in range(len(Bound_vert)):\n Bound_vert_phy.append(self.Pts2Physic(Bound_vert[i]))\n \n #Streamline\n if(len(Pts)==0): #if the initial Pts are not provided\n Pts=PointOnUnitSquare(NSL,Endpoint=False)\n else:\n NSL=len(Pts)\n \n SL=[]\n SL_phy=[]\n TOF_phy=[]\n \n for i in range(len(Pts)):\n temp=self.Trace1SL(Pts[i])\n SL.append(temp[2])\n SL_phy.append(temp[3])\n TOF_phy.append(temp[5])\n \n #SL_phy=self.RotateSL(SL_phy)\n #SL_phy=self.TranslateSL(SL_phy)\n \n fig, axs = plt.subplots(ncols=2)\n \n ax=axs[0]\n ax.plot(*np.asarray(Bound_vert).T,lw=3,color='red')\n for i in range(len(Pts)):\n ax.plot(*np.asarray(SL[i]).T,lw=1,marker='o',markersize=1,color='blue')\n ax.set_ylim(bottom=0)\n ax.set_aspect('equal')\n ax.set_title(r'Transformed Space ($\\alpha,\\beta$)')\n \n ax=axs[1]\n ax.plot(*np.asarray(Bound_vert_phy).T,lw=3,color='red')\n for i in range(len(Pts)):\n ax.plot(*np.asarray(SL_phy[i]).T,lw=1,marker='o',markersize=1,color='blue')\n ax.set_ylim(bottom=0)\n ax.set_aspect('equal')\n ax.set_title(r'Physical Space ($x,y$)')\n\n fig.tight_layout()\n plt.show()\n return SL_phy,TOF_phy","def plot_stream(x,y,gvx,gvy,oargs,outfile):\r\n\t\r\n\tme = \"LE_Plot.plot_stream: \"\r\n\t\r\n\t## Expand out parameters\r\n\tb,X,xmax,ymax,BW,smooth = oargs\r\n\tgv = np.sqrt(gvx*gvx+gvy*gvy)\r\n\t\t\r\n\tshowplot = False\r\n\r\n\t## Smooth data\r\n\tif smooth is not 0.0:\r\n\t\tgvy = gaussian_filter(gvy, smooth)\r\n\t\tgvx = gaussian_filter(gvx, smooth)\r\n\t\tgv = gaussian_filter(gv, smooth)\r\n\toutfile += \"_sm\"+str(smooth)\r\n\t\t\r\n\t## --------------------------------------------------------------------\t\r\n\t\r\n\t## Plotting\r\n\t\r\n\tt0 = time.time()\r\n\tfs = 25\r\n\t\r\n\tfig = plt.figure(facecolor=\"white\")\r\n\tfig.suptitle(outfile)\r\n\t\r\n\t## Add subplot with exact solution\r\n\tif not BW:\r\n\t\tfrom LE_ExactHO import main as plot_exact\r\n\t\tax1 = fig.add_subplot(121,aspect=\"auto\")\r\n\t\tax2 = fig.add_subplot(122,aspect=\"auto\",sharey=ax1)\r\n\t\tplot_exact((ax2,xmax,ymax,b,False))\r\n\t\tfig.tight_layout();fig.subplots_adjust(top=0.93)\r\n\t\tprint me+\"Plotting exact\",round(time.time()-t0,1),\"seconds\"\r\n\telse:\r\n\t\tax1 = fig.add_subplot(111)\r\n\t\r\n\t## Accoutrements\t\r\n\tax1.set_xlim([-xmax,xmax]);\tax1.set_ylim([-ymax,ymax])\r\n\tax1.set_xlabel(\"$x$\",fontsize=fs);ax1.set_ylabel(\"$\\eta$\",fontsize=fs)\r\n\t## Plot wall positions if BW; plot separatrix if HO\r\n\tif BW:\tplot_walls(ax1, X, xmax,ymax,2)\r\n\telse:\tplot_separatrix(ax1, b, xmax, ymax, 2)\r\n\t\r\n\t## Line widths\r\n\tlw1 = 3.0*gv/gv.max()\r\n\t\r\n\tt0=time.time()\r\n\t## Plot absolute speed contour and streamplot\r\n\t## NOTE fudge (-) to force agreement with exact\r\n\t# ax1.contourf(xi,yi,gv, 4, alpha=0.4)\r\n\tax1.streamplot(-x,y, -gvx,gvy, arrowsize=1.8, arrowstyle=\"->\", linewidth=lw1, minlength=xmax/20)\r\n\t\t\t\r\n\tprint me+\"Plotting data \",round(time.time()-t0,1),\"seconds\"; t0=time.time()\r\n\t\t\r\n\t## Output\r\n\tfig.savefig(outfile+\".png\",facecolor=fig.get_facecolor(), edgecolor=\"none\")\r\n\tprint me+\"Plot saved\",outfile+\".png\"\r\n\tif showplot:\tplt.show()\r\n\r\n\tplt.close()\r\n\t\t\t\r\n\treturn","def load_nir_alcohol():\n\n # loading matlab data set\n raw_data = sio.loadmat(__data_set_path)\n\n # ----------------\n\n # getting all variable/features labels\n var_labels_all = raw_data['var_labels_all'].tolist()\n\n # getting spectra labels\n var_labels_spectra = [int(l) for l in var_labels_all[3:]]\n\n # getting properties labels\n var_labels_properties = var_labels_all[:3]\n\n # ----------------\n\n # getting all data (train-new-msc)\n data_all = raw_data['data_all']\n\n # getting spectra data\n data_spectra = data_all[:, 3:]\n\n # getting properties data\n data_properties = data_all[:, :3]\n\n # ----------------\n\n obj_labels_train = raw_data['obj_labels_train'].tolist()\n data_train = data_spectra[:27, :]\n other_cols_train = {p_name: p_data for p_name, p_data in zip(var_labels_properties, data_properties[:27, :].T)}\n\n ds_train = utils.build_data_set(data_train, obj_labels_train, var_labels_spectra, extra_cols=other_cols_train)\n\n # ----------------\n\n obj_labels_new = raw_data['obj_labels_new'].tolist()\n data_new = data_spectra[27:40, :]\n other_cols_new = {p_name: p_data for p_name, p_data in zip(var_labels_properties, data_properties[27:40, :].T)}\n\n ds_new = utils.build_data_set(data_new, obj_labels_new, var_labels_spectra, extra_cols=other_cols_new)\n\n # ----------------\n\n obj_labels_msc = raw_data['obj_labels_mscorrected'].tolist()\n data_msc = data_spectra[40:, :]\n other_cols_msc = {p_name: p_data for p_name, p_data in zip(var_labels_properties, data_properties[40:, :].T)}\n\n ds_msc = utils.build_data_set(data_msc, obj_labels_msc, var_labels_spectra, extra_cols=other_cols_msc)\n\n # ----------------\n\n # training/validation data sets and labels\n data_sets = [ds_train, ds_new, ds_msc]\n labels = ['train', 'new', 'msc']\n\n # actually building the joint data set\n ds = pd.concat(data_sets, keys=labels)\n\n # returning the final data set\n return ds","def plot_loss_landscape(\n path: str,\n **plot_kwargs,\n):\n a = np.load(path)\n n = a['train_acc'].shape[0]\n\n plt.subplot(221)\n for i in range(n):\n plt.plot(a['ts'], a['train_acc'][i, :], \".-\",\n **plot_kwargs)\n plt.xlabel('Perturbation')\n plt.ylabel('Train Accuracy')\n\n plt.subplot(222)\n for i in range(n):\n plt.plot(a['ts'], a['test_acc'][i, :], \".-\", **plot_kwargs)\n plt.xlabel('Perturbation')\n plt.ylabel('Test Accuracy')\n\n plt.subplot(223)\n for i in range(n):\n plt.plot(a['ts'], a['train_loss'][i, :], \".-\", **plot_kwargs)\n plt.xlabel('Perturbation')\n plt.ylabel('Train Loss')\n\n plt.subplot(224)\n for i in range(n):\n plt.plot(a['ts'], a['test_loss'][i, :], \".-\", label='$\\lambda = $' + str(a['eigvals'][a['idx'][i]]),\n **plot_kwargs)\n plt.xlabel('Perturbation')\n plt.ylabel('Test Loss')\n\n plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)","def to_neptune(self, **kwargs) -> 'PlotLosses':\n self.outputs.append(outputs.NeptuneLogger(**kwargs))\n return self","def make_llr_plots(self):\n import matplotlib.pyplot as plt\n plt.rcParams['text.usetex'] = True\n\n outdir = os.path.join(self.outdir, 'LLRDistributions')\n mkdir(outdir)\n\n for injkey in self.values.keys():\n\n data = self.values[injkey]\n metric_type = data['h0_fit_to_h0_fid']['metric_val']['type']\n metric_type_pretty = self.tex_axis_label(metric_type)\n h0_fid_metric = self.fid_values[injkey][\n 'h0_fit_to_%s'%self.labels.dict['data']\n ][\n 'metric_val'\n ]\n h1_fid_metric = self.fid_values[injkey][\n 'h1_fit_to_%s'%self.labels.dict['data']\n ][\n 'metric_val'\n ]\n\n h0_fit_to_h0_fid_metrics = np.array(\n data['h0_fit_to_h0_fid']['metric_val']['vals']\n )\n h1_fit_to_h0_fid_metrics = np.array(\n data['h1_fit_to_h0_fid']['metric_val']['vals']\n )\n h0_fit_to_h1_fid_metrics = np.array(\n data['h0_fit_to_h1_fid']['metric_val']['vals']\n )\n h1_fit_to_h1_fid_metrics = np.array(\n data['h1_fit_to_h1_fid']['metric_val']['vals']\n )\n\n # In the case of likelihood, the maximum metric is the better fit.\n # With chi2 metrics the opposite is true, and so we must multiply\n # everything by -1 in order to apply the same treatment.\n if 'chi2' in metric_type:\n logging.info('Converting chi2 metric to likelihood equivalent.')\n h0_fid_metric *= -1\n h1_fid_metric *= -1\n h0_fit_to_h0_fid_metrics *= -1\n h1_fit_to_h0_fid_metrics *= -1\n h0_fit_to_h1_fid_metrics *= -1\n h1_fit_to_h1_fid_metrics *= -1\n\n if h1_fid_metric < h0_fid_metric:\n bestfit = 'h0'\n altfit = 'h1'\n critical_value = h0_fid_metric-h1_fid_metric\n else:\n bestfit = 'h1'\n altfit = 'h0'\n critical_value = h1_fid_metric-h0_fid_metric\n\n if bestfit == 'h0':\n llrbest = h0_fit_to_h0_fid_metrics - h1_fit_to_h0_fid_metrics\n llralt = h0_fit_to_h1_fid_metrics - h1_fit_to_h1_fid_metrics\n else:\n llrbest = h1_fit_to_h1_fid_metrics - h0_fit_to_h1_fid_metrics\n llralt = h1_fit_to_h0_fid_metrics - h0_fit_to_h0_fid_metrics\n\n minllr = min(min(llrbest), min(llralt))\n maxllr = max(max(llrbest), max(llralt))\n rangellr = maxllr - minllr\n # Special case for low numbers of trials. Here, the plot\n # can't really be interpreted but the numbers printed on\n # it can still be useful, so we need to make something.\n if self.num_trials < 100:\n binning = np.linspace(minllr - 0.1*rangellr,\n maxllr + 0.1*rangellr,\n 10)\n elif self.num_trials < 2000:\n binning = np.linspace(minllr - 0.1*rangellr,\n maxllr + 0.1*rangellr,\n int(self.num_trials/40))\n else:\n binning = np.linspace(minllr - 0.1*rangellr,\n maxllr + 0.1*rangellr,\n 50)\n binwidth = binning[1]-binning[0]\n\n llrbesthist, llrbestbinedges = np.histogram(llrbest, bins=binning)\n llralthist, llraltbinedges = np.histogram(llralt, bins=binning)\n\n llrhistmax = max(max(llrbesthist), max(llralthist))\n\n best_median = np.median(llrbest)\n\n if self.labels.dict['data_name'] == '':\n inj_name = \"data\"\n else:\n inj_name = \"true %s\"%self.tex_axis_label(\n self.labels.dict['data_name']\n )\n best_name = self.labels.dict['%s_name'%bestfit]\n alt_name = self.labels.dict['%s_name'%altfit]\n\n # Calculate p values\n ## First for the preferred hypothesis based on the fiducial fit\n crit_p_value, unc_crit_p_value = self.calc_p_value(\n llrdist=llralt,\n critical_value=critical_value\n )\n ## Then for the alternate hypothesis based on the fiducial fit\n alt_crit_p_value, alt_unc_crit_p_value = self.calc_p_value(\n llrdist=llrbest,\n critical_value=critical_value\n )\n ## Combine these to give a cls value based on arXiv:1407.5052\n cls_value = (1 - alt_crit_p_value) / (1 - crit_p_value)\n unc_cls_value = cls_value * np.sqrt(\n np.power(alt_unc_crit_p_value/alt_crit_p_value, 2.0) + \\\n np.power(unc_crit_p_value/crit_p_value, 2.0)\n )\n ## Then for the preferred hypothesis based on the median. That\n ## is, the case of a median experiment from the distribution\n ## under the preferred hypothesis.\n med_p_value, unc_med_p_value, median_error = self.calc_p_value(\n llrdist=llralt,\n critical_value=best_median,\n median_p_value=True,\n llrbest=llrbest\n )\n\n if metric_type == 'llh':\n plot_title = (r\"\\begin{center}\"\\\n +\"%s %s Event Selection \"%(self.detector,\n self.selection)\\\n +r\"\\\\\"+\" llr Distributions for %s (%i trials)\"%(\n inj_name, self.num_trials)\\\n +r\"\\end{center}\")\n\n else:\n plot_title = (r\"\\begin{center}\"\\\n +\"%s %s Event Selection \"%(self.detector,\n self.selection)\\\n +r\"\\\\\"+\" %s \\\"llr\\\" Distributions for \"\n %(metric_type_pretty)\\\n +\"%s (%i trials)\"%(inj_name,\n self.num_trials)\\\n +r\"\\end{center}\")\n\n # Factor with which to make everything visible\n plot_scaling_factor = 1.55\n\n # In case of median plot, draw both best and alt histograms\n ## Set up the labels for the histograms\n llr_labels = [\n r\"%s Pseudo-Experiments - \"%(self.tex_axis_label(best_name)) + \\\n r\"$\\log\\left[\\mathcal{L}\\left(\\mathcal{H}_{%s}\"%(best_name) + \\\n r\"\\right)/\\mathcal{L}\\left(\\mathcal{H}_{%s}\\right)\\right]$\"%(\n alt_name),\n r\"%s Pseudo-Experiments - \"%(self.tex_axis_label(alt_name)) + \\\n r\"$\\log\\left[\\mathcal{L}\\left(\\mathcal{H}_{%s}\"%(best_name) + \\\n r\"\\right)/\\mathcal{L}\\left(\\mathcal{H}_{%s}\\right)\\right]$\"%(\n alt_name)\n ]\n self.plot_llr_histograms(\n llrarrays=[llrbest, llralt],\n llrhistmax=llrhistmax,\n binning=binning,\n colors=['r', 'b'],\n labels=llr_labels,\n best_name=best_name,\n alt_name=alt_name,\n critical_value=best_median,\n critical_label=r\"%s Median = $%.4f\\pm%.4f$\"%(\n self.tex_axis_label(best_name),\n best_median,\n median_error),\n critical_height=float(max(llrbesthist))/float(\n plot_scaling_factor*llrhistmax),\n llrhist=llralthist\n )\n plt.legend(loc='upper left')\n plt.title(plot_title)\n # Write the p-value on the plot\n plt.figtext(\n 0.15,\n 0.66,\n r\"$\\mathrm{p}\\left(\\mathcal{H}_{%s}\\right) = %.4f\\pm%.4f$\"%(\n best_name, med_p_value, unc_med_p_value),\n color='k',\n size='xx-large'\n )\n self.save_plot(\n outdir=outdir,\n end='%s_llrDistribution_median_%i_Trials'%(\n metric_type, self.num_trials)\n )\n # Add the extra points if they exist\n if self.extra_points is not None:\n plt.legend(loc='upper left', fontsize=11)\n curleg = plt.gca().get_legend()\n linelist = self.add_extra_points(\n ymax=float(max(llrbesthist))/float(\n plot_scaling_factor*llrhistmax)\n )\n handles, labels = plt.gca().get_legend_handles_labels()\n newhandles = []\n for l, h in zip(labels, handles):\n if l in linelist:\n newhandles.append(h)\n newleg = plt.legend(\n handles=newhandles,\n loc='upper right',\n fontsize=11\n )\n plt.gca().add_artist(newleg)\n plt.gca().add_artist(curleg)\n self.save_plot(\n outdir=outdir,\n end='%s_llrDistribution_median_w_extra_points_%i_Trials'%(\n metric_type, self.num_trials)\n )\n plt.close()\n\n # Make some debugging plots\n ## Set up the labels for the histograms\n llr_labels = [\n r\"%s Pseudo-Experiments - \"%(self.tex_axis_label(best_name)) + \\\n r\"$\\log\\left[\\mathcal{L}\\left(\\mathcal{H}_{%s}\"%(best_name) + \\\n r\"\\right)/\\mathcal{L}\\left(\\mathcal{H}_{%s}\\right)\\right]$\"%(\n alt_name),\n r\"%s Pseudo-Experiments - \"%(self.tex_axis_label(alt_name)) + \\\n r\"$\\log\\left[\\mathcal{L}\\left(\\mathcal{H}_{%s}\"%(best_name) + \\\n r\"\\right)/\\mathcal{L}\\left(\\mathcal{H}_{%s}\\right)\\right]$\"%(\n alt_name)\n ]\n self.plot_llr_histograms(\n llrarrays=[llrbest, llralt],\n llrhistmax=llrhistmax,\n binning=binning,\n colors=['r', 'b'],\n labels=llr_labels,\n best_name=best_name,\n alt_name=alt_name,\n critical_value=best_median,\n critical_label=r\"%s Median = $%.4f\\pm%.4f$\"%(\n self.tex_axis_label(best_name),\n best_median,\n median_error),\n critical_height=float(max(llrbesthist))/float(\n plot_scaling_factor*llrhistmax),\n llrhist=None\n )\n plt.legend(loc='upper left')\n plt.title(plot_title)\n self.save_plot(\n outdir=outdir,\n end='%s_llrDistribution_median_both_fit_dists_%i_Trials'%(\n metric_type, self.num_trials)\n )\n plt.close()\n ## Set up the labels for the histograms\n llr_labels = [\n r\"%s Pseudo-Experiments - \"%(self.tex_axis_label(best_name)) + \\\n r\"$\\log\\left[\\mathcal{L}\\left(\\mathcal{H}_{%s}\" + \\\n r\"\\right)/\\mathcal{L}\\left(\\mathcal{H}_{%s}\\right)\\right]$\"%(\n alt_name),\n ]\n self.plot_llr_histograms(\n llrarrays=[llrbest],\n llrhistmax=llrhistmax,\n binning=binning,\n colors=['r'],\n labels=llr_labels,\n best_name=best_name,\n alt_name=alt_name,\n critical_value=None,\n critical_label=None,\n critical_height=None,\n llrhist=None\n )\n plt.legend(loc='upper left')\n plt.title(plot_title)\n self.save_plot(\n outdir=outdir,\n end='%s_llrDistribution_best_fit_dist_%i_Trials'%(\n metric_type, self.num_trials)\n )\n plt.close()\n ## Set up the labels for the histograms\n llr_labels = [\n r\"%s Pseudo-Experiments - \"%(self.tex_axis_label(best_name)) + \\\n r\"$\\log\\left[\\mathcal{L}\\left(\\mathcal{H}_{%s}\"%(best_name) + \\\n r\"\\right)/\\mathcal{L}\\left(\\mathcal{H}_{%s}\\right)\\right]$\"%(\n alt_name),\n ]\n self.plot_llr_histograms(\n llrarrays=[llrbest],\n llrhistmax=llrhistmax,\n binning=binning,\n colors=['r'],\n labels=llr_labels,\n best_name=best_name,\n alt_name=alt_name,\n critical_value=best_median,\n critical_label=r\"%s Median = $%.4f\\pm%.4f$\"%(\n self.tex_axis_label(best_name),\n best_median,\n median_error),\n critical_height=float(max(llrbesthist))/float(\n plot_scaling_factor*llrhistmax),\n llrhist=None\n )\n plt.legend(loc='upper left')\n plt.title(plot_title)\n self.save_plot(\n outdir=outdir,\n end='%s_llrDistribution_median_best_fit_dist_%i_Trials'%(\n metric_type, self.num_trials)\n )\n plt.close()\n ## Set up the labels for the histograms\n llr_labels = [\n r\"%s Pseudo-Experiments - \"%(self.tex_axis_label(alt_name)) + \\\n r\"$\\log\\left[\\mathcal{L}\\left(\\mathcal{H}_{%s}\"%(best_name) + \\\n r\"\\right)/\\mathcal{L}\\left(\\mathcal{H}_{%s}\\right)\\right]$\"%(\n alt_name)\n ]\n self.plot_llr_histograms(\n llrarrays=[llralt],\n llrhistmax=llrhistmax,\n binning=binning,\n colors=['b'],\n labels=llr_labels,\n best_name=best_name,\n alt_name=alt_name,\n critical_value=None,\n critical_label=None,\n critical_height=None,\n llrhist=None\n )\n plt.legend(loc='upper left')\n plt.title(plot_title)\n self.save_plot(\n outdir=outdir,\n end='%s_llrDistribution_alt_fit_dist_%i_Trials'%(\n metric_type, self.num_trials)\n )\n plt.close()\n ## Set up the labels for the histograms\n llr_labels = [\n r\"%s Pseudo-Experiments - \"%(self.tex_axis_label(alt_name)) + \\\n r\"$\\log\\left[\\mathcal{L}\\left(\\mathcal{H}_{%s}\" + \\\n r\"\\right)/\\mathcal{L}\\left(\\mathcal{H}_{%s}\\right)\\right]$\"%(\n alt_name)\n ]\n self.plot_llr_histograms(\n llrarrays=[llralt],\n llrhistmax=llrhistmax,\n binning=binning,\n colors=['b'],\n labels=llr_labels,\n best_name=best_name,\n alt_name=alt_name,\n critical_value=best_median,\n critical_label=r\"%s Median = $%.4f\\pm%.4f$\"%(\n self.tex_axis_label(best_name),\n best_median,\n median_error),\n critical_height=float(max(llrbesthist))/float(\n plot_scaling_factor*llrhistmax),\n llrhist=llralthist\n )\n plt.legend(loc='upper left')\n plt.title(plot_title)\n # Write the p-value on the plot\n plt.figtext(\n 0.15,\n 0.66,\n r\"$\\mathrm{p}\\left(\\mathcal{H}_{%s}\\right) = %.4f\\pm%.4f$\"%(\n best_name, med_p_value, unc_med_p_value),\n color='k',\n size='xx-large'\n )\n self.save_plot(\n outdir=outdir,\n end='%s_llrDistribution_median_alt_fit_dist_%i_Trials'%(\n metric_type, self.num_trials)\n )\n plt.close()\n\n # In case of critical plot, draw just alt histograms\n ## Set up the label for the histogram\n llr_labels = [\n r\"%s Pseudo-Experiments - \"%(self.tex_axis_label(alt_name)) + \\\n r\"$\\log\\left[\\mathcal{L}\\left(\\mathcal{H}_{%s}\"%(best_name) + \\\n r\"\\right)/\\mathcal{L}\\left(\\mathcal{H}_{%s}\\right)\\right]$\"%(\n alt_name)\n ]\n self.plot_llr_histograms(\n llrarrays=[llralt],\n llrhistmax=llrhistmax,\n binning=binning,\n colors=['b'],\n labels=llr_labels,\n best_name=best_name,\n alt_name=alt_name,\n critical_value=critical_value,\n critical_label=r\"Critical Value = %.4f\"%(critical_value),\n critical_height=float(max(llrbesthist))/float(\n plot_scaling_factor*llrhistmax),\n llrhist=llralthist\n )\n plt.legend(loc='upper left')\n plt.title(plot_title)\n # Write the p-value on the plot\n plt.figtext(\n 0.15,\n 0.70,\n r\"$\\mathrm{p}\\left(\\mathcal{H}_{%s}\\right) = %.4f\\pm%.4f$\"%(\n best_name, crit_p_value, unc_crit_p_value),\n color='k',\n size='xx-large'\n )\n self.save_plot(\n outdir=outdir,\n end='%s_llrDistribution_critical_%i_Trials'%(\n metric_type, self.num_trials)\n )\n plt.close()\n\n # Make a second critical plot for the alt hypothesis, so we draw the\n # preferred hypothesis\n ## Set up the label for the histogram\n llr_labels = [\n r\"%s Pseudo-Experiments - \"%(self.tex_axis_label(best_name)) + \\\n r\"$\\log\\left[\\mathcal{L}\\left(\\mathcal{H}_{%s}\"%(best_name) + \\\n r\"\\right)/\\mathcal{L}\\left(\\mathcal{H}_{%s}\\right)\\right]$\"%(\n alt_name)\n ]\n self.plot_llr_histograms(\n llrarrays=[llrbest],\n llrhistmax=llrhistmax,\n binning=binning,\n colors=['r'],\n labels=llr_labels,\n best_name=best_name,\n alt_name=alt_name,\n critical_value=critical_value,\n critical_label=r\"Critical Value = %.4f\"%(critical_value),\n critical_height=float(max(llrbesthist))/float(\n plot_scaling_factor*llrhistmax),\n llrhist=llrbesthist\n )\n plt.legend(loc='upper left')\n plt.title(plot_title)\n # Write the p-value on the plot\n plt.figtext(\n 0.15,\n 0.70,\n r\"$\\mathrm{p}\\left(\\mathcal{H}_{%s}\\right) = %.4f\\pm%.4f$\"%(\n alt_name, alt_crit_p_value, alt_unc_crit_p_value),\n color='k',\n size='xx-large'\n )\n self.save_plot(\n outdir=outdir,\n end='%s_llrDistribution_critical_alt_%i_Trials'%(\n metric_type, self.num_trials)\n )\n plt.close()\n\n # Lastly, show both exclusion regions and then the joined cls value\n ## Set up the labels for the histograms\n llr_labels = [\n r\"%s Pseudo-Experiments - \"%(self.tex_axis_label(best_name)) + \\\n r\"$\\log\\left[\\mathcal{L}\\left(\\mathcal{H}_{%s}\"%(best_name) + \\\n r\"\\right)/\\mathcal{L}\\left(\\mathcal{H}_{%s}\\right)\\right]$\"%(\n alt_name),\n r\"%s Pseudo-Experiments - \"%(self.tex_axis_label(alt_name)) + \\\n r\"$\\log\\left[\\mathcal{L}\\left(\\mathcal{H}_{%s}\"%(best_name) + \\\n r\"\\right)/\\mathcal{L}\\left(\\mathcal{H}_{%s}\\right)\\right]$\"%(\n alt_name)\n ]\n self.plot_llr_histograms(\n llrarrays=[llrbest, llralt],\n llrhistmax=llrhistmax,\n binning=binning,\n colors=['r', 'b'],\n labels=llr_labels,\n best_name=best_name,\n alt_name=alt_name,\n critical_value=critical_value,\n critical_label=r\"Critical Value = %.4f\"%(critical_value),\n critical_height=float(max(llrbesthist))/float(\n plot_scaling_factor*llrhistmax),\n llrhist=[llrbesthist, llralthist],\n cls=True,\n )\n plt.legend(loc='upper left')\n plt.title(plot_title)\n # Write the p-values on the plot\n plt.figtext(\n 0.50,\n 0.66,\n r\"$\\mathrm{CL}_{s}\\left(\\mathcal{H}_{%s}\"%(best_name) + \\\n r\"\\right)= %.4f\\pm%.4f$\"%(cls_value, unc_cls_value),\n horizontalalignment='center',\n color='k',\n size='xx-large'\n )\n plt.figtext(\n 0.12,\n 0.55,\n r\"$\\mathrm{p}\\left(\\mathcal{H}_{%s}\\right) = %.2f\\pm%.2f$\"%(\n alt_name, alt_crit_p_value, alt_unc_crit_p_value),\n bbox=dict(facecolor='none', edgecolor='red', boxstyle='round'),\n horizontalalignment='left',\n color='k',\n size='x-large'\n )\n plt.figtext(\n 0.88,\n 0.55,\n r\"$\\mathrm{p}\\left(\\mathcal{H}_{%s}\\right) = %.2f\\pm%.2f$\"%(\n best_name, crit_p_value, unc_crit_p_value),\n horizontalalignment='right',\n bbox=dict(facecolor='none', edgecolor='blue', boxstyle='round'),\n color='k',\n size='x-large'\n )\n self.save_plot(\n outdir=outdir,\n end='%s_llrDistribution_CLs_%i_Trials'%(\n metric_type, self.num_trials)\n )\n plt.close()","def plot_raft_map(data, img, TITLE, OUTDIR, vmin=None, vmax=None):\n\n map = np.zeros((6, 24))\n for i, fli in enumerate(img):\n x = (fli.dev_index / 3) * 2 # [0, 2, 4]\n y = (fli.dev_index % 3) * 8 # [0, 8, 16]\n for j in range(16):\n xx = x + j / 8 # [0, 1,..., 5]\n yy = y + j % 8 # [0, 1,..., 23]\n map[xx, yy] = data[i, j]\n\n yseg = range(6)\n ylab = [\"00-07\", \"10-17\", \"00-07\", \"10-17\", \"00-07\", \"10-17\"]\n xseg = range(0, 24, 4)\n xlab = [\"0\", \"4\", \"0\", \"4\", \"0\", \"4\"]\n\n fig = plt.figure(figsize=(10, 10))\n ax1 = fig.add_subplot(111)\n im = ax1.imshow(map, interpolation='nearest', cmap='jet', aspect=4, vmin=vmin, vmax=vmax)\n plt.yticks(yseg, ylab)\n plt.xticks(xseg, xlab)\n plt.annotate('S22', xy=(0, 0), xytext=(4, -0.8), fontsize=15, ha='center', va='center')\n plt.annotate('S12', xy=(0, 0), xytext=(12, -0.8), fontsize=15, ha='center', va='center')\n plt.annotate('S02', xy=(0, 0), xytext=(20, -0.8), fontsize=15, ha='center', va='center')\n plt.annotate('S02', xy=(0, 0), xytext=(24., 0.5), fontsize=15, ha='left', va='center')\n plt.annotate('S01', xy=(0, 0), xytext=(24., 2.5), fontsize=15, ha='left', va='center')\n plt.annotate('S00', xy=(0, 0), xytext=(24., 4.5), fontsize=15, ha='left', va='center')\n ax1.vlines(7.5, -0.5, 5.5)\n ax1.vlines(15.5, -0.5, 5.5)\n ax1.hlines(1.5, -0.5, 23.5)\n ax1.hlines(3.5, -0.5, 23.5)\n plt.subplots_adjust(left=0.07, bottom=0.05, right=0.8, top=0.95, wspace=0, hspace=0)\n #cbar_ax = fig.add_axes([0.15, 0.03, 0.7, 0.05])\n #fig.colorbar(im, cax=cbar_ax, orientation=\"horizontal\")\n cbar_ax = fig.add_axes([0.87, 0.15, 0.05, 0.7])\n fig.colorbar(im, cax=cbar_ax)\n fig.suptitle(TITLE, y=0.98, size=19)\n plt.savefig(OUTDIR + TITLE + '.png')\n plt.show()\n plt.close(fig)","def logplot(in_dir, fname, xlim, ylim, title):\n\n with open(in_dir + fname,'r') as logfile:\n lf_lines = logfile.readlines()\n\n traj_x = []\n traj_y = []\n\n for row in lf_lines:\n if row[:4] == 'pose':\n #print(float(row[10:-2]))\n tup = row[7:]\n sep_pos = tup.find(' , ')\n traj_x.append(float(tup[:sep_pos]))\n traj_y.append(float(tup[sep_pos+3:]))\n\n liveplot(traj_x, traj_y, xlim, ylim, title)","def add_lvs_correspondence_points(self):\n\n pin = self.rbl_inv_inst.get_pin(\"A\")\n self.add_label_pin(text=\"bl[0]\",\n layer=pin.layer,\n offset=pin.ll(),\n height=pin.height(),\n width=pin.width())\n\n pin = self.dc_inst.get_pin(\"out\")\n self.add_label_pin(text=\"delayed_en\",\n layer=pin.layer,\n offset=pin.ll(),\n height=pin.height(),\n width=pin.width())","def streamlines(ax, mesh, umean):\n Nx,Ny = 1001, 401\n xcart = np.linspace(0,10,Nx)\n ycart = np.linspace(0,4,Ny)\n meshcart = np.vstack( map(lambda x: x.flatten(), np.meshgrid(xcart, ycart)) ).T\n interp_u = tri.LinearTriInterpolator(mesh, umean[:,0])\n interp_v = tri.LinearTriInterpolator(mesh, umean[:,1])\n ucart = interp_u(meshcart[:,0], meshcart[:,1])\n vcart = interp_v(meshcart[:,0], meshcart[:,1])\n X = meshcart[:,0].reshape(Ny,Nx)\n Y = meshcart[:,1].reshape(Ny,Nx)\n U = ucart.reshape(Ny,Nx)\n V = vcart.reshape(Ny,Nx)\n lw = np.sqrt(U**2+V**2)*3\n start_points=np.vstack((np.ones(10)*0.1, np.linspace(1,3,10))).T\n ###ax.streamplot(X, Y, U, V, density=.8, color='k', linewidth=1.)\n strm = ax.streamplot(xcart, ycart, U, V, start_points=[[4,2]], color='k', linewidth=1.)\n for path in strm.lines.get_paths():\n path.vertices","def line_sSFR(**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n GR = glo.global_results()\n \n L_line = getattr(GR,'L_'+p.line+'_sun')#[0:100]\n SFR = getattr(GR,'SFR')#[0:100]\n Zsfr = getattr(GR,'Zsfr')#[0:100]\n R_gas = getattr(GR,'R2_gas')#[0:100]\n M_H2 = getattr(GR,'M_H2_R2_gas')#[0:100]\n M_star = getattr(GR,'M_star')#[0:100]\n\n # Take only MS galaxies?\n if p.select == '_MS':\n indices = aux.select_salim18(GR.M_star,GR.SFR)\n L_line = L_line[indices]\n SFR = SFR[indices]\n Zsfr = Zsfr[indices]\n print('With MS selection criteria: only %i galaxies' % (len(L_line)))\n\n SFR = SFR[L_line > 0]\n Zsfr = Zsfr[L_line > 0]\n R_gas = R_gas[L_line > 0]\n M_H2 = M_H2[L_line > 0]\n M_star = M_star[L_line > 0]\n sSFR = SFR/M_star\n L_line = L_line[L_line > 0]\n\n print('%i data points ' % (len(L_line)))\n\n labs = {'_M10':'Mach=10 power-law',\\\n '_arepoPDF_dim':'AREPO parametric PDF with extinction',\\\n '_arepoPDF':'AREPO parametric PDF'}\n lab = labs[p.table_ext]\n\n if p.add:\n ax = p.ax\n else:\n fig,ax = plt.subplots(figsize=(8,6))\n\n if p.select == 'Sigma_M_H2':\n Sigma_M_H2 = M_H2/(np.pi*R_gas**2)\n m = ax.scatter(sSFR[np.argsort(Sigma_M_H2)],L_line[np.argsort(Sigma_M_H2)],marker='o',s=20,\\\n c=np.log10(Sigma_M_H2[np.argsort(Sigma_M_H2)]),vmin=3.5,label=lab,alpha=0.6,zorder=10)\n cbar = plt.colorbar(m,ax=ax)\n cbar.set_label(label=r'log $\\Sigma_{H2}$ [M$_{\\odot}$/kpc$^2$]',size=15)\n else:\n m = ax.scatter(sSFR,L_line,marker='o',s=20,\\\n c=Zsfr,label=lab,alpha=0.6,zorder=10)\n cbar = plt.colorbar(m,ax=ax)\n cbar.set_label(label=r'$\\langle Z\\rangle_{\\mathrm{SFR}}$ [Z$_{\\odot}$]',size=15)\n\n if p.add_obs:\n add_line_sSFR_obs(p.line,L_line,ax,select=p.select)\n\n ax.set_xscale('log')\n ax.set_yscale('log')\n ax.set_xlabel(getlabel('sSFR'))\n ax.set_ylabel(getlabel(p.line))\n handles,labels = ax.get_legend_handles_labels()\n handles = np.flip(handles)\n labels = np.flip(labels)\n # ax.legend(handles,labels,loc='upper left',fontsize=7)\n ax.legend(handles,labels,loc='lower right',fontsize=7,frameon=True,framealpha=0.5) \n print(np.min(sSFR),np.max(sSFR))\n if not p.xlim: p.xlim = 10.**np.array([-13,-7])\n if not p.ylim: \n p.ylim = [np.median(L_line)/1e6,np.median(L_line)*1e4]\n ax.set_xlim(p.xlim)\n ax.set_ylim(p.ylim)\n ax.grid(ls='--')\n\n if p.savefig & (not p.add):\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \n plt.savefig(p.d_plot + 'luminosity/%s_sSFR.png' % p.line, format='png', dpi=300)","def __init__(self,\n logs_dirs = ['LOGS'],\n profile_paths = [],\n history_paths = [],\n clean_data = True,\n extra_history_cols = [],\n identifier = \"eps_nuc\",\n extractor = default_extractor,\n log10_on_data = True,\n contour_colormap = plt.get_cmap(\"Blues\"),\n levels = [],\n log_levels = True,\n num_levels = 8,\n xaxis = \"model_number\",\n xaxis_divide = 1.0,\n time_units = \"Myr\",\n function_on_xaxis = lambda x: x,\n yaxis = \"mass\",\n yaxis_normalize = False,\n show_conv = True, show_therm = True, show_semi = True, show_over = True, show_rot = False,\n core_masses = [\"He\",\"C\",\"O\"],\n yresolution = 1000,\n mass_tolerance = 0.0000001,\n radius_tolerance = 0.0000001,\n decorate_plot = True,\n show_plot = False,\n save_file = True,\n save_filename = \"Kippenhahn.png\"):\n\n self.logs_dirs = logs_dirs\n self.profile_paths = profile_paths\n self.history_paths = history_paths\n self.clean_data = clean_data\n self.extra_history_cols = extra_history_cols\n self.identifier = identifier\n self.extractor = extractor\n self.log10_on_data = log10_on_data\n self.contour_colormap = contour_colormap\n self.levels = levels\n self.log_levels = log_levels\n self.num_levels = num_levels\n self.xaxis = xaxis\n self.xaxis_divide = xaxis_divide\n self.time_units = time_units\n self.function_on_xaxis = function_on_xaxis\n self.yaxis = yaxis\n self.yaxis_normalize = yaxis_normalize\n self.show_conv = show_conv\n self.show_therm = show_therm\n self.show_semi = show_semi\n self.show_over = show_over\n self.show_rot = show_rot\n self.core_masses = core_masses\n self.yresolution = yresolution\n self.mass_tolerance = mass_tolerance\n self.radius_tolerance = radius_tolerance\n self.decorate_plot = decorate_plot\n self.show_plot = show_plot\n self.save_file = save_file\n self.save_filename = save_filename","def plot_model(model, inputs, outputs, tss=90):\n mdl = np.load(model)\n sys = ss(mdl['A'], mdl['B'], mdl['C'], mdl['D'],1)\n gain_matrix = dcgain(sys).T\n num_i = len(inputs)\n num_o = len(outputs)\n fig, axs = plt.subplots(num_i,num_o, figsize=(3*len(outputs), 2*len(inputs)), facecolor='w', edgecolor='k')\n fig.suptitle('Step responce: '+model)\n T = np.arange(tss)\n for idx_i in range(num_i):\n for idx_o in range(num_o):\n ax = axs[idx_i][idx_o]\n t,y_step = step_response(sys,T, input=idx_i, output=idx_o)\n gain = round(gain_matrix[idx_i][idx_o],4)\n ax.plot(t, y_step,color='r')\n if idx_i == 0:\n ax.set_title(outputs[idx_o], rotation='horizontal', ha='center', fontsize=10)\n if idx_o == 0:\n ax.set_ylabel(inputs[idx_i], rotation=90, fontsize=10)\n ax.grid(color='k', linestyle='--', linewidth=0.5)\n ax.tick_params(axis='x', colors='red',size=0,labelsize=4)\n ax.tick_params(axis='y', colors='red',size=0,labelsize=4)\n ax.annotate(str(gain),xy=(.72,.8),xycoords='axes fraction')\n # fig.tight_layout()\n plt.show()","def test_plot_lin(self):\n pname = os.path.join(self.datadir, 'monol_testA_E3-50_pds_fit') + \\\n HEN_FILE_EXTENSION\n cname = os.path.join(self.datadir, 'monol_test_E3-50_cpds_fit') + \\\n HEN_FILE_EXTENSION\n lname = os.path.join(self.datadir, 'monol_testA_E3-50_lc') + \\\n HEN_FILE_EXTENSION\n hen.plot.main([pname, cname, lname, '--noplot', '--xlin', '--ylin',\n '-o', 'dummy.qdp'])\n hen.plot.main([lname, '--noplot',\n '--axes', 'time', 'counts', '--xlin', '--ylin',\n '-o', 'dummy.qdp'])","def __init__(self, vals, skel, scene=None, padding=0):\r\n self.skel = skel\r\n self.padding = padding\r\n connect = skel.connection_matrix()\r\n mocap_data_show_vpython.__init__(self, vals, scene=scene, connect=connect, radius=0.4)","def add_line_SFR_obs(line,L_line,ax,plot_fit=True,**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n # --- Observations compiled in Observations.ipynb ---\n\n L_obs = np.array([])\n SFR_obs = np.array([])\n\n if p.plot: print('\\nObserved galaxies with %s:' % line)\n\n c = 'dimgrey'\n a = 0.8\n mew = 1\n\n # Kamenetzky et al. 2016\n df = pd.read_pickle('data/observations/AHIMSA_sample_lit')\n df = df[(df.sizes < 47) & (df.SFR > 1e-4) & (df[line+ '_Lsun'].values > 0)] \n try:\n if p.plot: ax.plot(np.log10(df.SFR[(df.sizes < 47) & (df.SFR > 1e-4)]),\\\n np.log10(df[line + '_Lsun'][(df.sizes < 47) & (df.SFR > 1e-4)]),'>',ms=6,fillstyle='none',mew=mew,\\\n color=c,alpha=a,label='Mixed type galaxies [Kamenetzky+16]')\n lo_err = np.array(np.log10(df[line+ '_Lsun'].values)-np.log10(df[line+ '_Lsun'].values-df['e_'+line+ '_Lsun'].values))\n up_err = np.array(np.log10(df[line+ '_Lsun'].values+df['e_'+line+ '_Lsun'].values)-np.log10(df[line+ '_Lsun'].values))\n lo_err[df[line+ '_Lsun'].values == 0] = 0\n up_err[df[line+ '_Lsun'].values == 0] = 0\n # ax.errorbar(np.log10(df.SFR),\\\n # np.log10(df[line+ '_Lsun']),\\\n # yerr=np.column_stack([lo_err,up_err]).T,\\\n # elinewidth=1,marker='>',ms=6,mew=1,fillstyle='none',\\\n # color='grey',alpha=0.8,lw=0,label='Mixed z~0 sample [Kamenetzky+16]')\n L_obs = np.append(L_obs,df[line + '_Lsun'].values)\n SFR_obs = np.append(SFR_obs,df.SFR.values)\n if p.plot: print('%i galaxies from Kamenetzky+16 ' % (len(L_obs)))\n except:\n pass\n\n # print('min SFR: ',np.min(df.SFR.values[df.sizes < 47]))\n\n # Brauher et al. 2008\n try:\n df = pd.read_pickle('data/observations/Brauher_2008')\n if p.plot: \n # lo_err = np.array(np.log10(df['L_'+line].values)-np.log10(df['L_'+line].values-df['e_'+line].values))\n # up_err = np.array(np.log10(df['L_'+line].values+df['e_'+line].values)-np.log10(df['L_'+line].values))\n # print(lo_err)\n # print(df['e_'+line].values/df['L_'+line])\n # ax.errorbar(np.log10(df.SFR),np.log10(df['L_'+line]),\\\n # yerr=np.column_stack([lo_err,up_err]).T,\\\n # elinewidth=1,marker='o',ms=7,mew=1,fillstyle='none',\\\n # color='grey',alpha=0.8,lw=0,label='MS/SB galaxies [Brauher+08]')\n ax.plot(np.log10(df.SFR),np.log10(df['L_%s' % line]),'o',fillstyle='none',ms=4,mew=mew,color=c,\\\n alpha=a,label='MS/SB galaxies [Brauher+08]')\n L_ul = np.log10(df['L_%s' % line][df['f_'+line] == -1])\n if len(L_ul) > 0:\n # ax.plot(df.SFR[df['f_'+line] == -1],L_ul,'o',zorder=0,ms=7,mew=1,color='grey',alpha=0.8)\n ax.errorbar(np.log10(df.SFR[df['f_'+line] == -1]),L_ul,capsize=3,color=c,alpha=a,elinewidth=1,\\\n uplims=np.ones(len(L_ul)),\\\n yerr=0.3,lw=0)\n if p.plot: print('%i galaxies from Brauher+08 ' % (len(df)))\n L =df['L_%s' % line].values\n SFR =df['SFR'].values\n L = L[SFR > 0]\n SFR = SFR[SFR > 0]\n L_obs = np.append(L_obs,L)\n SFR_obs = np.append(SFR_obs,SFR)\n # print('min SFR: ',np.min(df.SFR))\n except:\n pass\n\n if p.select != '_MS':\n # Cormier et al. 2015\n try:\n df = pd.read_pickle('data/observations/DGS_Cormier_2015')\n if p.plot: \n # try: \n # lo_err = np.array(np.log10(df['L_'+line].values)-np.log10(df['L_'+line].values-df['e_'+line].values))\n # up_err = np.array(np.log10(df['L_'+line].values+df['e_'+line].values)-np.log10(df['L_'+line].values))\n # ax.errorbar(df.SFR,np.log10(df['L_'+line]),\\\n # yerr=np.column_stack([lo_err,up_err]).T,\\\n # elinewidth=1,marker='x',ms=7,mew=mew,\\\n # color=c,alpha=a,lw=0,label='Dwarf galaxies [Cormier+15]')\n # except:\n ax.plot(df.SFR,np.log10(df['L_%s' % line]),'x',zorder=0,ms=7,mew=mew,color=c,alpha=a,\\\n label='Dwarf galaxies [Cormier+15]')\n L_ul = np.log10(-1.*df['L_'+line][df['L_'+line] < 0])\n if len(L_ul) > 0:\n ax.plot(df.SFR[df['L_'+line] < 0],L_ul,'x',zorder=0,ms=7,mew=mew,color=c,alpha=a)\n ax.errorbar(df.SFR[df['L_'+line] < 0],L_ul,capsize=3,color=c,alpha=a,elinewidth=1,\\\n uplims=np.ones(len(L_ul)),\\\n yerr=0.3,lw=0)\n # np.log10(-1.*L_ul - 10.**(np.log10(-1.*L_ul)-0.3))\n if p.plot: print('%i galaxies from Cormier+15 ' % (len(df)))\n L_obs = np.append(L_obs,df['L_%s' % line].values)\n SFR_obs = np.append(SFR_obs,10.**df.SFR.values)\n except:\n pass\n\n # Schruba et al. 2012\n #try:\n if (line == 'CO(1-0)') | (line == 'CO(2-1)'):\n df = pd.read_pickle('data/observations/Schruba_2012')\n if p.plot: \n if line == 'CO(1-0)': label = 'Mixed type galaxies [Schruba+12]'\n if line == 'CO(2-1)': label = 'Dwarf galaxies [Schruba+12]'\n f_ul = df['f_%s' % line].values\n L = df['L_%s' % line].values\n SFR = df['SFR'].values\n L_obs = np.append(L_obs,L[L > 0])\n SFR_obs = np.append(SFR_obs,SFR[L > 0])\n Z = df['Z'].values\n if line == 'CO(2-1)': \n SFR = SFR[L>0]\n f_ul = f_ul[L>0]\n Z = Z[L>0]\n L = L[L>0]\n print('Schruba min max Z: ',Z.min(),Z.max())\n M_H2 = 1.8e9 * SFR # from S12 paper\n area = np.array([1.33,1.79,1.75,7.74,11.47,12.37,26.69,83.85,12.23,39.40,19.21,7.78,14.75,59.54,31.19,39.19]) # kpc2\n Sigma_M_H2 = M_H2 / (area*1000*1000)\n if p.select == 'Zsfr': \n ax.scatter(np.log10(SFR[L > 0]),np.log10(L[L > 0]),marker='*',zorder=0,facecolors='none',s=30,\\\n linewidth=mew,c=np.log10(Z),alpha=a,label=label,vmin=p.vmin,vmax=p.vmax)\n else:\n ax.scatter(np.log10(SFR[L > 0]),np.log10(L[L > 0]),marker='*',zorder=0,facecolors='none',s=30,\\\n linewidth=mew,c=np.log10(Sigma_M_H2),alpha=a,label=label,vmin=p.vmin,vmax=p.vmax)\n if line == 'CO(1-0)': \n ax.plot(np.log10(SFR[L > 0]),np.log10(L[L > 0]),'*',zorder=0,fillstyle='none',ms=7,mew=mew,color=c,alpha=a,\\\n label=label)\n if len(f_ul) > 0:\n # ax.plot(np.log10(SFR[f_ul == 1]),np.log10(L[f_ul == 1]),'*',zorder=0,fillstyle='none',ms=7,mew=mew,color=c,alpha=a)\n ax.errorbar(np.log10(SFR[f_ul == 1]),np.log10(L[f_ul == 1]),capsize=3,fillstyle='none',color=c,alpha=a,elinewidth=1,\\\n uplims=np.ones(len(L[f_ul == 1])),\\\n yerr=0.3,lw=0)\n if p.plot: print('%i galaxies from Schruba+12 ' % (len(df)))\n #except:\n # pass\n\n # Accurso et al. 2017\n try:\n df = pd.read_pickle('data/observations/xCOLD_GASS_Accurso_2017')\n df = df.loc[np.argwhere(df['L_CO(1-0)'].values > 0).flatten()]\n if p.plot: ax.plot(np.log10(df['SFR']),df['L_%s' % line], 'd', zorder=0,ms=7,fillstyle='none',mew=mew,color=c,alpha=a,label='COLD GASS [Accurso+17]') #c=np.log10(A17['Z']), \n L_obs = np.append(L_obs,10.**df['L_%s' % line].values)\n if p.plot: print('%i galaxies from Accurso+17 ' % (len(df)))\n SFR_obs = np.append(SFR_obs,df.SFR.values)\n except:\n pass\n\n # Vanzi et al. 2009\n if line == 'CO(3-2)':\n df = pd.read_pickle('data/observations/Vanzi_2009')\n df = df.loc[np.argwhere(df['L_CO(3-2)'].values > 0).flatten()]\n if p.plot: ax.plot(np.log10(df['SFR']),np.log10(df['L_%s' % line]), 'D', zorder=0,ms=7,fillstyle='none',mew=mew,\\\n color=c,alpha=a,label='Dwarf galaxies [Vanzi+09]') #c=np.log10(A17['Z']), \n L_obs = np.append(L_obs,df['L_%s' % line].values)\n if p.plot: print('%i galaxies from Vanzi+09 ' % (len(df)))\n SFR_obs = np.append(SFR_obs,df.SFR.values)\n # except:\n # pass\n\n\n # Diaz-Santos et al. 2013\n try:\n df = pd.read_pickle('data/observations/Diaz-Santos_2013')\n if p.plot: ax.plot(np.log10(df.SFR),np.log10(df['L_%s' % line]),'^',ms=6,zorder=0,fillstyle='none',mew=mew,color=c,alpha=a,label='LIRGs [Diaz-Santos+13]')\n if p.plot: print('%i galaxies from Diaz-Santos+17 ' % (len(df)))\n L_obs = np.append(L_obs,df['L_%s' % line].values)\n SFR_obs = np.append(SFR_obs,df.SFR.values)\n # print('min SFR: ',np.min(df.SFR))\n except:\n pass\n # Farrah et al. 2013\n # try:\n # df = pd.read_pickle('data/observations/Farrah_2013')\n # if p.plot: ax.plot(df.SFR,df['L_%s' % line],'<',fillstyle='none',mew=1,color='grey',alpha=0.8,label='Farrah+13 (ULIRGs)')\n # if p.plot: print('%i galaxies from Farrah+13 ' % (len(df)))\n # L_obs = np.append(L_obs,df['L_%s' % line].values)\n # SFR_obs = np.append(SFR_obs,df.SFR.values)\n # except:\n # pass\n # Zhao et al. 2016\n try:\n df = pd.read_pickle('data/observations/Zhao_2016')\n if p.plot: ax.plot(np.log10(df.SFR),np.log10(df['L_%s' % line]),'<',ms=6,fillstyle='none',mew=mew,color=c,alpha=a,label='GOALS (U)LIRGs [Zhao+16]')\n if p.plot: print('%i galaxies from Zhao+16 ' % (len(df)))\n L_obs = np.append(L_obs,df['L_%s' % line].values)\n SFR_obs = np.append(SFR_obs,df.SFR.values)\n # print('min SFR: ',np.min(df.SFR))\n except:\n pass\n\n if line in ['[CII]158','[OI]63','[OIII]88']:\n # De Looze 2014 relation\n if np.min(L_line) == 0 : L_line[L_line == 0] = 1e-30\n if p.plot: print(np.min(np.log10(L_line)),np.max(np.log10(L_line)))\n logL_delooze = np.arange(np.min(np.log10(L_line)) - 3,np.max(np.log10(L_line)) + 3)\n\n if line == '[CII]158':\n logSFR_delooze_DGS = -5.73 + 0.8 * logL_delooze\n logSFR_delooze_SBG = -7.06 + 1.0 * logL_delooze\n\n if line == '[OI]63':\n logSFR_delooze_DGS = -6.23 + 0.91 * logL_delooze\n logSFR_delooze_SBG = -6.05 + 0.89 * logL_delooze\n\n if line == '[OIII]88':\n logSFR_delooze_DGS = -6.71 + 0.92 * logL_delooze\n logSFR_delooze_SBG = -3.89 + 0.69 * logL_delooze\n\n if p.plot: ax.plot(logSFR_delooze_DGS,logL_delooze,'--',color='grey',alpha=0.7,\\\n label='Local dwarf galaxies [de Looze+ 2014]')\n if p.plot: ax.plot(logSFR_delooze_SBG,logL_delooze,':',color='grey',alpha=0.7,\\\n label='Local SB galaxies [de Looze+ 2014]')\n # print(SFR_obs)\n logSFR = np.arange(np.min(np.log10(SFR_obs[SFR_obs > 0])) - 3,np.max(np.log10(SFR_obs[SFR_obs > 0])) + 3)\n # fit = np.polyfit(np.log10(SFR_obs[(L_obs > 0) & (SFR_obs > 0)]),\\\n # np.log10(L_obs[(L_obs > 0) & (SFR_obs > 0)]),1)\n # pfit = np.poly1d(fit)\n # L_fit = 10.**pfit(logSFR)\n\n # Make log-linear fit to SFR-binned luminosities\n SFRs = SFR_obs[(L_obs > 0) & (SFR_obs > 0)]\n Ls = L_obs[(L_obs > 0) & (SFR_obs > 0)]\n SFR_axis = np.linspace(np.log10(SFRs.min()),np.log10(SFRs.max()),20)\n SFR_bins = SFR_axis[0:-1] + (SFR_axis[1]-SFR_axis[0])/2.\n Ls_binned = np.zeros(len(SFR_axis)-1)\n for i in range(len(Ls_binned)):\n Ls1 = Ls[(SFRs >= 10.**SFR_axis[i]) & (SFRs <= 10.**SFR_axis[i+1])]\n Ls_binned[i] = np.mean(np.log10(Ls1))\n SFR_bins = SFR_bins[Ls_binned > 0]\n Ls_binned = Ls_binned[Ls_binned > 0]\n # ax.plot(10.**SFR_bins,10.**Ls_binned,'x',color='orange',mew=3)\n fit = LinearRegression().fit(SFR_bins.reshape(-1, 1),\\\n Ls_binned.reshape(-1, 1))\n L_fit = 10.**fit.predict(logSFR.reshape(-1, 1))\n if p.plot & plot_fit: ax.plot(logSFR,np.log10(L_fit),'--k',lw=1.5,zorder=0)\n\n # print(line)\n # print(np.log10(L_obs[(L_obs > 0) & (SFR_obs > 0)]))\n # print(fit.predict(SFR_obs[(L_obs > 0) & (SFR_obs > 0)].reshape(-1, 1)).flatten())\n\n std = np.std(np.log10(L_obs[(L_obs > 0) & (SFR_obs > 0)]) - \\\n fit.predict(np.log10(SFR_obs[(L_obs > 0) & (SFR_obs > 0)]).reshape(-1, 1)).flatten())\n\n\n # Read literature data from AHIMSA project\n # obsdf = pd.read_pickle(p.d_data+'observations/sample_lit')\n # print(obsdf.keys())\n # print(L_obs)\n # print(SFR_obs)\n\n if not p.plot: \n return(L_obs.flatten(),SFR_obs.flatten(),fit,std)","def dline_Mgas(**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n GR = glo.global_results(sim_run=p.sim_run,nGal=p.nGal)\n \n marker = 'o'\n if p.sim_run == p.sim_runs[0]: marker = '^'\n\n L_line = getattr(GR,'L_'+p.line+'_sun')#[380:400]#[0:100]\n SFR = getattr(GR,'SFR')#[380:400]#[0:100]\n M_star = getattr(GR,'M_star')#[380:400]#[0:100]\n Zsfr = getattr(GR,'Zsfr')#[380:400]#[0:100]\n R_gas = getattr(GR,'R2_gas')#[380:400]#[0:100]\n M_H2 = getattr(GR,'M_H2_R2_gas')#[380:400]#[0:100]\n M_gas = getattr(GR,'M_gas')#[380:400]#[0:100]\n\n SFR = SFR[L_line > 0]\n M_star = M_star[L_line > 0]\n Zsfr = Zsfr[L_line > 0]\n R_gas = R_gas[L_line > 0]\n M_H2 = M_H2[L_line > 0]\n M_gas = M_gas[L_line > 0]\n L_line = L_line[L_line > 0]\n print('%i data points ' % (len(L_line)))\n\n if p.add:\n ax = p.ax\n else:\n fig,ax = plt.subplots(figsize=(8,6))\n\n # Distance from observed relation\n L_obs,SFR_obs,fit,std = add_line_SFR_obs(p.line,[1e6,1e6],ax,plot=False,select=p.select)\n ldL_line = np.log10(L_line) - fit.predict(np.log10(SFR.reshape(-1, 1))).flatten()\n\n labs = {'_M10':'Mach=10 power-law',\\\n '_arepoPDF_ext':'AREPO parametric PDF with extinction',\\\n '_arepoPDF':'SIGAME v3',\\\n '_arepoPDF_CMZ':'SIGAME v3',\\\n '_arepoPDF_M51':'SIGAME v3'}\n lab = labs[p.table_ext]\n\n\n ax.text(0.05,0.9,p.line,transform=ax.transAxes,fontsize=13)\n ax.set_xlabel(getlabel('M_gas'))\n ax.set_ylabel('log L - log L$_{obs}$(SFR)')\n if not p.xlim: p.xlim = np.array([8,11])\n if not p.ylim: \n p.ylim = [np.median(ldL_line) - 4,np.median(ldL_line) + 3]\n ax.set_xlim(p.xlim)\n ax.set_ylim(p.ylim)\n ax.plot([0,0],ax.get_ylim(),'--k',lw=1)\n ax.plot(ax.get_xlim(),[0,0],'--k',lw=1)\n\n if p.select == 'Sigma_M_H2':\n Sigma_M_H2 = M_H2/(np.pi*R_gas**2)/1e6 # per pc^-2\n m = ax.scatter(np.log10(M_gas)[np.argsort(Sigma_M_H2)],ldL_line[np.argsort(Sigma_M_H2)],marker=marker,s=14,\\\n c=np.log10(Sigma_M_H2[np.argsort(Sigma_M_H2)]),vmin=-2.5,vmax=2.2,label=lab,alpha=0.5,zorder=10)\n if p.cb:\n cbar = plt.colorbar(m,ax=ax)\n cbar.set_label(label=r'log $\\Sigma_{H2}$ [M$_{\\odot}$/pc$^2$]',size=15)\n\n print(np.log10(M_gas.min()),np.log10(M_gas.max()))","def preprocess_data(self, lidar_data):\n return lidar_data","def movie(l, zlim=0.7, zstep=0.01, nside=64, dump_plot_dir=None, nsn_func=None,\n bands=['g', 'r', 'i', 'z'],\n exclude_bands=['u', 'y'],\n vmax_nsn=None,\n min_cadence=0.5,\n lc_template=None,\n salt2=None):\n \n m = Metrics(l, model_filename=salt2, lc_template=lc_template, nside=nside)\n nsn_tot = np.zeros(m.npix)\n nsn_inst = np.zeros(m.npix)\n cadence_tot = np.zeros(m.npix)\n cadence_nhits = np.zeros(m.npix) \n zmax_tot = np.zeros(m.npix)\n zmax_nhits = np.zeros(m.npix)\n tmp_map = np.zeros(m.npix)\n\n # median values \n nsn_tot_history = []\n nsn_inst_history = []\n median_cadence_inst_history = []\n zmax_inst_history = []\n \n # p = Plotter()\n # for block in pxlog:\n # for m,acc in metrics:\n # r = m(block)\n # a.accumulate(r)\n # if a.do_plot:\n # p.plot_maps(a)\n \n \n \n # loop on the survey mjd -- by steps of 1 day\n for mjd in np.arange(m.mjd.min(), m.mjd.max()+1):\n zmax = np.zeros(m.npix)\n nsn = np.zeros(m.npix)\n \n # check that the sampling is ok at z=0\n s,u = m.select_window(mjd, z=0., bands=bands, exclude_bands=exclude_bands)\n c = m.cadence(u, z=0.)\n first, last = m.first_last_visits(mjd, u, z=0.)\n c[c<min_cadence] = 0.\n c[first==0.] = 0.\n c[last==0.] = 0.\n c0_ok = c>0.\n \n # loop over the redshift range, and check the resolution in\n # color as a function of redshift. Store the highest redshift\n # that passes the cuts \n for z in np.arange(0.1, zlim+zstep, zstep)[::-1]:\n # select the window \n s,u = m.select_window(mjd, z=z, exclude_bands=exclude_bands)\n \n # average cadence\n # note: explore median dt\n cz = m.cadence(u, z=z)\n \n # observations before -15 and after +30 ? \n firstz, lastz = m.first_last_visits(mjd, u, z=z)\n # cut in cadence \n cz[(cz<min_cadence)] = 0.\n \n # cut on the last visit\n cz[(firstz==0.)] = 0.\n cz[(lastz==0)] = 0.\n cz *= c0_ok\n\n # cut on sigma amplitude\n if np.abs(z-0.3) <= 0.01:\n snr_g = m.amplitude_snr(mjd, instrument_name + '::g', z, s)\n snr_r = m.amplitude_snr(mjd, instrument_name + '::r', z, s)\n snr_i = m.amplitude_snr(mjd, instrument_name + '::i', z, s)\n snr_z = m.amplitude_snr(mjd, instrument_name + '::z', z, s) \n if z <= 0.3:\n snr_ok = m.cut_on_amplitude_snr(mjd, z, s, \n snr_cuts = {instrument_name + '::g': 30., \n instrument_name + '::r': 40., \n instrument_name + '::i': 30., \n instrument_name + '::z': 20.})\n else:\n snr_ok = m.cut_on_amplitude_snr(mjd, z, s, \n snr_cuts = {instrument_name + '::r': 40., \n instrument_name + '::i': 30., \n instrument_name + '::z': 20.})\n \n # update max-z map \n zmax[(cz>0) & (snr_ok>0.) & (zmax==0.)] = z\n c[c==0] = cz[c==0]\n # update the number of supernovae for that day \n # we update (1) a map that contains the total\n # number of SNe and (2) a NTuple that contains\n # mjd, nsn, zmax\n if nsn_func is not None:\n nsn_inst[:] = 0.\n nsn_inst[zmax>0.] = nsn_func(zmax[zmax>0])\n nsn_tot[zmax>0.] += nsn_inst[zmax>0.]\n else:\n logging.warning('no function to compute number of SNe')\n\n # update the cumulative maps\n cadence_tot += c\n cadence_nhits[c>0] += 1\n zmax_tot += zmax\n zmax_nhits[zmax>0] += 1\n \n # m.plot_map(first, fig=1, vmin=0., vmax=1.25, sub=221, cbar=False)\n # m.plot_map(last, fig=1, vmin=0., vmax=1.25, sub=222, cbar=False)\n fig = plt.figure(1, figsize=(15.,7.5))\n human_date = DateTimeFromMJD(mjd).strftime('%Y-%m-%d')\n fig.suptitle('[%s mjd=%6.0f]' % (human_date, mjd))\n m.plot_map(nsn_tot, fig=1, sub=231, vmin=0., vmax=vmax_nsn, cbar=True, title='$N_{SNe}: %6.0f$ (tot)' % nsn_tot.sum())\n nsn_tot_history.append((mjd,nsn_tot.sum()))\n tmp_map[:] = hp.UNSEEN ; idx = zmax_nhits>0\n tmp_map[idx] = zmax_tot[idx] / zmax_nhits[idx]\n med = np.median(tmp_map[tmp_map>0])\n m.plot_map(tmp_map, fig=1, sub=232, vmin=0., vmax=0.5, cbar=True, title='$z_{max}$ (avg) [%4.2f]' % (med if ~np.isnan(med) else 0))\n tmp_map[:] = hp.UNSEEN ; idx = cadence_nhits>0\n tmp_map[idx] = cadence_tot[idx] / cadence_nhits[idx]\n med = np.median(tmp_map[tmp_map>0])\n m.plot_map(tmp_map, fig=1, sub=233, vmin=0., vmax=1., cbar=True, title='cadence [day$^{-1}$] (avg) [%4.2f]' % (med if ~np.isnan(med) else 0))\n \n m.plot_map(nsn_inst, fig=1, sub=234, vmin=0., vmax=0.015, cbar=True, title='$N_{SNe}: %4.0f$' % nsn_inst.sum())\n nsn_inst_history.append((mjd,nsn_inst.sum()))\n med = np.median(zmax[zmax>0])\n m.plot_map(zmax, fig=1, vmin=0., vmax=0.5, sub=235, cbar=True, title='$z_{max}$ [%4.2f]' % (med if ~np.isnan(med) else 0))\n zmax_inst_history.append((mjd,(med if ~np.isnan(med) else 0)))\n med = np.median(c[c>0])\n m.plot_cadence(c, fig=1, dump_plot_dir=dump_plot_dir, \n vmin=0.,\n vmax=1.,\n min_cadence=min_cadence,\n sub=236,\n title='cadence [day$^{-1}$] [%4.2f]' % (med if ~np.isnan(med) else 0.),\n cbar=True)\n median_cadence_inst_history.append((mjd,(med if ~np.isnan(med) else 0.)))\n\n # SNR debug plots \n fig = plt.figure(2)\n fig.suptitle('[%s mjd=%6.0f]' % (human_date, mjd))\n m.plot_map(snr_g, fig=2, sub=221, vmin=0., vmax=30., cbar=True, title='SNR[g]')\n m.plot_map(snr_r, fig=2, sub=222, vmin=0., vmax=40., cbar=True, title='SNR[r]')\n m.plot_map(snr_i, fig=2, sub=223, vmin=0., vmax=30., cbar=True, title='SNR[i]') \n m.plot_map(snr_z, fig=2, sub=224, vmin=0., vmax=20., cbar=True, title='SNR[z]', dump_plot_dir=dump_plot_dir, prefix='snr')\n\n # cadence debug plots\n\n m.fig_odometer += 1\n\n\n # dump history\n nsn_tot_history = np.rec.fromrecords(nsn_tot_history, names=['mjd', 'val'])\n nsn_inst_history = np.rec.fromrecords(nsn_inst_history, names=['mjd', 'val'])\n zmax_inst_history = np.rec.fromrecords(zmax_inst_history, names=['mjd', 'val'])\n median_cadence_inst_history = np.rec.fromrecords(median_cadence_inst_history, names=['mjd', 'val'])\n np.save(dump_plot_dir + os.sep + 'nsn_tot_history.npy', nsn_tot_history)\n np.save(dump_plot_dir + os.sep + 'nsn_inst_history.npy', nsn_inst_history)\n np.save(dump_plot_dir + os.sep + 'zmax_inst_history.npy', zmax_inst_history)\n np.save(dump_plot_dir + os.sep + 'median_cadence_inst_history.npy', median_cadence_inst_history)","def plot_seaice_predict_components(anomlous = False, temporal_resolution = 'monthly', spatial_resolution = 1, detrend = False, imagefolder = 'images/timeseries/prediction/',seaice_source='nsidc'):\n output_folder = 'processed_data/SIC/'\n if seaice_source == 'ecmwf':\n output_folder = 'processed_data/ERA5/SIC/'\n\n if anomlous:\n temp_decomp = 'anomalous'\n else:\n temp_decomp = 'raw'\n\n\n title = temp_decomp.capitalize() + ' '\n\n if detrend:\n dt = 'detrended'\n title += dt + ' '\n else:\n dt = 'raw'\n\n title += temporal_resolution\n title += ' SIE prediction'\n\n\n# Loading Seaice Trends\n seaicename = f'{temp_decomp}_{temporal_resolution}_{spatial_resolution}_{dt}'\n seaice = xr.open_dataset(output_folder + seaicename +'.nc')\n area = xr.open_dataset('data/area_files/processed_nsidc.nc').area\n seaice = seaice\n\n\n# Index contributions\n filename = f'processed_data/regressions/spatial_multiple/regr_{temp_decomp}_{temporal_resolution}_{dt}_{spatial_resolution}'\n dataset = xr.open_dataset(filename + '.nc')\n indicies = np.array([i for i in dataset])\n values = np.array([dataset[i].values for i in dataset])\n index_data = {}\n for indexname in indicies[:-1]:\n filename = f'{indexname}_{temp_decomp}_{temporal_resolution}_{dt}'\n index_data[indexname] = xr.open_dataset('processed_data/INDICIES/' + filename +'.nc')[indexname]\n index_data[indexname] = (index_data[indexname] - index_data[indexname].mean()) \n index_data[indexname] = index_data[indexname] / index_data[indexname].std()\n\n times = list(set.intersection(set(seaice.time.values), *(set(index_data[i].time.values)for i in indicies[:-1])))\n\n prediction = seaice.copy() * 0\n predictions = []\n for indexname in indicies:\n if indexname in index_data.keys():\n prediction += index_data[indexname].sel(time=times).sortby('time') * dataset[indexname]\n predictions += [index_data[indexname].sel(time=times).sortby('time') * dataset[indexname]]\n else:\n prediction += dataset[indexname]\n predictions += [dataset[indexname]]\n\n\n seaice = seaice.sortby('time').sel(time=times).sortby('time')\n prediction = prediction.sortby('time').sel(time=times).sortby('time')\n\n fig = plt.figure()\n ax = fig.add_subplot(111)\n ax.axhline(y=0, alpha = 0.5)\n data = (prediction[seaicename]*area/250).sum(dim = ('x', 'y'))\n data_m, data_b, data_r_value, data_p_value, data_std_err = scipy.stats.linregress(data.time.values.astype(float), data)\n plt.plot(data.time, data_m * data.time.values.astype(float) + data_b, color = '#EA1B10', alpha = 0.5)\n data = (seaice[seaicename]*area/250).sum(dim = ('x', 'y'))\n data_m, data_b, data_r_value, data_p_value, data_std_err = scipy.stats.linregress(data.time.values.astype(float), data)\n plt.plot(data.time, data_m * data.time.values.astype(float) + data_b, color = '#177E89', alpha = 0.5)\n\n\n ln1 = ax.plot(seaice.time, (seaice[seaicename]*area/250).sum(dim = ('x', 'y')), label = 'SIE', alpha = 0.5)\n ln2 = ax.plot(seaice.time, (prediction[seaicename]*area/250).sum(dim = ('x', 'y')), label = 'Prediction', alpha = 0.5)\n\n lines = ln1 + ln2\n i = 0\n for indexname in indicies[:-1]:\n predict = index_data[indexname] * dataset[indexname]\n lines += ax.plot(predict.time, (predict*area/250).sum(dim = ('x', 'y')), '--', label = f'{indexname}', linewidth=1)\n i += 1\n\n labels = [line.get_label() for line in lines]\n plt.legend(lines,labels,bbox_to_anchor=(0.99, -0.15), ncol = 3, loc = 'upper right')\n plt.title(title)\n\n plt.savefig(imagefolder + seaicename + '_components.pdf')\n plt.show()\n\n fig = plt.figure()\n ax = fig.add_subplot(111)\n ax.axhline(y=0, alpha = 0.5)\n data = (prediction[seaicename]*area/250).sum(dim = ('x', 'y'))\n data_m, data_b, data_r_value, data_p_value, data_std_err = scipy.stats.linregress(data.time.values.astype(float), data)\n # plt.plot(data.time, data_m * data.time.values.astype(float) + data_b, color = '#EA1B10', alpha = 0.5)\n data = (seaice[seaicename]*area/250).sum(dim = ('x', 'y'))\n data_m, data_b, data_r_value, data_p_value, data_std_err = scipy.stats.linregress(data.time.values.astype(float), data)\n # plt.plot(data.time, data_m * data.time.values.astype(float) + data_b, color = '#177E89', alpha = 0.5)\n\n\n norm = (seaice[seaicename]*area/250).sum(dim = ('x', 'y')) / 100\n ln1 = ax.plot(seaice.time, (seaice[seaicename]*area/250).sum(dim = ('x', 'y')).sortby('time')/norm, label = 'SIE', alpha = 0.5)\n ln2 = ax.plot(seaice.time, (prediction[seaicename]*area/250).sum(dim = ('x', 'y')).sortby('time')/norm, label = 'Prediction', alpha = 0.5)\n\n lines = ln1 + ln2\n i = 0\n for indexname in indicies[:-1]:\n predict = index_data[indexname].sel(time=times).sortby('time') * dataset[indexname]\n lines += ax.plot(predict.time, (predict*area/250).sum(dim = ('x', 'y'))/norm, '--', label = f'{indexname}', linewidth=1)\n i += 1\n\n labels = [line.get_label() for line in lines]\n plt.legend(lines,labels,bbox_to_anchor=(0.99, -0.15), ncol = 3, loc = 'upper right')\n plt.title(title)\n\n plt.savefig(imagefolder + seaicename + '_components_normalised.pdf')\n plt.show()","def decoding(file_path, id2spo, logits_all, seq_len_all,\n tok_to_orig_start_index_all, tok_to_orig_end_index_all):\n example_all = []\n with open(file_path, \"r\", encoding=\"utf-8\") as fp:\n for line in fp:\n example_all.append(json.loads(line))\n\n formatted_outputs = []\n for (i, (example, logits, seq_len, tok_to_orig_start_index, tok_to_orig_end_index)) in \\\n enumerate(zip(example_all, logits_all, seq_len_all, tok_to_orig_start_index_all, tok_to_orig_end_index_all)):\n\n logits = logits[1:seq_len +\n 1] # slice between [CLS] and [SEP] to get valid logits\n logits[logits >= 0.5] = 1\n logits[logits < 0.5] = 0\n tok_to_orig_start_index = tok_to_orig_start_index[1:seq_len + 1]\n tok_to_orig_end_index = tok_to_orig_end_index[1:seq_len + 1]\n predictions = []\n for token in logits:\n predictions.append(np.argwhere(token == 1).tolist())\n\n # format predictions into example-style output\n formatted_instance = {}\n text_raw = example['text']\n complex_relation_label = [8, 10, 26, 32, 46]\n complex_relation_affi_label = [9, 11, 27, 28, 29, 33, 47]\n\n # flatten predictions then retrival all valid subject id\n flatten_predictions = []\n for layer_1 in predictions:\n for layer_2 in layer_1:\n flatten_predictions.append(layer_2[0])\n subject_id_list = []\n for cls_label in list(set(flatten_predictions)):\n if 1 < cls_label <= 56 and (cls_label + 55) in flatten_predictions:\n subject_id_list.append(cls_label)\n subject_id_list = list(set(subject_id_list))\n\n # fetch all valid spo by subject id\n spo_list = []\n for id_ in subject_id_list:\n if id_ in complex_relation_affi_label:\n continue # do this in the next \"else\" branch\n if id_ not in complex_relation_label:\n subjects = find_entity(text_raw, id_, predictions,\n tok_to_orig_start_index,\n tok_to_orig_end_index)\n objects = find_entity(text_raw, id_ + 55, predictions,\n tok_to_orig_start_index,\n tok_to_orig_end_index)\n for subject_ in subjects:\n for object_ in objects:\n spo_list.append({\n \"predicate\": id2spo['predicate'][id_],\n \"object_type\": {\n '@value': id2spo['object_type'][id_]\n },\n 'subject_type': id2spo['subject_type'][id_],\n \"object\": {\n '@value': object_\n },\n \"subject\": subject_\n })\n else:\n # traverse all complex relation and look through their corresponding affiliated objects\n subjects = find_entity(text_raw, id_, predictions,\n tok_to_orig_start_index,\n tok_to_orig_end_index)\n objects = find_entity(text_raw, id_ + 55, predictions,\n tok_to_orig_start_index,\n tok_to_orig_end_index)\n for subject_ in subjects:\n for object_ in objects:\n object_dict = {'@value': object_}\n object_type_dict = {\n '@value': id2spo['object_type'][id_].split('_')[0]\n }\n if id_ in [8, 10, 32, 46\n ] and id_ + 1 in subject_id_list:\n id_affi = id_ + 1\n object_dict[id2spo['object_type'][id_affi].split(\n '_')[1]] = find_entity(text_raw, id_affi + 55,\n predictions,\n tok_to_orig_start_index,\n tok_to_orig_end_index)[0]\n object_type_dict[id2spo['object_type'][\n id_affi].split('_')[1]] = id2spo['object_type'][\n id_affi].split('_')[0]\n elif id_ == 26:\n for id_affi in [27, 28, 29]:\n if id_affi in subject_id_list:\n object_dict[id2spo['object_type'][id_affi].split('_')[1]] = \\\n find_entity(text_raw, id_affi + 55, predictions, tok_to_orig_start_index, tok_to_orig_end_index)[0]\n object_type_dict[id2spo['object_type'][id_affi].split('_')[1]] = \\\n id2spo['object_type'][id_affi].split('_')[0]\n spo_list.append({\n \"predicate\": id2spo['predicate'][id_],\n \"object_type\": object_type_dict,\n \"subject_type\": id2spo['subject_type'][id_],\n \"object\": object_dict,\n \"subject\": subject_\n })\n\n formatted_instance['text'] = example['text']\n formatted_instance['spo_list'] = spo_list\n formatted_outputs.append(formatted_instance)\n return formatted_outputs","def __init__(self, vals, model, data_visualize, latent_axes=None, sense_axes=None, latent_index=[0,1]):\r\n if vals == None:\r\n vals = model.X[0]\r\n\r\n matplotlib_show.__init__(self, vals, axes=latent_axes)\r\n\r\n if isinstance(latent_axes,mpl.axes.Axes):\r\n self.cid = latent_axes.figure.canvas.mpl_connect('button_press_event', self.on_click)\r\n self.cid = latent_axes.figure.canvas.mpl_connect('motion_notify_event', self.on_move)\r\n self.cid = latent_axes.figure.canvas.mpl_connect('axes_leave_event', self.on_leave)\r\n self.cid = latent_axes.figure.canvas.mpl_connect('axes_enter_event', self.on_enter)\r\n else:\r\n self.cid = latent_axes[0].figure.canvas.mpl_connect('button_press_event', self.on_click)\r\n self.cid = latent_axes[0].figure.canvas.mpl_connect('motion_notify_event', self.on_move)\r\n self.cid = latent_axes[0].figure.canvas.mpl_connect('axes_leave_event', self.on_leave)\r\n self.cid = latent_axes[0].figure.canvas.mpl_connect('axes_enter_event', self.on_enter)\r\n\r\n self.data_visualize = data_visualize\r\n self.model = model\r\n self.latent_axes = latent_axes\r\n self.sense_axes = sense_axes\r\n self.called = False\r\n self.move_on = False\r\n self.latent_index = latent_index\r\n self.latent_dim = model.input_dim\r\n\r\n # The red cross which shows current latent point.\r\n self.latent_values = vals\r\n self.latent_handle = self.latent_axes.plot([0],[0],'rx',mew=2)[0]\r\n self.modify(vals)\r\n self.show_sensitivities()","def show_predictions(request):\n route_tag = request.GET['RT']\n direction_tag = request.GET['DT']\n stop_tag = request.GET['ST']\n\n pred = get_predictions('sf-muni', route_tag, direction_tag, stop_tag)\n\n return HttpResponse(json.dumps(pred), content_type='application/json')","def test_lpp():\n \n tce_filename = \"tce0001234567_dvt.fits\"\n \n #Populate the tce class by reading in a file\n #At this point a phases array, \n #and (int) transit_number would get populated.\n \n tce = vet.create_tce(file = tce_filename, ext = 1)\n \n #This populates the LPP metric fields in this class\n #It also populates where the plotting data is stored\n #This function relies on inputs from a precomputed model stored\n #in something called mapInfo. In theory if someone trains up another \n #model we could input it here.\n tce.run_lpp(mapInfo = None)\n \n norm_TLpp = tce.lpp.norm\n raw_TLpp = tce.lpp.raw\n binned_lpp_transit = tce.lpp.binned_transit\n \n plot_out = tce.lpp.plot(filename=\"lpp_plot.png\")\n \n assert norm_TLpp > 0\n assert norm_TLpp < 10\n assert len(binned_lpp_transit) > 50","def linedata():\n get_values = request.args\n pc = get_values.get('pc') is not None # Per Capita\n gr = get_values.get('gr') is not None # Growth Rate\n place_args, _ = get_place_args(get_values)\n plot_data, _ = datachart_handler.get_plot_data(place_args, pc, gr)\n return json.dumps(plot_data)","def plot_interaction_map(model, name, matrix, output_name, first_variable, second_variable, x_coord, y_coord, output_path): \n import matplotlib\n import matplotlib.cm as cm\n import matplotlib.pyplot as plt\n\n font = {'size' : 14}\n\n matplotlib.rc('font', **font)\n fig = plt.figure(figsize=(5,5))\n ax = plt.subplot()\n\n maxValue = np.max(np.abs(matrix))\n img = ax.imshow((matrix), cmap = cm.bwr, origin='lower', vmin = -min(maxValue, 6), vmax = min(maxValue, 6), interpolation='spline16')\n\n first_variable = '{}'.format(first_variable)\n second_variable = '{}'.format(second_variable)\n ax.set_ylabel(r'$x_i$ = ' + first_variable)\n ax.set_xlabel(r'$y_i$ = ' + second_variable)\n ax.axes.set_xticks([0, 50, 99])\n ax.axes.set_yticks([0, 50, 99])\n xticks = np.linspace(np.array(model.feature_limits[first_variable]).min(), np.array(model.feature_limits[first_variable]).max(), 3)\n yticks = np.linspace(np.array(model.feature_limits[second_variable]).min(), np.array(model.feature_limits[second_variable]).max(), 3)\n ax.scatter([x_coord], [y_coord], marker='o', color='white', s = 250, edgecolors='black', linewidth=3)\n\n ax.set_yticklabels([xticks[tind] for tind in range(3)])\n ax.set_xticklabels([yticks[tind] for tind in range(3)])\n ax.axis([0, (100) - 1, 0, (100) - 1])\n\n # ax.scatter([x_coord_linear], [y_coord_linear], marker='o', color='blue', s = 250, edgecolors='black', linewidth=3)\n t = ax.set_title(r'$\\mathregular{\\frac{\\delta ^2 F(\\bar{x})}{\\delta x_i \\delta x_j}}$')\n # t = ax.set_title('{} and {} - '.format(first_variable, second_variable) + r'$\\mathregular{\\frac{\\delta ^2 F(\\bar{x})}{\\delta x_i \\delta x_j}}$')\n t.set_position([.5, 1.025])\n from mpl_toolkits.axes_grid1 import make_axes_locatable\n divider = make_axes_locatable(ax)\n cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n cb = plt.colorbar(img, cax=cax)\n cb.set_label(\"Nomralized mixed derivative\", rotation=90)\n plt.savefig('{}/{}_{}_{}_{}_nonlinear_map.pdf'.format(output_path, name, output_name, first_variable, second_variable), transparent=True, bbox_inches='tight', format='pdf', dpi=600)\n # plt.close('all')","def generate_egoview_overlaid_lidar(\n data_root: Path,\n output_dir: Path,\n log_id: str,\n render_ground_pts_only: bool,\n dump_single_frames: bool,\n) -> None:\n loader = AV2SensorDataLoader(data_dir=data_root, labels_dir=data_root)\n\n log_map_dirpath = data_root / log_id / \"map\"\n avm = ArgoverseStaticMap.from_map_dir(log_map_dirpath, build_raster=True)\n\n # repeat red to green colormap every 50 m.\n colors_arr_rgb = color_utils.create_colormap(\n color_list=[RED_HEX, GREEN_HEX], n_colors=NUM_RANGE_BINS\n )\n colors_arr_rgb = (colors_arr_rgb * 255).astype(np.uint8)\n colors_arr_bgr: NDArrayByte = np.fliplr(colors_arr_rgb)\n\n for _, cam_name in enumerate(list(RingCameras)):\n cam_im_fpaths = loader.get_ordered_log_cam_fpaths(log_id, cam_name)\n num_cam_imgs = len(cam_im_fpaths)\n\n video_list = []\n for i, im_fpath in enumerate(cam_im_fpaths):\n if i % 50 == 0:\n logging.info(\n f\"\\tOn file {i}/{num_cam_imgs} of camera {cam_name} of {log_id}\"\n )\n\n cam_timestamp_ns = int(im_fpath.stem)\n city_SE3_ego = loader.get_city_SE3_ego(log_id, cam_timestamp_ns)\n if city_SE3_ego is None:\n logger.exception(\"missing LiDAR pose\")\n continue\n\n # load feather file path, e.g. '315978406032859416.feather\"\n lidar_fpath = loader.get_closest_lidar_fpath(log_id, cam_timestamp_ns)\n if lidar_fpath is None:\n logger.info(\n \"No LiDAR sweep found within the synchronization interval for %s, so skipping...\",\n cam_name,\n )\n continue\n\n img_bgr = io_utils.read_img(im_fpath, channel_order=\"BGR\")\n\n lidar_points_ego = io_utils.read_lidar_sweep(lidar_fpath, attrib_spec=\"xyz\")\n lidar_timestamp_ns = int(lidar_fpath.stem)\n\n # put into city coords, then prune away ground and non-RoI points\n lidar_points_city = city_SE3_ego.transform_point_cloud(lidar_points_ego)\n lidar_points_city = avm.remove_non_drivable_area_points(lidar_points_city)\n is_ground_logicals = avm.get_ground_points_boolean(lidar_points_city)\n lidar_points_city = lidar_points_city[\n is_ground_logicals if render_ground_pts_only else ~is_ground_logicals\n ]\n lidar_points_ego = city_SE3_ego.inverse().transform_point_cloud(\n lidar_points_city\n )\n\n # motion compensate always\n (\n uv,\n points_cam,\n is_valid_points,\n ) = loader.project_ego_to_img_motion_compensated(\n points_lidar_time=lidar_points_ego,\n cam_name=cam_name,\n cam_timestamp_ns=cam_timestamp_ns,\n lidar_timestamp_ns=lidar_timestamp_ns,\n log_id=log_id,\n )\n\n if is_valid_points is None or uv is None or points_cam is None:\n continue\n\n if is_valid_points.sum() == 0:\n continue\n\n uv_int: NDArrayInt = np.round(uv[is_valid_points]).astype(np.int32)\n points_cam = points_cam[is_valid_points]\n pt_ranges: NDArrayFloat = np.linalg.norm(points_cam[:, :3], axis=1)\n color_bins: NDArrayInt = np.round(pt_ranges).astype(np.int32)\n # account for moving past 100 meters, loop around again\n color_bins = color_bins % NUM_RANGE_BINS\n uv_colors_bgr = colors_arr_bgr[color_bins]\n\n img_empty = np.full_like(img_bgr, fill_value=255)\n img_empty = raster_rendering_utils.draw_points_xy_in_img(\n img_empty, uv_int, uv_colors_bgr, diameter=10\n )\n blended_bgr = raster_utils.blend_images(img_bgr, img_empty)\n frame_rgb = blended_bgr[:, :, ::-1]\n\n if dump_single_frames:\n save_dir = output_dir / log_id / cam_name\n os.makedirs(save_dir, exist_ok=True)\n cv2.imwrite(\n str(save_dir / f\"{cam_name}_{lidar_timestamp_ns}.jpg\"), blended_bgr\n )\n\n video_list.append(frame_rgb)\n\n if len(video_list) == 0:\n raise RuntimeError(\n \"No video frames were found; log data was not found on disk.\"\n )\n\n video: NDArrayByte = np.stack(video_list).astype(np.uint8)\n video_output_dir = output_dir / \"videos\"\n video_utils.write_video(\n video=video,\n dst=video_output_dir / f\"{log_id}_{cam_name}.mp4\",\n fps=RING_CAMERA_FPS,\n )","def dataModel():\n srcmap001 = fits.open('dataFiles/6gev_srcmap_001.fits')\n srcmap03 = fits.open('dataFiles/6gev_srcmap_03.fits')\n\n image_data = fits.getdata('6gev_image.fits')\n filename = get_pkg_data_filename('6gev_image.fits')\n hdu = fits.open(filename)[0]\n wcs = WCS(hdu.header)\n\n #Given the results of the fit, calculate the model\n modelData001 = np.zeros(srcmap001[0].shape)\n modelData03 = np.zeros(srcmap03[0].shape)\n\n file = open('plotsData/fitResults001.pk1','rb')\n fit001 = pickle.load(file)\n file.close()\n\n file = open('plotsData/fitResults03.pk1','rb')\n fit03 = pickle.load(file)\n file.close()\n\n\n for source in fit001:\n the_index = srcmap001.index_of(source)\n\n modelData001 += fit001[source][:, None, None]*srcmap001[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap001[the_index].data, axis=2), axis=1)[:-1, None, None]\n for source in fit03:\n the_index = srcmap03.index_of(source)\n modelData03 += fit03[source][:, None, None]*srcmap03[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap03[the_index].data, axis=2), axis=1)[:-1, None, None]\n\n fig = plt.figure(figsize=[12, 4.5])\n\n vmin = 0\n vmax = 70.0\n cbStep = 10.0\n ax = fig.add_subplot(121, projection=wcs)\n ax=plt.gca()\n ax.tick_params(direction='in')\n c = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax.get_transform('galactic'))\n ax.add_patch(c)\n mappable=plt.imshow((image_data),cmap='inferno',origin='lower',norm=colors.PowerNorm(gamma=0.6),vmin=vmin, vmax=vmax, interpolation='gaussian')#\n plt.xlabel('Galactic Longitude')\n plt.ylabel('Galactic Latitude')\n plt.title('Data ($>6$ GeV)')\n cb = plt.colorbar(mappable, label='Counts per pixel', pad=0.01,ticks=np.arange(vmin, vmax+cbStep, cbStep))\n cb.ax.tick_params(width=0)\n\n\n ax2=fig.add_subplot(122, projection=wcs)\n ax2 = plt.gca()\n\n sources = []\n sources.append({\n 'Name':'3FGL J1745.3-2903c',\n 'RA':266.3434922,\n 'DEC':-29.06274323,\n 'color':'xkcd:bright light blue'})\n\n sources.append({\n 'Name':'1FIG J1748.2-2816',\n 'RA':267.1000722,\n 'DEC':-28.27707114,\n 'color':'xkcd:fire engine red'\n })\n\n sources.append({\n 'Name':'1FIG J1746.4-2843',\n 'RA':266.5942898,\n 'DEC':-28.86244442,\n 'color':'xkcd:fluorescent green'\n })\n\n sources.append({\n 'Name':'Galactic Center',\n 'RA':266.417,\n 'DEC':-29.0079,\n 'color':'black'\n })\n\n #Add source names:\n for source in sources:\n l, b = ra_dec_to_l_b(source['RA'], source['DEC'])\n ax2.scatter(l, b, color=source['color'],marker='x',s=45.0, transform=ax2.get_transform('galactic'), label=source['Name'])\n\n c2 = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax2.get_transform('galactic'))\n ax2.add_patch(c2)\n mappable2 = plt.imshow((np.sum(modelData03,axis=0)), cmap='inferno',norm=colors.PowerNorm(gamma=0.6),origin='lower',vmin=vmin, vmax=vmax, interpolation='gaussian')\n plt.xlabel('Galactic Longitude')\n plt.ylabel('Galactic Latitude')\n plt.title('Model ($>6$ GeV)')\n cb2 = plt.colorbar(mappable2, label='Counts per pixel', pad=0.01, ticks=np.arange(vmin, vmax+cbStep, cbStep))\n cb2.ax.tick_params(width=0)\n leg = plt.legend(loc=1,frameon=True)\n leg.get_frame().set_alpha(0.5)\n leg.get_frame().set_edgecolor('white')\n text1 = leg.get_texts()\n for text in text1:\n text.set_color('black')\n\n fig.tight_layout()\n plt.subplots_adjust(wspace = 0.13, left=0.04, bottom=0.13, top=0.92)\n plt.show()\n #plt.savefig('plots/dataModelComparison.pdf',bbox_inches='tight')","def plot_dollo_ml_tree(tree, nodes):\n leaf_order = []\n for leaf in tree.leaves:\n leaf.plot_id = leaf.name\n leaf_order.append(leaf.name)\n\n origin_counts = nodes.groupby('node')['ml_origin'].sum()\n\n for node in tree.nodes:\n node.origin_count = origin_counts[node.label]\n\n loss_counts = nodes.groupby('node')['ml_loss'].sum()\n\n width = 1 + 0.5 * float(len(list(tree.leaves)))\n fig = plt.figure(figsize=(width/1.5, 6))\n\n ax = fig.add_subplot(111)\n\n def func(x, pos):\n s = '{:0,d}'.format(int(x))\n return s\n ax.yaxis.set_major_formatter(matplotlib.ticker.FuncFormatter(func))\n\n wgs_analysis.plots.trees.plot_tree(ax, tree, landscape=False, flip=True, branch_length_attr='origin_count', leaf_name_attr='plot_id')\n\n ax.set_ylabel('SNV count')\n\n plt.tight_layout()","def analyze(data):\n # perform fit\n regr_results = sm.OLS.from_formula('mosquitos ~ temperature + rainfall', data).fit()\n print(regr_results.tvalues)\n \n fig = plt.figure(figsize=(6, 9))\n\n # plot predicted vs. measured mosquito populations from fitted model \n ax0 = fig.add_subplot(3, 1, 1)\n\n parameters = regr_results.params\n predicted = (parameters['Intercept'] + \n parameters['temperature'] * data['temperature'] + \n parameters['rainfall'] * data['rainfall'])\n\n ax0.plot(predicted, data['mosquitos'], 'gd')\n\n ax0.set_xlabel('predicted mosquito population')\n ax0.set_ylabel('measured mosquito population')\n \n # plot mosquitos vs. temperature\n ax1 = fig.add_subplot(3, 1, 2)\n\n ax1.plot(data['temperature'], data['mosquitos'], 'ro')\n ax1.set_xlabel('temperature')\n ax1.set_ylabel('mosquitos')\n\n # plot mosquitos vs. rainfall\n ax2 = fig.add_subplot(3, 1, 3)\n\n ax2.plot(data['rainfall'], data['mosquitos'], 'bs')\n ax2.set_xlabel('rainfall')\n ax2.set_ylabel('mosquitos')\n \n # adjust layout of axes according to label placement\n plt.tight_layout()\n \n return fig","def example():\n # --- input data filename ---\n infile = os.path.join(os.path.dirname(__file__),\n '../../ExampleDataFiles/MarsTopo719.shape')\n coeffs, lmax = pysh.shio.shread(infile)\n\n # --- plot grid ---\n grid = pysh.expand.MakeGridDH(coeffs, csphase=-1)\n fig_map = plt.figure()\n plt.imshow(grid)\n\n # ---- compute spectrum ----\n ls = np.arange(lmax + 1)\n pspectrum = pysh.spectralanalysis.spectrum(coeffs, unit='per_l')\n pdensity = pysh.spectralanalysis.spectrum(coeffs, unit='per_lm')\n\n # ---- plot spectrum ----\n fig_spectrum, ax = plt.subplots(1, 1)\n ax.set_xscale('log')\n ax.set_yscale('log')\n ax.set_xlabel('degree l')\n ax.grid(True, which='both')\n\n ax.plot(ls[1:], pspectrum[1:], label='power per degree l')\n ax.plot(ls[1:], pdensity[1:], label='power per degree l and order m')\n\n ax.legend()\n\n fig_map.savefig('SHRtopography_mars.png')\n fig_spectrum.savefig('SHRspectrum_mars.png')\n print('mars topography and spectrum saved')\n\n # plt.show()","def __init__(self):\n super(vanderpol_output,self).__init__()\n\n # add figure object for further use\n fig = plt.figure()\n self.ax = fig.add_subplot(111)\n self.ax.set_xlim([-2.5,2.5])\n self.ax.set_ylim([-10.5,10.5])\n plt.ion()\n self.sframe = None","def __init__(self):\r\n self.label = \"OVL to Feature\"\r\n self.description = \"OVL to Feature converts an OVL file from CPOF, C2PC, GCCS or similar system and converts it to a series of Feature Class for Point, Line, and Polygons.\"\r\n self.canRunInBackground = False","def main():\n strikes, dips, normals, slip = generate_normal_ss_data(330, 60, n=500, porp=1)\n #strikes, dips, normals, slip = generate_normal_data(330, 60, n=500, porp=10)\n sigma = invert_plane_stress(normals, slip)\n plot(sigma, strikes, dips)\n plt.show()","def plot_ls(self, ax):\n t = self.t\n x_true = self.x_true\n x_ls = self.x_ls\n\n ax.plot(t, x_true, 'k-', label='true', lw=1.5)\n ax.plot(t, x_ls, 'r-', label=r'$\\vec{x}_{LS}$', lw=1.5)\n ax.set_title(r'Noisy $A\\vec{x} = \\vec{b}$')\n ax.set_xlabel(r'$t$')\n ax.set_ylabel(r'$x$')\n leg = ax.legend(loc='upper left')\n leg.get_frame().set_alpha(0.5)\n ax.grid()","def make_map(data,LatLonBox):\n\n proj = ccrs.LambertConformal(central_longitude=data.StationLongitude,\n central_latitude=data.StationLatitude)\n\n fig = plt.figure(figsize=(17,11))\n ax = plt.subplot(111,projection=proj)\n \n ax.coastlines('50m', 'black', linewidth=2, zorder=2)\n\n reader = shpreader.Reader('/Users/chowdahead/Documents/shapefiles/countyl010g_shp_nt00964/countyl010g.shp')\n counties = list(reader.geometries())\n COUNTIES = cfeature.ShapelyFeature(counties,ccrs.PlateCarree())\n ax.add_feature(COUNTIES, facecolor='none',edgecolor='w')\n # Grab state borders\n state_borders = cfeature.NaturalEarthFeature(\n category='cultural', name='admin_1_states_provinces_lines',\n scale='50m', facecolor='none')\n ax.add_feature(state_borders, edgecolor='w', linewidth=1, zorder=3)\n \n ocean = cfeature.NaturalEarthFeature('physical', 'ocean', scale='50m',\n edgecolor='face',\n facecolor=cfeature.COLORS['water'])\n land = cfeature.NaturalEarthFeature('physical', 'land', scale='50m',\n edgecolor='face',\n facecolor=\"k\")\n\n ax.add_feature(ocean, zorder=-1)\n ax.add_feature(land, zorder=-1)\n ax.set_facecolor('black')\n \n ax.set_extent(LatLonBox,ccrs.PlateCarree())\n \n return fig,ax,proj","def learnSVR(metricArray, n, overlap, imageSize, fit): \n # fit = svrAlg() \n # metricArray = [[1,1],[2,3],[4,5], [3,7],[70,20],[5,20],[9,18], [87,34],[43,127], [1,10],[5,3],[4,8], [3,90],[76,20],[500,20],[29,34], [38,34],[43,17]]\n # n= 50 #Change your metrics here!!!!!!!!!\n # overlap = 0.3 \n #imageSize = [100,400]\n \n densMap(fit, metricArray, n, overlap, imageSize )\n overlayMap('SmallTile.jpg', 'ContourPlot.jpg') \n # Final map is saved as OverlayMap.jpg","def try4():\n path = '/Users/mayankkejriwal/git-projects/bioExperiments/tsne_python/'\n mnist = path+'mnist2500_X.txt'\n X = numpy.loadtxt(mnist)\n labels = numpy.loadtxt(path+\"mnist2500_labels.txt\")\n Y = tsne.tsne(X, 2, 50, 20.0)\n pylab.scatter(Y[:,0], Y[:,1], 20, labels)\n pylab.show()","def P_AI_Rocky2(in_dict):\n # START\n fs = 16\n plt.rc('font', size=fs)\n fig = plt.figure(figsize=(8,12))\n ds = nc.Dataset(in_dict['fn'])\n\n # PLOT CODE\n aa = [-122.8, -122.54, 47.92, 48.22]\n # import cmocean\n # cmap = cmocean.cm.speed\n # cmap = 'RdYlBu_r'\n cmap = 'Spectral_r'\n\n from warnings import filterwarnings\n filterwarnings('ignore') # skip some warning messages\n \n # plot Code\n \n # calculate speed\n uu = ds['u'][0, -1, :, :]\n vv = ds['v'][0, -1, :, :]\n u = zfun.fillit(uu)\n v = zfun.fillit(vv)\n u[np.isnan(u)] = 0\n v[np.isnan(v)] = 0\n # interpolate to the clipped rho grid\n ur = (u[1:-1,1:] + u[1:-1,:-1])/2\n vr = (v[1:,1:-1] + v[:-1,1:-1])/2\n spd = np.sqrt(ur**2 + vr**2)\n spd[spd==0] = np.nan\n \n G = zrfun.get_basic_info(in_dict['fn'], only_G=True)\n \n # panel 1\n ax = fig.add_subplot(111)\n cs = plt.pcolormesh(G['lon_psi'], G['lat_psi'], spd, cmap=cmap,\n vmin=0, vmax=1.5)\n tstr = (r'Admiralty Inlet Surface Speed ($m\\ s^{-1}$)')\n #pfun.add_bathy_contours(ax, ds, txt=True)\n pfun.add_coast(ax)\n ax.axis(aa)\n pfun.dar(ax)\n ax.set_xlabel('Longitude')\n ax.set_ylabel('Latitude')\n ax.set_title(tstr)\n pfun.add_info(ax, in_dict['fn'])\n ax.set_xticks([-122.8, -122.7, -122.6])\n ax.set_yticks([48, 48.1, 48.2])\n \n # Inset colorbar\n from mpl_toolkits.axes_grid1.inset_locator import inset_axes\n cbaxes = inset_axes(ax, width=\"4%\", height=\"30%\", loc='upper right', borderpad=3)\n fig.colorbar(cs, cax=cbaxes, orientation='vertical')\n \n #pfun.add_bathy_contours(ax, ds)\n pfun.add_coast(ax)\n ax.axis(aa)\n pfun.dar(ax)\n ax.set_xlabel('Longitude')\n ax.set_title(tstr)\n \n pfun.add_velocity_vectors(ax, ds, in_dict['fn'], v_scl=100, v_leglen=1,\n nngrid=80, zlev='top', center=(.1,.05))\n \n fig.tight_layout()\n # FINISH\n ds.close()\n if len(in_dict['fn_out']) > 0:\n plt.savefig(in_dict['fn_out'])\n plt.close()\n else:\n plt.show()\n plt.rcdefaults()","def plot_results(models,\n data,\n batch_size=128,\n model_name=\"vae_mnist\"):\n\n encoder, decoder = models\n x_test, y_test = data\n os.makedirs(model_name, exist_ok=True)\n\n filename = os.path.join(model_name, \"vae_mean.png\")\n # display a 2D plot of the digit classes in the latent space\n z_mean, _, _ = encoder.predict(x_test,\n batch_size=batch_size)\n plt.figure(figsize=(12, 10))\n plt.scatter(z_mean[:, 0], z_mean[:, 1], c=y_test)\n plt.colorbar()\n plt.xlabel(\"z[0]\")\n plt.ylabel(\"z[1]\")\n plt.savefig(filename)\n plt.show()\n\n filename = os.path.join(model_name, \"digits_over_latent.png\")\n # display a 30x30 2D manifold of digits\n n = 30\n digit_size = 28\n figure = np.zeros((digit_size * n, digit_size * n))\n # linearly spaced coordinates corresponding to the 2D plot\n # of digit classes in the latent space\n grid_x = np.linspace(-4, 4, n)\n grid_y = np.linspace(-4, 4, n)[::-1]\n\n for i, yi in enumerate(grid_y):\n for j, xi in enumerate(grid_x):\n z_sample = np.array([[xi, yi]])\n x_decoded = decoder.predict(z_sample)\n digit = x_decoded[0].reshape(digit_size, digit_size)\n figure[i * digit_size: (i + 1) * digit_size,\n j * digit_size: (j + 1) * digit_size] = digit\n\n plt.figure(figsize=(10, 10))\n start_range = digit_size // 2\n end_range = n * digit_size + start_range + 1\n pixel_range = np.arange(start_range, end_range, digit_size)\n sample_range_x = np.round(grid_x, 1)\n sample_range_y = np.round(grid_y, 1)\n plt.xticks(pixel_range, sample_range_x)\n plt.yticks(pixel_range, sample_range_y)\n plt.xlabel(\"z[0]\")\n plt.ylabel(\"z[1]\")\n plt.imshow(figure, cmap='Greys_r')\n plt.savefig(filename)\n plt.show()","def plotSnr2Density_TT_lines(self):\n # ell values for phi\n #L = np.logspace(np.log10(10.), np.log10(1.e4), 5, 10.)\n #L = np.array([10., 1.e2, 5.e2])\n L = [100.]\n \n # ell values for T\n L1 = np.logspace(np.log10(10.), np.log10(6.e4), 501, 10.)\n\n fig=plt.figure(0)\n ax=fig.add_subplot(111)\n #\n for iL in range(len(L)):\n f = lambda l1: self.snr2DensitySymLowL_TT(L[iL], l1)\n snr2Density = np.array(map(f, L1))\n # expected value if only counting number of modes\n dNLkappadlnl_theory = L1**2 / (np.pi)# * L[iL]**4\n\n # save the values for future use\n data = np.zeros((len(L1), 3))\n data[:,0] = L1.copy()\n data[:,1] = snr2Density\n data[:,2] = dNLkappadlnl_theory\n path = \"./output/cmblensrec/\"+self.CMB.name+\"/dsnr2_dlnl_L\"+intExpForm(L[iL])+\".txt\"\n print \"saving to \"+path\n np.savetxt(path, data)\n \n # normalize both, for plot\n dNLkappadlnl_theory /= np.max(snr2Density)\n snr2Density /= np.max(snr2Density)#[np.where(L1 <= 5.e3)]) # just to rescale in plot\n #ax.plot(L1, snr2Density, lw=2, c=plt.cm.jet(1.*iL/len(L)), label=r'$L_\\phi=$'+str(int(L[iL])))\n ax.plot(L1, snr2Density, lw=2, c='r', label=r'$L_\\phi=$'+str(int(L[iL])))\n ax.plot(L1, dNLkappadlnl_theory, 'r', ls='--', lw=1)\n #\n ax.legend(loc=1)\n ax.set_xscale('log', nonposx='clip')\n ax.set_xlabel(r'$\\ell_T$')\n ax.set_ylabel(r'$d\\text{SNR}(\\phi_L)^2/d\\text{ln}\\ell_T$')\n #ax.set_xlim((1., 5.e3))\n ax.set_ylim((0., 1.1))\n #\n path = \"./figures/cmblensrec/dsnr2_dl_test.pdf\"\n fig.savefig(path, bbox_inches='tight')\n \n plt.show()\n\n return L1, snr2Density","def read_SimCenter_DL_input(input_path, verbose=False):\n \n with open(input_path, 'r') as f:\n jd = json.load(f)\n\n # get the data required for DL\n data = dict([(label, dict()) for label in [\n 'general', 'units', 'components', 'collapse_modes',\n 'decision_variables', 'dependencies'\n ]])\n\n LM = jd['LossModel']\n\n # decision variables of interest\n # We assume that these are always specified in the file.\n DV = LM['DecisionVariables']\n for target_att, source_att in [\n ['injuries', 'Injuries'],\n ['rec_cost', 'ReconstructionCost'],\n ['rec_time', 'ReconstructionTime'],\n ['red_tag', 'RedTag'],\n ]:\n data['decision_variables'].update({target_att: bool(DV[source_att])})\n DV = data['decision_variables']\n\n # general information\n if 'GeneralInformation' in jd:\n GI = jd['GeneralInformation']\n else:\n GI = None\n\n # units\n if (GI is not None) and ('units' in GI.keys()):\n for key, value in GI['units'].items():\n if value == 'in':\n value = 'inch'\n if value in globals().keys():\n data['units'].update({key: globals()[value]})\n else:\n warnings.warn(UserWarning(\n \"Unknown {} unit: {}\".format(key, value)\n ))\n if 'length' in data['units'].keys():\n data['units'].update({\n 'area': data['units']['length']**2.,\n 'volume': data['units']['length']**3. \n })\n if 'acceleration' not in data['units'].keys():\n data['units'].update({\n 'acceleration': \n data['units']['length'] / data['units']['time'] ** 2.})\n else:\n warnings.warn(UserWarning(\n \"No units were specified in the input file. Standard units are \"\n \"assumed.\"))\n data['units'].update({\n 'force': 1.,\n 'length': 1.,\n 'area': 1.,\n 'volume': 1.,\n 'acceleration': 1.,\n })\n\n # other attributes\n for target_att, source_att, f_conv, unit_kind, dv_req in [\n ['plan_area', 'planArea', float, 'area', 'injuries'],\n # The following lines are commented out for now, because we do not use\n # these pieces of data anyway.\n #['stories', 'stories', int, ''],\n #['building_type', 'type', str, ''],\n #['height', 'height', float, 'length'],\n #['year_built', 'year', int, ''],\n ]:\n if (GI is not None) and (source_att in GI.keys()):\n #if unit_kind is not '':\n # f_unit = data['units'][unit_kind]\n #else:\n # f_unit = 1\n f_unit = data['units'][unit_kind]\n att_value = f_conv(GI[source_att]) * f_unit\n data['general'].update({target_att: att_value})\n else:\n if DV[dv_req]:\n warnings.warn(UserWarning(\n \"{} is not in the DL input file.\".format(source_att)))\n \n # components\n # Having components defined is not necessary, but if a component is defined\n # then all of its attributes need to be specified.\n if 'Components' in LM.keys():\n for comp in LM['Components']:\n comp_data = {\n 'quantities' : \n np.array([float(qnt) for qnt in comp['quantity'].split(',')]),\n 'csg_weights' : \n [float(wgt) for wgt in comp['weights'].split(',')],\n 'dirs' : \n [int(dir_) for dir_ in comp['directions'].split(',')],\n 'kind' : 'structural' if comp['structural'] else 'non-structural',\n 'distribution': comp['distribution'],\n 'cov' : float(comp['cov']),\n 'unit' : [float(comp['unit_size']), comp['unit_type']],\n }\n # get the location(s) of components based on non-zero quantities\n comp_data.update({\n 'locations':(np.where(comp_data['quantities'] > 0.)[0]+1).tolist()\n })\n # remove the zeros from the quantities\n nonzero = comp_data['quantities'] > 0.\n comp_data['quantities'] = comp_data['quantities'][nonzero].tolist()\n \n # scale the quantities according to the specified unit\n unit_kind = comp_data['unit'][1]\n if unit_kind not in globals().keys():\n raise ValueError(\n \"Unknown unit for component {}: {}\".format(\n comp['ID'], unit_kind))\n \n # store the component data\n data['components'].update({comp['ID']: comp_data})\n else:\n warnings.warn(UserWarning(\n \"No components were defined in the input file.\"))\n\n # collapse modes\n # Having collapse modes defined is not necessary, but if a collapse mode is\n # defined, then all of its attributes need to be specified.\n if 'CollapseModes' in LM.keys():\n for coll_mode in LM['CollapseModes']:\n cm_data = {\n 'w' : float(coll_mode['w']),\n 'injuries' : [float(inj) for inj in\n coll_mode['injuries'].split(',')],\n 'affected_area': [float(cfar) for cfar in\n coll_mode['affected_area'].split(',')],\n }\n data['collapse_modes'].update({coll_mode['name']: cm_data})\n else:\n warnings.warn(UserWarning(\n \"No collapse modes were defined in the input file.\"))\n\n # the number of realizations has to be specified in the file \n if (('UncertaintyQuantification' in LM) and \n ('Realizations' in LM['UncertaintyQuantification'])):\n data['general'].update({\n 'realizations': int(LM['UncertaintyQuantification'][\n 'Realizations'])})\n else:\n raise ValueError(\n \"Number of realizations is not specified in the input file.\")\n\n # this is a convenience function for converting strings to float or None\n def float_or_None(text):\n return float(text) if text != '' else None\n \n EDP_units = dict(\n # PID is not here because it is unitless\n PFA = 'acceleration'\n )\n\n # other general info\n if 'BuildingDamage' in LM.keys():\n if 'CollapseLimits' in LM['BuildingDamage'].keys():\n data['general'].update({\n 'collapse_limits':\n dict([(key, float_or_None(value)) for key, value in\n LM['BuildingDamage']['CollapseLimits'].items()])})\n # scale the limits by the units\n DGCL = data['general']['collapse_limits']\n for EDP_kind, value in DGCL.items():\n if (EDP_kind in EDP_units.keys()) and (value is not None):\n f_EDP = data['units'][EDP_units[EDP_kind]]\n DGCL[EDP_kind] = DGCL[EDP_kind] * f_EDP\n else:\n warnings.warn(UserWarning(\n \"Collapse EDP limits were not defined in the input file. \"\n \"Infinite EDP limits are assumed.\"))\n \n if 'IrrepairableResidualDrift' in LM['BuildingDamage'].keys():\n data['general'].update({\n 'irrepairable_res_drift':\n dict([(key, float_or_None(value)) for key, value in\n LM['BuildingDamage'][\n 'IrrepairableResidualDrift'].items()])})\n elif DV['rec_cost'] or DV['rec_time']:\n warnings.warn(UserWarning(\n \"Residual drift limits corresponding to irrepairable \"\n \"damage were not defined in the input file. We assume that \"\n \"damage is repairable regardless of the residual drift.\"))\n \n if 'ReplacementCost' in LM['BuildingDamage'].keys():\n data['general'].update({\n 'replacement_cost': float_or_None(\n LM['BuildingDamage']['ReplacementCost'])})\n elif DV['rec_cost']:\n warnings.warn(UserWarning(\n \"Building replacement cost was not defined in the input file.\"))\n \n if 'ReplacementTime' in LM['BuildingDamage'].keys():\n data['general'].update({\n 'replacement_time': float_or_None(\n LM['BuildingDamage']['ReplacementTime'])})\n elif DV['rec_time']:\n warnings.warn(UserWarning(\n \"Building replacement time was not defined in the input file.\"))\n else:\n warnings.warn(UserWarning(\n \"Building damage characteristics were not defined in the input \"\n \"file\"))\n \n if 'BuildingResponse' in LM.keys():\n if 'DetectionLimits' in LM['BuildingResponse'].keys():\n data['general'].update({\n 'detection_limits':\n dict([(key, float_or_None(value)) for key, value in\n LM['BuildingResponse']['DetectionLimits'].items()])})\n # scale the limits by the units\n DGDL = data['general']['detection_limits']\n for EDP_kind, value in DGDL.items():\n if (EDP_kind in EDP_units.keys()) and (value is not None):\n f_EDP = data['units'][EDP_units[EDP_kind]]\n DGDL[EDP_kind] = DGDL[EDP_kind] * f_EDP\n else:\n warnings.warn(UserWarning(\n \"EDP detection limits were not defined in the input file.\"))\n \n if 'YieldDriftRatio' in LM['BuildingResponse'].keys():\n data['general'].update({\n 'yield_drift': float_or_None(\n LM['BuildingResponse']['YieldDriftRatio'])})\n elif DV['rec_cost'] or DV['rec_time']:\n warnings.warn(UserWarning(\n \"Yield drift ratio was not defined in the input file.\"))\n \n else:\n warnings.warn(UserWarning(\n \"Building response characteristics were not defined in the input \"\n \"file.\"))\n \n if 'AdditionalUncertainty' in LM['UncertaintyQuantification'].keys():\n data['general'].update({\n 'added_uncertainty': {\n 'beta_gm': float_or_None(\n LM['UncertaintyQuantification']['AdditionalUncertainty'][\n 'GroundMotion']),\n 'beta_m' : float_or_None(\n LM['UncertaintyQuantification']['AdditionalUncertainty'][\n 'Modeling'])}})\n else:\n warnings.warn(UserWarning(\n \"No additional uncertainties were defined in the input file.\"))\n \n if 'Inhabitants' in LM.keys():\n if 'OccupancyType' in LM['Inhabitants'].keys():\n data['general'].update({\n 'occupancy_type': LM['Inhabitants']['OccupancyType']})\n elif DV['injuries']:\n warnings.warn(UserWarning(\n \"Occupancy type was not defined in the input file.\"))\n \n if 'PeakPopulation' in LM['Inhabitants'].keys():\n data['general'].update({\n 'population': [float(pop) for pop in\n LM['Inhabitants']['PeakPopulation'].split(',')]})\n elif DV['injuries']:\n warnings.warn(UserWarning(\n \"Peak population was not defined in the input file.\"))\n elif DV['injuries']:\n warnings.warn(UserWarning(\n \"Information about inhabitants was not defined in the input file.\"))\n\n # dependencies\n # We assume 'Independent' for all unspecified fields except for the \n # fragilities where 'per ATC recommendation' is the default setting.\n dependency_to_acronym = {\n 'btw. Fragility Groups' : 'FG',\n 'btw. Performance Groups': 'PG',\n 'btw. Floors' : 'LOC',\n 'btw. Directions' : 'DIR',\n 'btw. Damage States' : 'DS',\n 'Independent' : 'IND',\n 'per ATC recommendation' : 'ATC',\n }\n \n if 'LossModelDependencies' in LM:\n DEP = LM['LossModelDependencies']\n else:\n DEP = None\n \n for target_att, source_att, dv_req in [\n ['quantities', 'Quantities', ''],\n ['fragilities', 'Fragilities', ''],\n ['injuries', 'Injuries', 'injuries'],\n ['rec_costs', 'ReconstructionCosts', 'rec_cost'],\n ['rec_times', 'ReconstructionTimes', 'rec_time'],\n ['red_tags', 'RedTagProbabilities', 'red_tag'],\n ]:\n if (DEP is not None) and (source_att in DEP.keys()):\n data['dependencies'].update({\n target_att:dependency_to_acronym[DEP[source_att]]})\n elif dv_req == '' or DV[dv_req]:\n if target_att is not 'fragilities':\n data['dependencies'].update({target_att: 'IND'})\n else:\n data['dependencies'].update({target_att: 'ATC'})\n \n warnings.warn(UserWarning(\n \"Correlation between {} was not \".format(source_att)+\n \"defined in the input file. Using default values.\"))\n \n if (DEP is not None) and ('CostAndTime' in DEP.keys()):\n data['dependencies'].update({'cost_and_time': bool(DEP['CostAndTime'])})\n elif DV['rec_cost'] or DV['rec_time']:\n data['dependencies'].update({'cost_and_time': False})\n warnings.warn(UserWarning(\n \"Correlation between reconstruction cost and time was not defined \"\n \"in the input file. Using default values.\"))\n\n if (DEP is not None) and ('InjurySeverities' in DEP.keys()):\n data['dependencies'].update({'injury_lvls': \n bool(DEP['InjurySeverities'])})\n elif DV['injuries']:\n data['dependencies'].update({'injury_lvls': False})\n warnings.warn(UserWarning(\n \"Correlation between injury levels was not defined in the input \"\n \"file. Using default values.\"))\n\n if verbose: pp.pprint(data)\n \n return data","def load_gnss_logs(prefix):\n\n sat_data = loadmat(prefix + 'satposecef.mat')\n all_sat_pos = sat_data[\"svPoss\"][1:,:,:3] # ECEF coordinates (meters)\n ion_correction = sat_data[\"svPoss\"][1:,:,3] # meters\n sat_clock_bias = sat_data[\"svPoss\"][1:,:,4] # seconds\n\n # Load data and correct for ionosphere and satellite clock bias\n pr_data = loadmat(prefix + 'ranges.mat')\n if pr_data[\"pseudoranges\"].ndim == 2:\n all_pr = pr_data[\"pseudoranges\"][1:,:] + ion_correction + C*sat_clock_bias\n sats = pr_data[\"pseudoranges\"][0,:] # satellite SVID\n pos_only = True\n print('Assuming data at 1 Hz with t0 = 0')\n times = range(all_pr.shape[0])\n\n elif pr_data[\"pseudoranges\"].ndim == 3:\n all_pr = pr_data[\"pseudoranges\"][1:,:,0] + ion_correction + C*sat_clock_bias\n all_pr_rate = pr_data[\"pseudoranges\"][1:,:,1]\n all_sat_vel = pr_data[\"pseudoranges\"][1:,:,2:5]\n if pr_data[\"pseudoranges\"].shape[2] == 6:\n times = np.max(pr_data[\"pseudoranges\"][1:,:,5], axis=1)\n else:\n print('Assuming data at 1 Hz with t0 = 0')\n times = range(all_pr.shape[0])\n sats = pr_data[\"pseudoranges\"][0,:,0] # satellite SVID\n pos_only = False\n\n # Parse the data by time step and remove all invalid data (NaN)\n T, N = all_pr.shape\n sat_pos = []\n sat_vel = []\n pr = []\n pr_rate = []\n for t in range(T):\n # Only take measurements that are not NaN\n sat_pos_t = np.array([]).reshape(0,3)\n sat_vel_t = np.array([]).reshape(0,3)\n pr_t = np.array([])\n pr_rate_t = np.array([])\n for i in range(N):\n if not np.all(all_sat_pos[t,i,:] == 0.0) and not np.isnan(all_pr[t,i]):\n if pos_only:\n sat_pos_t = np.vstack((sat_pos_t, all_sat_pos[t,i,:].reshape((1,3))))\n pr_t = np.hstack((pr_t, all_pr[t,i]))\n else:\n sat_pos_t = np.vstack((sat_pos_t, all_sat_pos[t,i,:].reshape((1,3))))\n sat_vel_t = np.vstack((sat_vel_t, all_sat_vel[t,i,:].reshape((1,3))))\n pr_t = np.hstack((pr_t, all_pr[t,i]))\n pr_rate_t = np.hstack((pr_rate_t, all_pr_rate[t,i]))\n\n # Append data from time t to list\n sat_pos.append(sat_pos_t)\n sat_vel.append(sat_vel_t)\n pr.append(pr_t)\n pr_rate.append(pr_rate_t)\n\n # Store data in dictionary\n data = {\"t\":times, \"sats\":sats, \"sat_pos\":sat_pos, \"pr\":pr}\n if not pos_only:\n data[\"sat_vel\"] = sat_vel\n data[\"pr_rate\"] = pr_rate\n\n return data","def _fix_slovenian_lpis(self, eopatch):\n eopatch.vector_timeless[self.feature].rename(index=str, columns={\"SIFRA_KMRS\": \"crop_geopedia_idx\"},\n inplace=True)\n eopatch.vector_timeless[self.feature] = pd.merge(eopatch.vector_timeless[self.feature],\n self.mapping,\n on='crop_geopedia_idx')\n eopatch.vector_timeless[self.feature].loc[eopatch.vector_timeless[self.feature]['SIFKMRS'] == '204_a',\n 'SIFKMRS'] = '1204'\n eopatch.vector_timeless[self.feature]['SIFKMRS'] = pd.to_numeric(eopatch.vector_timeless[self.feature]['SIFKMRS'])","def add_line_sSFR_obs(line,L_line,ax,**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n # --- Observations compiled in Observations.ipynb ---\n\n L_obs = np.array([])\n sSFR_obs = np.array([])\n\n if p.plot: print('\\nObserved galaxies with %s:' % line)\n\n # Cormier et al. 2015 and Madden et al. 2013\n df = pd.read_pickle('data/observations/DGS_Cormier_2015') \n try:\n df = pd.read_pickle('data/observations/DGS_Cormier_2015')\n if p.plot: \n ax.errorbar(10.**df.sSFR,df['L_'+line],yerr=df['e_'+line], elinewidth=1,marker='s',ms=5,mew=0,\\\n color='grey',alpha=0.8,lw=0)\n # ax.plot(10.**df.sSFR,df['L_'+line],'s',ms=5,mew=0,color='grey',alpha=0.8,label='Cormier+15 (dwarfs)')\n L_ul = df['L_'+line][df['L_'+line] < 0]\n if len(L_ul) > 0:\n ax.plot(10.**df.sSFR[df['L_'+line] < 0],L_ul,'s',ms=5,mew=0,color='grey',alpha=0.8)\n ax.errorbar(10.**df.sSFR[df['L_'+line] < 0],L_ul, elinewidth=1,\\\n uplims=np.ones(len(L_ul)),yerr=0.3,color='grey',alpha=0.8,lw=0)\n #-1.*L_ul - 10.**(np.log10(-1.*L_ul)-0.3)\n L_obs = np.append(L_obs,df['L_'+line].values)\n # print(df['L_'+line].values)\n sSFR_obs = np.append(sSFR_obs,df.sSFR.values)\n if p.plot: print('%i galaxies from Cormier+15 with positiv flux' % (len(df['L_'+line].values[df['L_'+line].values > 0])))\n # print('min SFR: ',np.min(df.SFR.values[df.sizes < 47]))\n except:\n pass","def reconstruct(self, lam = 0.0001, display=False):\n \n self.history = {}\n \n x = utils.initImage(self.data, self.fov, self.scales[0], self.pulse_ft)\n \n if display:\n plt.ion()\n plt.show()\n self.__fig, self.__axs = plt.subplots(1, 2)\n plt.subplots_adjust(wspace=-0.1)\n self.__display(x, np.zeros_like(x), 'Initialization')\n \n self.history['init'] = x\n \n for scale in self.scales:\n\n x = utils.upscaleImage(x, self.fov, scale, self.pulse)\n \n gammas = (utils.ftVectors(self.data['bi_uvcoord1'], self.fov, \n scale, self.pulse_ft),\n utils.ftVectors(self.data['bi_uvcoord2'], self.fov, \n scale, self.pulse_ft),\n utils.ftVectors(self.data['bi_uvcoord3'], self.fov, \n scale, self.pulse_ft))\n \n for beta in self.betas:\n \n # (a) solve for Z while keeping x constant\n Z = utils.mostLikelyPatches(x, beta, self.data, \n self.patch_size, self.gmm)\n \n # (b) solve for x while keeping Z constant\n x = utils.taylorExpansion(x, Z, beta, self.data, gammas,\n self.patch_size, lam=lam)\n \n if display:\n self.__axs[0].clear()\n self.__axs[1].clear()\n self.__display(x, Z, 'Scale: ' + str(scale) + '\\n' +\\\n r'$\\beta$: ' + str(beta))\n self.history[scale] = x\n \n if display:\n plt.ioff()\n \n self.res = np.rot90(utils.upscaleImage(x, self.fov, \n self.naxis, self.pulse),2)\n return self.res","def show_map(pdb,show_sticks_all=False, show_sticks_metalbinding=True, show_probes=True, show_pdb_metals=True):\n view=py3Dmol.view(width=1000, height=800)\n\n view.addModel(open(pdb+'.pdb', 'r').read(),'pdb')\n if show_probes:\n view.addModel(open(pdb+'_PredictedSites.xyz', 'r').read(),'xyz')\n probes = open(pdb+'_PredictedSites.xyz', 'r').readlines()\n if(int(probes[0])!=0):\n probabilities = [p.replace('#','').split()[-1] for p in probes[2:]] # read p from comment in xyz file\n colors = {}\n # use different colors for the probabilities\n for i,x in enumerate(probabilities):\n colors[i] = '#%02x%02x%02x' % (0, 128, int(float(x)/float(probabilities[0])*255))\n else: #no predicted site\n colors = [] \n view.addLabel(\"No probe predicted\", {'position': {'x':0, 'y':0, 'z':0}, 'backgroundColor': '#0080FF', 'fontColor': 'white'});\n \n view.zoomTo()\n view.setBackgroundColor('white')\n view.setStyle({},{'cartoon': {'color':'gray'}})\n if show_sticks_all:\n view.setStyle({}, {'stick':{},'cartoon': {'color':'gray'}})\n if show_pdb_metals:\n view.getModel(0).setStyle({'resn':\"ZN\"},{'sphere': {'opacity':.75}})\n view.getModel(0).setStyle({'resn':\"CA\"},{'sphere': {'opacity':.75}})\n view.getModel(0).setStyle({'resn':\"CU\"},{'sphere': {'opacity':.75}})\n view.getModel(0).setStyle({'resn':\"HG\"},{'sphere': {'opacity':.75}})\n view.getModel(0).setStyle({'resn':\"MG\"},{'sphere': {'opacity':.75}})\n view.getModel(0).setStyle({'resn':\"FE\"},{'sphere': {'opacity':.75}})\n view.getModel(0).setStyle({'resn':\"MN\"},{'sphere': {'opacity':.75}})\n view.getModel(0).setStyle({'resn':\"NI\"},{'sphere': {'opacity':.75}})\n view.getModel(0).setStyle({'resn':\"MB\"},{'sphere': {'opacity':.75}})\n \n if show_probes:\n view.getModel(1).setStyle({},{'sphere': {'colorscheme':{'prop':'index', 'map':colors}}})\n \n # add hoverable labels for the residues and the predicted metals\n # two callbacks are needed, one for the residues and one for the metals\n # the metal one displays the probability\n view.getModel(0).setHoverable({},True,'''function(atom,viewer,event,container) {\n if(!atom.label) {\n atom.label = viewer.addLabel(atom.resn+atom.resi+\":\"+atom.atom,{position: atom, backgroundColor: 'mintcream', fontColor:'black'});\n }}''',\n '''function(atom,viewer) { \n if(atom.label) {\n viewer.removeLabel(atom.label);\n delete atom.label;\n }\n }''')\n view.getModel(1).setHoverable({},True,'''function(atom,viewer,event,container) {\n if(!atom.label) {\n atom.label = viewer.addLabel(atom.atom+\" [\"+atom.serial+\"]\",{position: atom, backgroundColor: 'mintcream', fontColor:'black'});\n }}''',\n '''function(atom,viewer) { \n if(atom.label) {\n viewer.removeLabel(atom.label);\n delete atom.label;\n }\n }''')\n if show_sticks_metalbinding:\n view.setStyle({'resn':\"HIS\"},{'stick': {}, 'cartoon': {'color':'gray'}})\n view.setStyle({'resn':\"ASP\"},{'stick': {}, 'cartoon': {'color':'gray'}})\n view.setStyle({'resn':\"GLU\"},{'stick': {}, 'cartoon': {'color':'gray'}})\n view.setStyle({'resn':\"CYS\"},{'stick': {}, 'cartoon': {'color':'gray'}})\n\n return view.show()","def plotTI():\n min_dl = dlam[dlam != 0].min()\n S = int(0.4/min_dl)\n fig = pl.figure(figsize = (8,6))\n ax = fig.add_subplot(1,1,1)\n ax.spines['bottom'].set_position('zero')\n ax.spines['top'].set_color('none')\n ax.spines['right'].set_color('none')\n ax.xaxis.set_ticks_position('bottom')\n ax.yaxis.set_ticks_position('left')\n\n for k, spine in ax.spines.items():\n spine.set_zorder(12.2)\n\n xs, ndx, dx = [0], 0, 0.001\n colors = ['r', 'g', '#7F38EC', '#9F000F', 'b', 'y']\n min_y, max_y = 0, 0\n\n lines = tuple()\n ## lv_names2 = [r'$Coulomb$', r'$vdWaals$'] ## for the paper\n lv_names2 = []\n for j in range(n_components):\n y = ave_dhdl[:,j]\n if not (y == 0).all():\n lv_names2.append(r'$%s$' % P.lv_names[j].capitalize())\n\n for j in range(n_components):\n\n y = ave_dhdl[:,j]\n if not (y == 0).all():\n\n # Get the coordinates.\n lj = lchange[:,j]\n x = lv[:,j][lj]\n y = y[lj]/P.beta_report\n\n if 'TI' in P.methods:\n # Plot the TI integration area.\n ss = 'TI'\n for i in range(len(x)-1):\n min_y = min(y.min(), min_y)\n max_y = max(y.max(), max_y)\n #pl.plot(x,y)\n if i%2==0:\n pl.fill_between(x[i:i+2]+ndx, 0, y[i:i+2], color=colors[ndx], alpha=1.0)\n else:\n pl.fill_between(x[i:i+2]+ndx, 0, y[i:i+2], color=colors[ndx], alpha=0.5)\n xlegend = [-100*wnum for wnum in range(len(lv_names2))]\n pl.plot(xlegend, [0*wnum for wnum in xlegend], ls='-', color=colors[ndx], label=lv_names2[ndx]) ## for the paper\n\n if 'TI-CUBIC' in P.methods and not cubspl[j]==0:\n # Plot the TI-CUBIC interpolation curve.\n ss += ' and TI-CUBIC'\n xnew = numpy.arange(0, 1+dx, dx)\n ynew = cubspl[j].interpolate(y, xnew)\n min_y = min(ynew.min(), min_y)\n max_y = max(ynew.max(), max_y)\n pl.plot(xnew+ndx, ynew, color='#B6B6B4', ls ='-', solid_capstyle='round', lw=3.0)\n\n else:\n # Plot the TI-CUBIC integration area.\n ss = 'TI-CUBIC'\n for i in range(len(x)-1):\n xnew = numpy.arange(x[i], x[i+1]+dx, dx)\n ynew = cubspl[j].interpolate(y, xnew)\n ynew[0], ynew[-1] = y[i], y[i+1]\n min_y = min(ynew.min(), min_y)\n max_y = max(ynew.max(), max_y)\n if i%2==0:\n pl.fill_between(xnew+ndx, 0, ynew, color=colors[ndx], alpha=1.0)\n else:\n pl.fill_between(xnew+ndx, 0, ynew, color=colors[ndx], alpha=0.5)\n\n # Store the abscissa values and update the subplot index.\n xs += (x+ndx).tolist()[1:]\n ndx += 1\n\n # Make sure the tick labels are not overcrowded.\n xs = numpy.array(xs)\n dl_mat = numpy.array([xs-i for i in xs])\n ri = range(len(xs))\n\n def getInd(r=ri, z=[0]):\n primo = r[0]\n min_dl=ndx*0.02*2**(primo>10)\n if dl_mat[primo].max()<min_dl:\n return z\n for i in r:\n for j in range(len(xs)):\n if dl_mat[i,j]>min_dl:\n z.append(j)\n return getInd(ri[j:], z)\n\n xt = [i if (i in getInd()) else '' for i in range(K)]\n pl.xticks(xs[1:], xt[1:], fontsize=10)\n pl.yticks(fontsize=10)\n #ax = pl.gca()\n #for label in ax.get_xticklabels():\n # label.set_bbox(dict(fc='w', ec='None', alpha=0.5))\n\n # Remove the abscissa ticks and set up the axes limits.\n for tick in ax.get_xticklines():\n tick.set_visible(False)\n pl.xlim(0, ndx)\n min_y *= 1.01\n max_y *= 1.01\n pl.ylim(min_y, max_y)\n\n for i,j in zip(xs[1:], xt[1:]):\n pl.annotate(('%.2f' % (i-1.0 if i>1.0 else i) if not j=='' else ''), xy=(i, 0), xytext=(i, 0.01), size=10, rotation=90, textcoords=('data', 'axes fraction'), va='bottom', ha='center', color='#151B54')\n if ndx>1:\n lenticks = len(ax.get_ymajorticklabels()) - 1\n if min_y<0: lenticks -= 1\n if lenticks < 5:\n from matplotlib.ticker import AutoMinorLocator as AML\n ax.yaxis.set_minor_locator(AML())\n pl.grid(which='both', color='w', lw=0.25, axis='y', zorder=12)\n pl.ylabel(r'$\\mathrm{\\langle{\\frac{ \\partial U } { \\partial \\lambda }}\\rangle_{\\lambda}\\/%s}$' % P.units, fontsize=20, color='#151B54')\n pl.annotate('$\\mathit{\\lambda}$', xy=(0, 0), xytext=(0.5, -0.05), size=18, textcoords='axes fraction', va='top', ha='center', color='#151B54')\n if not P.software.title()=='Sire':\n lege = ax.legend(prop=FP(size=14), frameon=False, loc=1)\n for l in lege.legendHandles:\n l.set_linewidth(10)\n pl.savefig(os.path.join(P.output_directory, 'dhdl_TI.pdf'))\n pl.close(fig)\n return","def _build_plotels(self, model):\n nplotels = len(model.plotels)\n if nplotels:\n # sorting these don't matter, but why not?\n #lines = [element.node_ids for unused_eid, element in sorted(model.plotels.items())]\n lines = []\n for unused_eid, element in sorted(model.plotels.items()):\n node_ids = element.node_ids\n lines.append(node_ids)\n lines = np.array(lines, dtype='int32')\n\n self.gui.create_alternate_vtk_grid(\n 'plotel', color=RED_FLOAT, line_width=2, opacity=0.8,\n point_size=5, representation='wire', is_visible=True)\n self._add_nastran_lines_to_grid('plotel', lines, model)","def __init__(self, votable, url=None):\n super(SLAResults, self).__init__(votable, url, \"sla\", \"1.0\")\n self._slacols = {\n\n\n \"ssldm:Line.title\": self.fieldname_with_utype(\"ssldm:Line.title\"),\n \"ssldm:Line.wavelength.value\": self.fieldname_with_utype(\"ssldm:Line.wavelength.value\"),\n \"ssldm:Line.initialLevel.energy.value\": self.fieldname_with_utype(\"ssldm:Line.initialLevel.energy.value\"),\n \"ssldm:Line.finalLevel.energy.value\": self.fieldname_with_utype(\"ssldm:Line.finalLevel.energy.value\"),\n \"ssldm:Line.environment.temperature.value\": self.fieldname_with_utype(\"ssldm:Line.environment.temperature.value\"),\n \"ssldm:Line.einsteinA.value\": self.fieldname_with_utype(\"ssldm:Line.einsteinA.value\"),\n \"ssldm:Process.type\": self.fieldname_with_utype(\"ssldm:Process.type\"),\n \"ssldm:Process.name\": self.fieldname_with_utype(\"ssldm:Process.name\"),\n \"ssldm:Line.identificationStatus\": self.fieldname_with_utype(\"ssldm:Line.identificationStatus\"),\n \"ssldm:Line.species.name\": self.fieldname_with_utype(\"ssldm:Line.species.name\"),\n \"ssldm:Line.initialLevel.name\": self.fieldname_with_utype(\"ssldm:Line.initialLevel.name\"),\n \"ssldm:Line.finalLevel.name\": self.fieldname_with_utype(\"ssldm:Line.finalLevel.name\"),\n \"ssldm:Line.observedWavelength.value\": self.fieldname_with_utype(\"ssldm:Line.observedWavelength.value\"),\n \"slap:Query.Score\": self.fieldname_with_utype(\"slap:Query.Score\"),\n \"ssldm:Line.initialLevel.configuration\": self.fieldname_with_utype(\"ssldm:Line.initialLevel.configuration\"),\n \"ssldm:Line.finalLevel.configuration\": self.fieldname_with_utype(\"ssldm:Line.finalLevel.configuration\"),\n \"ssldm:Line.initialLevel.quantumState\": self.fieldname_with_utype(\"ssldm:Line.initialLevel.quantumState\"),\n \"ssldm:Line.finalLevel.quantumState\": self.fieldname_with_utype(\"ssldm:Line.finalLevel.quantumState\"),\n \"Target.Name\": self.fieldname_with_utype(\"Target.Name\"),\n \"char:SpatialAxis.Coverage.Location.Value\": self.fieldname_with_utype(\"char:SpatialAxis.Coverage.Location.Value\"),\n \"char:TimeAxis.Coverage.Bounds.Start\": self.fieldname_with_utype(\"char:TimeAxis.Coverage.Bounds.Start\"),\n \"char:TimeAxis.Coverage.Bounds.Stop\": self.fieldname_with_utype(\"char:TimeAxis.Coverage.Bounds.Stop\")\n }\n self._recnames = { \n \"title\": self._slacols[\"ssldm:Line.title\"],\n \"wavelength\": self._slacols[\"ssldm:Line.wavelength.value\"],\n \"status\": self._slacols[\"ssldm:Line.identificationStatus\"],\n \"species_name\": self._slacols[\"ssldm:Line.species.name\"],\n \"initial_level\": self._slacols[\"ssldm:Line.initialLevel.name\"],\n \"final_level\": self._slacols[\"ssldm:Line.finalLevel.name\"]\n }"],"string":"[\n \"def plot_LvsL(modeldata,line1='CIV1548',line2='CIII1908',plotname='./TESTPLOT.pdf',\\n Zgas=False,logU=False,xid=0.3,nh=100,COratio=0.38,Mcutoff=100,\\n logx=False,logy=False,logp1=False,logp2=False,fixxrange=False,fixyrange=False,\\n showobs=None,noobserr=False,verbose=True):\\n NFalse = 0\\n freeparam = []\\n inforstr = \\\"\\\"\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n legenddic = {}\\n legenddic['Zgas'] = r'Z$_\\\\textrm{gas}$'\\n legenddic['logUs'] = r'log$_\\\\textrm{10}$(U)'\\n legenddic['xid'] = r'$\\\\xi_\\\\textrm{d}$'\\n legenddic['nh'] = r'n$_\\\\textrm{H}$ / [cm$^3$]'\\n legenddic['COCOsol'] = r'C/O / [C/O]$_\\\\textrm{sun}$'\\n legenddic['mup'] = r'M$_\\\\textrm{cut IMF}$ / [M$_\\\\textrm{sun}]$'\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not Zgas:\\n Zgasrange = [0.0,1.0]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' Zgas:vary, '\\n freeparam.append('Zgas')\\n else:\\n Zgasrange = [Zgas-1e-6,Zgas+1e-6]\\n inforstr = inforstr+' '+legenddic['Zgas']+'='+str(Zgas)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not logU:\\n logUrange = [-5.0,0.0]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' logU:vary, '\\n freeparam.append('logUs')\\n else:\\n logUrange = [logU-0.1,logU+0.1]\\n inforstr = inforstr+' '+legenddic['logUs']+'='+str(logU)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not xid:\\n xidrange = [0.0,0.6]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' xid:vary, '\\n freeparam.append('xid')\\n else:\\n xidrange = [xid-0.01,xid+0.01]\\n inforstr = inforstr+' '+legenddic['xid']+'='+str(xid)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not nh:\\n nhrange = [0.0,1.0e6]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' nH:vary, '\\n freeparam.append('nh')\\n else:\\n nhrange = [nh-1.0,nh+1.0]\\n inforstr = inforstr+' '+legenddic['nh']+'='+str(nh)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not COratio:\\n COratiorange = [0.0,2.0]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' C/O:vary, '\\n freeparam.append('COCOsol')\\n else:\\n COratiorange = [COratio-0.001,COratio+0.001]\\n inforstr = inforstr+' '+legenddic['COCOsol']+'='+str(COratio)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not Mcutoff:\\n Mcutoffrange = [0.0,400.0]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' Mcutoff:vary, '\\n freeparam.append('mup')\\n else:\\n Mcutoffrange = [Mcutoff-1.0,Mcutoff+1.0]\\n inforstr = inforstr+' '+legenddic['mup']+'='+str(Mcutoff)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n\\n if NFalse != 2:\\n sys.exit(' Two and only two of the model parameters (Zgas,logU,xid,nh,COratio,Mcutoff) '\\n 'should be set to Flase to define the model grid; however it appears '+str(NFalse)+\\n ' parameters where not set')\\n\\n goodent = np.where( (modeldata['Zgas'] > Zgasrange[0]) & (modeldata['Zgas'] < Zgasrange[1]) &\\n (modeldata['logUs'] > logUrange[0]) & (modeldata['logUs'] < logUrange[1]) &\\n (modeldata['xid'] > xidrange[0]) & (modeldata['xid'] < xidrange[1]) &\\n (modeldata['nh'] > nhrange[0]) & (modeldata['nh'] < nhrange[1]) &\\n (modeldata['COCOsol'] > COratiorange[0]) & (modeldata['COCOsol'] < COratiorange[1]) &\\n (modeldata['mup'] > Mcutoffrange[0]) & (modeldata['mup'] < Mcutoffrange[1]) )\\n\\n Ngoodent = len(goodent[0])\\n\\n if Ngoodent > 1:\\n if verbose: print(' - Getting data for '+str(Ngoodent)+' data points satisfying model selection ')\\n param1 = modeldata[freeparam[0]][goodent]\\n if logp1:\\n param1 = np.log10(param1)\\n\\n param2 = modeldata[freeparam[1]][goodent]\\n if logp2:\\n param2 = np.log10(param2)\\n\\n lum1 = modeldata[line1][goodent]\\n lum2 = modeldata[line2][goodent]\\n else:\\n if verbose: print(' WARNING: Less than 2 model grid points to plot; no output generated')\\n return\\n\\n # - - - - - - - - - - - PLOTTING - - - - - - - - - - -\\n if verbose: print(' - Setting up and generating plot')\\n plotname = plotname\\n fig = plt.figure(figsize=(9, 5))\\n fig.subplots_adjust(wspace=0.1, hspace=0.1,left=0.1, right=0.99, bottom=0.10, top=0.95)\\n Fsize = 10\\n lthick = 1\\n marksize = 3\\n plt.rc('text', usetex=True)\\n plt.rc('font', family='serif',size=Fsize)\\n plt.rc('xtick', labelsize=Fsize)\\n plt.rc('ytick', labelsize=Fsize)\\n plt.clf()\\n plt.ioff()\\n plt.title(inforstr[:-2],fontsize=Fsize)\\n\\n margin = 0.1\\n dx = np.abs(np.max(lum1)-np.min(lum1))\\n dy = np.abs(np.max(lum2)-np.min(lum2))\\n\\n\\n if fixxrange:\\n xrange = fixxrange\\n else:\\n if logx:\\n xrange = [np.min(lum1)-np.min(lum1)/2.,np.max(lum1)+np.max(lum1)/2.]\\n else:\\n xrange = [np.min(lum1)-dx*margin,np.max(lum1)+dx*margin]\\n\\n if fixyrange:\\n yrange = fixyrange\\n else:\\n if logy:\\n yrange = [np.min(lum2)-np.min(lum2)/2.,np.max(lum2)+np.max(lum2)/2.]\\n else:\\n yrange = [np.min(lum2)-dy*margin,np.max(lum2)+dy*margin]\\n\\n # ------------ PARAM1 ------------\\n cmap = plt.cm.get_cmap('winter')\\n cmin = np.min(param1)\\n cmax = np.max(param1)\\n colnorm = matplotlib.colors.Normalize(vmin=cmin,vmax=cmax)\\n cmaparr = np.linspace(cmin, cmax, 30) #cmax-cmin)\\n mm = plt.cm.ScalarMappable(cmap=cmap)\\n mm.set_array(cmaparr)\\n cb1 = plt.colorbar(mm)#shrink=0.25\\n\\n pstr1 = legenddic[freeparam[0]]\\n if logp1:\\n pstr1 = r'log$_\\\\textrm{10}$('+pstr1+')'\\n\\n cb1.set_label(pstr1+' (outer circle) - Fixed: black line')\\n\\n for p1 in np.unique(param1):\\n p1col = cmap(colnorm(p1))\\n p1ent = np.where(param1 == p1)\\n\\n plt.plot(lum1[p1ent],lum2[p1ent],'-',lw=lthick, color='k',zorder=1)\\n\\n plt.errorbar(lum1[p1ent],lum2[p1ent],xerr=None,yerr=None,\\n marker='o',lw=0, markersize=marksize*3,\\n markerfacecolor=p1col,ecolor=p1col,markeredgecolor = 'k',zorder=10)\\n\\n # ------------ PARAM2 ------------\\n cmap = plt.cm.get_cmap('spring')\\n cmin = np.min(param2)\\n cmax = np.max(param2)\\n colnorm = matplotlib.colors.Normalize(vmin=cmin,vmax=cmax)\\n cmaparr = np.linspace(cmin, cmax, 30) #cmax-cmin)\\n mm = plt.cm.ScalarMappable(cmap=cmap)\\n mm.set_array(cmaparr)\\n cb2 = plt.colorbar(mm)#shrink=0.25\\n\\n pstr2 = legenddic[freeparam[1]]\\n if logp2:\\n pstr2 = 'log10('+pstr2+')'\\n\\n cb2.set_label(pstr2+' (inner circle) - Fixed: gray line')\\n\\n for p2 in np.unique(param2):\\n p2col = cmap(colnorm(p2))\\n p2ent = np.where(param2 == p2)\\n\\n plt.plot(lum1[p2ent],lum2[p2ent],'-',lw=lthick, color='gray',zorder=2)\\n\\n plt.errorbar(lum1[p2ent],lum2[p2ent],xerr=None,yerr=None,\\n marker='o',lw=0, markersize=marksize*1.5,\\n markerfacecolor=p2col,ecolor=p2col,markeredgecolor = 'k',zorder=20)\\n\\n if showobs != None:\\n for ii, objid in enumerate(showobs[:,0]):\\n if (showobs[:,7][ii] > xrange[0]) & (showobs[:,7][ii] < xrange[1]) & \\\\\\n (showobs[:,9][ii] > yrange[0]) & (showobs[:,9][ii] < yrange[1]):\\n\\n if noobserr:\\n obsxerr = None\\n obsyerr = None\\n else:\\n obsxerr = showobs[:,8][ii]\\n obsyerr = showobs[:,10][ii]\\n plt.errorbar(showobs[:,7][ii],showobs[:,9][ii],xerr=obsxerr,yerr=obsyerr,\\n marker='*',lw=lthick, markersize=marksize*2,\\n markerfacecolor='k',ecolor='k',markeredgecolor = 'k',zorder=30)\\n\\n plt.xlabel(r'L$_\\\\textrm{'+line1+r'}$ / [3.826$\\\\times$1e33 erg/s]/[Msun/yr]')\\n plt.ylabel(r'L$_\\\\textrm{'+line2+r'}$ / [3.826$\\\\times$1e33 erg/s]/[Msun/yr]')\\n\\n plt.xlim(xrange)\\n plt.ylim(yrange)\\n\\n if logx:\\n plt.xscale('log')\\n if logy:\\n plt.yscale('log')\\n\\n #--------- LEGEND ---------\\n # plt.errorbar(-1,-1,xerr=None,yerr=None,fmt='o',lw=lthick,ecolor='white', markersize=marksize*2,\\n # markerfacecolor='white',markeredgecolor = 'k',label='Ground-based spec')\\n #\\n # leg = plt.legend(fancybox=True, loc='upper center',prop={'size':Fsize},ncol=1,numpoints=1)\\n # #bbox_to_anchor=(1.25, 1.03)) # add the legend\\n # leg.get_frame().set_alpha(0.7)\\n #--------------------------\\n\\n if verbose: print(' Saving plot to'+plotname)\\n plt.savefig(plotname)\\n plt.clf()\\n plt.close('all')\",\n \"def label_2d_latent(model,data_loader,embeddings=False):\\n model.eval()\\n plt.style.use('seaborn')\\n fig, ax = plt.subplots(dpi=100)\\n for batch_idx, (data,target) in enumerate(data_loader):\\n data = data.float()\\n z, recon_batch, mu, logvar = model(data.view(-1,numpy.prod(data.shape[-2:])))\\n z = z.data.cpu().numpy()\\n plt.scatter(z[:,0],z[:,1],s=10,c=target,cmap='cool',alpha=0.5)\\n if embeddings:\\n for i,img in enumerate(data):\\n imagebox = OffsetImage(data[i,0], zoom=0.4)\\n ab = AnnotationBbox(imagebox, (z[i,0], z[i,1]),frameon=False)\\n ax.add_artist(ab)\\n plt.xlabel('Latent variable 1')\\n plt.ylabel('Latent variable 2')\\n plt.tight_layout()\",\n \"def convert_mel_spectrogram_to_linear(self, mel: 'torch.tensor', **kwargs) -> 'torch.tensor':\",\n \"def plot_lshell_map(self, fitResultsDF,\\\\\\n baseDir=\\\"/home/bharat/Documents/code/new-vel-data/fit-figs/\\\"):\\n import seaborn as sns\\n import matplotlib.pyplot as plt\\n from matplotlib.colors import ListedColormap\\n from matplotlib.colors import Normalize\\n # Seaborn styling\\n sns.set_style(\\\"darkgrid\\\")\\n sns.set_context(\\\"paper\\\")\\n seaMap = ListedColormap(sns.color_palette(\\\"RdPu\\\"))\\n vLosSeaMap = ListedColormap(sns.color_palette(\\\"Spectral\\\"))\\n # Plot using matplotlib\\n fig = plt.figure()\\n ax1 = fig.add_subplot(211)\\n self.sapsVelsDF.plot( kind='scatter',\\n x='normMLT',\\n y='MLAT',\\n c='vLos',\\n s=20., cmap=vLosSeaMap, ax=ax1)\\n ax1.set_ylabel(\\\"MLAT\\\")\\n ax1.set_xlabel(\\\"MLT\\\", fontsize=12)\\n ax1.set_title( \\\"Velocities\\\" )\\n velScaleMax = 2000.\\n velScaleMin = 0.\\n colNorm = Normalize( vmin=velScaleMin, vmax=velScaleMax )\\n for frRows in fitResultsDF.iterrows():\\n # Plot Velocity vectors\\n currCol = seaMap( colNorm(frRows[1][\\\"velSAPS\\\"]) )\\n if frRows[1][\\\"goodFit\\\"]:\\n \\n ax1.plot( [ frRows[1][\\\"normMlt\\\"] , frRows[1][\\\"endPtNormMLT\\\"] ],\\\\\\n [ frRows[1][\\\"mlat\\\"], frRows[1][\\\"endPtMLAT\\\"] ],\\\\\\n color=currCol ) \\n ax1.arrow( frRows[1][\\\"normMlt\\\"], frRows[1][\\\"mlat\\\"], \\\\\\n frRows[1][\\\"endPtNormMLT\\\"]-frRows[1][\\\"normMlt\\\"],\\\\\\n frRows[1][\\\"endPtMLAT\\\"]-frRows[1][\\\"mlat\\\"],\\\\\\n head_width=0.1, head_length=0.2, fc=currCol,\\\\\\n ec=currCol)\\n else:\\n ax1.plot( [ frRows[1][\\\"normMlt\\\"] , frRows[1][\\\"endPtNormMLT\\\"] ],\\\\\\n [ frRows[1][\\\"mlat\\\"], frRows[1][\\\"endPtMLAT\\\"] ],\\\\\\n color=currCol, linestyle='dotted') \\n ax1.arrow( frRows[1][\\\"normMlt\\\"], frRows[1][\\\"mlat\\\"], \\\\\\n frRows[1][\\\"endPtNormMLT\\\"]-frRows[1][\\\"normMlt\\\"],\\\\\\n frRows[1][\\\"endPtMLAT\\\"]-frRows[1][\\\"mlat\\\"],\\\\\\n head_width=0.1, head_length=0.2, fc=currCol,\\\\\\n ec=currCol, linestyle='dotted')\\n # Plot azim\\n ax2 = fig.add_subplot(212)\\n self.sapsVelsDF.plot( kind='scatter',\\n x='normMLT',\\n y='MLAT',\\n c=self.fitAzmType,\\n s=20., cmap=seaMap, ax=ax2)\\n ax2.set_ylabel(\\\"MLAT\\\")\\n ax2.set_xlabel(\\\"MLT\\\", fontsize=12)\\n ax2.set_title( \\\"Azim\\\" )\\n figName = baseDir + \\\"lmap-\\\" + pandas.to_datetime(str(self.inpTime)).strftime(\\\"%Y%m%d\\\") +\\\\\\n \\\"-\\\" + pandas.to_datetime(str(self.inpTime)).strftime(\\\"%H%M\\\") + \\\".pdf\\\"\\n fig.savefig( figName,bbox_inches='tight' ) \\n plt.close('all')\",\n \"def make_kin_summary(loess=False, contours=\\\"vband\\\", format=\\\"png\\\",\\r\\n sn_lims=None, sn_loess=None, sn_sig=True):\\r\\n ##########################################################################\\r\\n # Set the limits for the S/N in case it is not defined by the user\\r\\n # sn_cut is defined in the setup_n3311 file\\r\\n if sn_lims == None:\\r\\n sn_lims = [sn_cut] * 4\\r\\n ##########################################################################\\r\\n # In case of LOESS smoothing, set the smoothing region (S/N < sn_loess)\\r\\n if sn_loess == None:\\r\\n sn_loess = [25, 25, 25, 25]\\r\\n ##########################################################################\\r\\n # Read data values for Lick indices\\r\\n data = np.loadtxt(outtable, usecols=(5, 7, 9, 11)).T\\r\\n # Read spectra name\\r\\n s = np.genfromtxt(outtable, usecols=(0,), dtype=None).tolist()\\r\\n ########################################################\\r\\n # Read coords and S/N\\r\\n xall, yall, sn = np.loadtxt(outtable, usecols=(1, 2, 14)).T\\r\\n ##########################################################\\r\\n # If using S/N / sigma instead of S/N\\r\\n if sn_sig == True:\\r\\n sn /= data[1] / 100.\\r\\n ########################################################\\r\\n # Read values of other authors\\r\\n tab1a, tab1b = get_richtler()\\r\\n tab2 = get_ventimiglia()\\r\\n ###############################################\\r\\n # Details of the maps\\r\\n # Name to be displayed during processing\\r\\n titles = [r\\\"velocity\\\", r\\\"sigma\\\", r\\\"h3\\\", r\\\"h4\\\"]\\r\\n # Tex strings to be used in labels\\r\\n cb_label = [r\\\"V$_{\\\\rm LOS}$ [km/s]\\\", r\\\"$\\\\sigma_{\\\\rm LOS}$ [km/s]\\\",\\r\\n r\\\"$h_3$\\\", r\\\"$h_4$\\\"]\\r\\n # Ranges of the plots\\r\\n # lims = [[3750, 4000], [200, 500], [None, None], [None, None]]\\r\\n lims = [[3700, 4100], [180, 500], [-0.08, 0.08], [-0.05, 0.11]]\\r\\n # Position of the colorbars\\r\\n xcb = [0.075, 0.555]\\r\\n xcb = xcb + xcb\\r\\n yc1 = 0.56\\r\\n yc2 = 0.085\\r\\n ycb = [yc1, yc1, yc2, yc2]\\r\\n # Colormap\\r\\n cmap = \\\"Spectral_r\\\"\\r\\n ylabels = [1, 0, 1, 0]\\r\\n xlabels = [0, 0, 1, 1]\\r\\n cb_fmts = [\\\"%d\\\", \\\"%d\\\", \\\"%.2f\\\", \\\"%.2f\\\"]\\r\\n ###############################################\\r\\n # Initialize figure and subplots\\r\\n fig = plt.figure(figsize=(12.5, 12))\\r\\n gs = gridspec.GridSpec(2, 2)\\r\\n gs.update(left=0.045, right=0.988, bottom=0.05, top=0.99, hspace=0.03,\\r\\n wspace=0.03)\\r\\n # Loop for figures\\r\\n for i, vector in enumerate(data):\\r\\n print \\\"Producing figure for {0}...\\\".format(titles[i])\\r\\n good = np.where(((~np.isnan(vector)) & (sn > sn_lims[i])))[0]\\r\\n if loess:\\r\\n sn_high = np.where(((~np.isnan(vector)) & (sn >= sn_loess[i])))[0]\\r\\n sn_low = np.delete(good, sn_high)\\r\\n vector_low = ll.loess_2d(xall[sn_low], yall[sn_low],\\r\\n vector[sn_low], frac=frac_loess)\\r\\n vector_high = vector[sn_high]\\r\\n good = np.hstack((sn_high, sn_low))\\r\\n v = np.hstack((vector_high, vector_low))\\r\\n else:\\r\\n v = vector[good]\\r\\n mad = 1.4826 * np.median(np.abs(v - np.median(v)))\\r\\n ######################################################################\\r\\n # Set limits according to median deviation if not defined in lims\\r\\n vmin = np.median(v) - 1.5 * mad if lims[i][0] == None else lims[i][0]\\r\\n vmax = np.median(v) + 1.5 * mad if lims[i][0] == None else lims[i][1]\\r\\n norm = Normalize(vmin=vmin, vmax=vmax)\\r\\n ######################################################################\\r\\n ax = plt.subplot(gs[i])\\r\\n coll = PolyCollection(polygons_bins[good], array=v, cmap=cmap,\\r\\n edgecolors='w', norm=norm)\\r\\n draw_map(fig, ax, coll)\\r\\n draw_contours(contours, fig, ax)\\r\\n plt.gca().add_patch(Rectangle((18, -36), 20, 10, alpha=1, zorder=1000,\\r\\n color=\\\"w\\\"))\\r\\n draw_colorbar(fig, ax, coll, cblabel=cb_label[i],\\r\\n cbar_pos=[xcb[i], ycb[i], 0.09, 0.02],\\r\\n ticks=np.linspace(vmin, vmax, 4), cb_fmt=cb_fmts[i],\\r\\n labelsize=12)\\r\\n xylabels(ax, y=ylabels[i], x=xlabels[i])\\r\\n if i not in [0, 2]:\\r\\n ax.set_yticklabels([])\\r\\n if i < 2:\\r\\n ax.set_xticklabels([])\\r\\n #####################################################\\r\\n # Draw long slits of other papers\\r\\n #####################################################\\r\\n if i > 1:\\r\\n continue\\r\\n bc = [\\\"g\\\", \\\"g\\\", \\\"b\\\", \\\"b\\\"]\\r\\n for k, tab in enumerate([tab1a, tab1b, tab2[4:], tab2[:4]]):\\r\\n norm = Normalize(vmin=vmin, vmax=vmax)\\r\\n idx = np.argsort(tab[:, 0])\\r\\n points = np.array([tab[:, 0][idx], tab[:, 1][idx]]).T.reshape(-1,\\r\\n 1, 2)\\r\\n segments = np.concatenate([points[:-1], points[1:]],\\r\\n axis=1)\\r\\n lc = LineCollection(segments, array=tab[:, i + 2],\\r\\n cmap=\\\"cubelaw\\\", norm=norm, lw=5)\\r\\n ax.add_collection(lc)\\r\\n add_borders(ax, points, c=bc[k])\\r\\n nloess = \\\"_loess\\\" if loess else \\\"\\\"\\r\\n plt.savefig(\\\"figs/kinmaps{0}_{1}.{2}\\\".format(nloess, contours, format),\\r\\n dpi=100)\\r\\n return\",\n \"def embedding_plot(model,datapath,img_size=100,stride=10,sample_size=1,nrand=None,adjust=True,show_images=True):\\n data = set_creation(datapath,img_size,stride,sample_size,nrand=nrand,adjust=adjust)\\n model.eval()\\n z = model(data[:nrand].float())[-1]\\n z = z.data.cpu().numpy()\\n plt.style.use('seaborn')\\n fig, ax = plt.subplots(dpi=100)\\n plt.scatter(z[:,0,0], z[:,0,1])\\n if show_images:\\n for i in range(len(z)):\\n imagebox = OffsetImage(data[i,0], zoom=0.4)\\n ab = AnnotationBbox(imagebox, (z[i,0,0], z[i,0,1]),frameon=False)\\n ax.add_artist(ab)\\n plt.xlabel('Latent variable 1')\\n plt.ylabel('Latent variable 2')\\n plt.tight_layout()\",\n \"def LLEEmbedding(TurosR=10,Torusr=4,Classes=[3,5,7],nei=[5,10,20], DataSet = {'Turos', 'Digits'}):\\n\\n S, dig = CreateDS_Torus_Digits(TurosR=TurosR,Torusr=Torusr,Classes=[3,5,7])\\n ### ------ LLE ------###\\n nei = nei\\n\\n if 'Turos' in DataSet:\\n # Plotting Torus\\n fig = plt.figure(figsize=(30, 10))\\n for i,j in enumerate(nei):\\n Torus_LLE = LLE(S,2,j)\\n neighbors = j\\n method = 'Torus LLE'\\n ax = fig.add_subplot(1, len(nei), i + 1)\\n scatter = ax.scatter(Torus_LLE[:, 0], Torus_LLE[:, 1], c=S[:, 0:1], cmap=plt.cm.Spectral)\\n # legend = ax.legend(*scatter.legend_elements(), loc=\\\"lower left\\\", title=\\\"Classes\\\")\\n # ax.add_artist(legend)\\n # ax.legend()\\n ax.set_title('{} with {} Neighbours'.format(method, neighbors))\\n # making_plot(Torus_LLE, pallete=S[:, 0:1], neighbors=j, method='Torus LLE') #An option to plot single graphs\\n plt.savefig('Torus LLE embbeding for {} neighbour'.format(neighbors))\\n\\n if 'Digits' in DataSet:\\n #Plotting Digits\\n for Argclass, Specificcalss in enumerate(dig):\\n fig = plt.figure(figsize=(30,10))\\n for i,j in enumerate(nei):\\n neighbors = j\\n Digit_LLE = LLE(Specificcalss[0],2,j)\\n method = 'Digit LLE'\\n ax = fig.add_subplot(1, len(nei), i + 1)\\n scatter = ax.scatter(Digit_LLE[:, 0], Digit_LLE[:, 1], c=Specificcalss[1], cmap=plt.cm.Spectral)\\n legend = ax.legend(*scatter.legend_elements(), loc=\\\"lower left\\\", title=\\\"Classes\\\")\\n ax.add_artist(legend)\\n ax.legend()\\n ax.set_title('{} with {} Neighbours'.format(method, neighbors))\\n # making_plot(Digit_isomap, Specificcalss[1], neighbors=j, method='Digit ISOMAP') #An option to plot single graphs\\n plt.savefig('Digits up to {} - LLE embbeding for {} neighbour'.format(Classes[Argclass], nei))\",\n \"def parse_lsg_model(lsg_model, plot_it=True):\\n df = pd.DataFrame(lsg_model.train_history_)\\n if plot_it:\\n ggplot(aes(x='epoch', y='valid_loss'), data=df) + geom_line()\\n return df\",\n \"def plot_lasso_path(df, resp_var, exp_vars):\\n import numpy as np\\n import pandas as pd\\n import matplotlib.pyplot as plt\\n import mpld3\\n from mpld3 import plugins\\n from sklearn.preprocessing import StandardScaler\\n from sklearn.linear_model import lasso_path\\n\\n # Standardise the feature data and response\\n feat_std = StandardScaler().fit_transform(df[[resp_var,] + exp_vars])\\n \\n # Calculate lasso path\\n alphas, coefs, _ = lasso_path(feat_std[:, 1:], # X\\n feat_std[:, 0], # y\\n eps=1e-3, # Path length\\n fit_intercept=False) # Already centred\\n\\n # -Log(alphas) is easier for display\\n neg_log_alphas = -np.log10(alphas)\\n\\n # Build df of results\\n res_df = pd.DataFrame(data=coefs.T, index=alphas, columns=exp_vars)\\n \\n # Plot\\n fig, ax = plt.subplots()\\n\\n for coef, name in zip(coefs, exp_vars):\\n line = ax.plot(neg_log_alphas, coef, label=name)\\n plugins.connect(fig, plugins.LineLabelTooltip(line[0], label=name))\\n\\n plt.xlabel('-Log(alpha)')\\n plt.ylabel('Coefficients')\\n plt.title('Lasso paths')\\n plt.legend(loc='best', title='', ncol=3) \\n \\n return res_df, fig\",\n \"def visualize_model():\\n dictionary_vis = gensim.corpora.Dictionary.load('dictionary.gensim')\\n corpus_vis = pickle.load(open('corpus.pkl', 'rb'))\\n lda = gensim.models.ldamodel.LdaModel.load('model5.gensim')\\n lda_display = pyLDAvis.gensim.prepare(lda, corpus_vis, dictionary_vis,\\n sort_topics=False)\\n pyLDAvis.display(lda_display)\",\n \"def plot_latents(model, data, mode='ae'):\\n latents = []\\n labels = []\\n for i, batch in enumerate(data):\\n imgs, digits = batch \\n imgs = imgs.squeeze(1).reshape(-1, 28*28)\\n if mode == 'ae':\\n embeds, _ = model(imgs)\\n if mode == 'vae':\\n embeds, _,_,_ = model(imgs)\\n embeds = embeds.detach().numpy().tolist()\\n digits = digits.detach().numpy().tolist()\\n latents.extend(embeds)\\n labels.extend(digits)\\n latents = np.asarray(latents)\\n print(f\\\"Labels:{len(labels)}, Data:{len(latents)}\\\")\\n plt.scatter(latents[:,0], latents[:,1], c=labels, cmap='tab10')\\n plt.colorbar()\",\n \"def make_los_velocity_map(time: u.s, field, instr, **kwargs):\\n plot_settings = {'cmap': cm.get_cmap('bwr'),\\n 'norm': colors.SymLogNorm(10, vmin=-1e8, vmax=1e8)}\\n plot_settings.update(kwargs.get('plot_settings', {}))\\n\\n bins, bin_range = instr.make_detector_array(field)\\n visible = is_visible(instr.total_coordinates, instr.observer_coordinate)\\n hist_coordinates, _, _ = np.histogram2d(instr.total_coordinates.Tx.value,\\n instr.total_coordinates.Ty.value,\\n bins=(bins.x.value, bins.y.value),\\n range=(bin_range.x.value, bin_range.y.value),\\n weights=visible)\\n with h5py.File(instr.counts_file, 'r') as hf:\\n try:\\n i_time = np.where(u.Quantity(hf['time'],\\n get_keys(hf['time'].attrs), ('unit', 'units')) == time)[0][0]\\n except IndexError:\\n raise IndexError(f'{time} is not a valid time in observing time for {instr.name}')\\n v_x = u.Quantity(hf['velocity_x'][i_time, :],\\n get_keys(hf['velocity_x'].attrs, ('unit', 'units')))\\n v_y = u.Quantity(hf['velocity_y'][i_time, :],\\n get_keys(hf['velocity_y'].attrs, ('unit', 'units')))\\n v_z = u.Quantity(hf['velocity_z'][i_time, :],\\n get_keys(hf['velocity_z'].attrs, ('unit', 'units')))\\n v_los = instr.los_velocity(v_x, v_y, v_z)\\n\\n hist, _, _ = np.histogram2d(instr.total_coordinates.Tx.value,\\n instr.total_coordinates.Ty.value,\\n bins=(bins.x.value, bins.y.value),\\n range=(bin_range.x.value, bin_range.y.value),\\n weights=v_los.value * visible)\\n hist /= np.where(hist_coordinates == 0, 1, hist_coordinates)\\n meta = instr.make_fits_header(field, instr.channels[0])\\n del meta['wavelnth']\\n del meta['waveunit']\\n meta['bunit'] = v_los.unit.to_string()\\n meta['detector'] = 'LOS Velocity'\\n meta['comment'] = 'LOS velocity calculated by synthesizAR'\\n\\n return GenericMap(hist.T, meta, plot_settings=plot_settings)\",\n \"def main():\\n\\n \\\"\\\"\\\"\\n Initialize Parameters\\n \\\"\\\"\\\"\\n src_path_map = '../data/map/wean.dat'\\n src_path_log = '../data/log/robotdata1.log'\\n\\n map_obj = MapReader(src_path_map)\\n occupancy_map = map_obj.get_map()\\n logfile = open(src_path_log, 'r')\\n\\n motion_model = MotionModel()\\n params = {\\n 'z_max': 8000,\\n 'lambda_short': 0.1,\\n 'sigma_hit': 20,\\n\\n 'z_pHit': 0.95,\\n 'z_pShort': 0.01,\\n 'z_pMax': 0.05,\\n 'z_pRand': 0.05,\\n\\n 'laser_sensor_offset': 25.0,\\n 'ray_step_size': 2,\\n 'grid_size': 10,\\n 'occ_thrsh': 0.1,\\n 'laser_subsample': 30,\\n\\n 'rayCast_vis': False,\\n 'map_vis': True\\n }\\n sensor_model = SensorModel(occupancy_map, params)\\n resampler = Resampling()\\n\\n num_particles = 1500\\n X_bar = init_particles_freespace(num_particles, occupancy_map)\\n vis_flag = 1\\n\\n \\\"\\\"\\\"\\n Monte Carlo Localization Algorithm : Main Loop\\n \\\"\\\"\\\"\\n if vis_flag:\\n visualize_map(occupancy_map)\\n\\n first_time_idx = True\\n for time_idx, line in enumerate(logfile):\\n\\n # Read a single 'line' from the log file (can be either odometry or laser measurement)\\n meas_type = line[0] # L : laser scan measurement, O : odometry measurement\\n meas_vals = np.fromstring(line[2:], dtype=np.float64,\\n sep=' ') # convert measurement values from string to double\\n\\n odometry_robot = meas_vals[0:3] # odometry reading [x, y, theta] in odometry frame\\n time_stamp = meas_vals[-1]\\n\\n # if ((time_stamp <= 0.0) | (meas_type == \\\"O\\\")): # ignore pure odometry measurements for now (faster debugging) \\n # continue\\n\\n if (meas_type == \\\"L\\\"):\\n odometry_laser = meas_vals[3:6] # [x, y, theta] coordinates of laser in odometry frame\\n ranges = meas_vals[6:-1] # 180 range measurement values from single laser scan\\n\\n print(\\\"Processing time step \\\" + str(time_idx) + \\\" at time \\\" + str(time_stamp) + \\\"s\\\")\\n\\n if (first_time_idx):\\n u_t0 = odometry_robot\\n first_time_idx = False\\n continue\\n\\n X_bar_new = np.zeros((num_particles, 4), dtype=np.float64)\\n u_t1 = odometry_robot\\n for m in range(0, num_particles):\\n\\n \\\"\\\"\\\"\\n MOTION MODEL\\n \\\"\\\"\\\"\\n x_t0 = X_bar[m, 0:3]\\n x_t1 = motion_model.update(u_t0, u_t1, x_t0)\\n\\n \\\"\\\"\\\"\\n SENSOR MODEL\\n \\\"\\\"\\\"\\n if (meas_type == \\\"L\\\"):\\n z_t = ranges\\n w_t = sensor_model.beam_range_finder_model(z_t, x_t1)\\n # w_t = 1/num_particles\\n X_bar_new[m, :] = np.hstack((x_t1, w_t))\\n else:\\n X_bar_new[m, :] = np.hstack((x_t1, X_bar[m, 3]))\\n\\n X_bar = X_bar_new\\n u_t0 = u_t1\\n\\n \\\"\\\"\\\"\\n RESAMPLING\\n \\\"\\\"\\\"\\n X_bar = resampler.low_variance_sampler(X_bar)\\n if vis_flag:\\n visualize_timestep(X_bar)\",\n \"def make_kinematics():\\r\\n # Read data values for vel, sigma, h3, h4\\r\\n data = np.loadtxt(outtable, usecols=(5, 7, 9, 11)).T\\r\\n xall, yall, sn = np.loadtxt(outtable, usecols=(1, 2, 14,)).T\\r\\n ###########################################################################\\r\\n # Details of the maps\\r\\n names = [r\\\"vel\\\", r\\\"sigma\\\", r\\\"h3\\\", r\\\"h4\\\"]\\r\\n cb_label = [r\\\"V$_{\\\\rm LOS}$ (km/s)\\\", r\\\"$\\\\sigma_{\\\\rm LOS}$ (km/s)\\\",\\r\\n r\\\"$h_3$\\\", r\\\"$h_4$\\\"]\\r\\n # lims = [[3750,4000], [150,500], [-0.08, 0.08], [-0.15, 0.15] ]\\r\\n lims = [[3640, 4040], [220, 500], [-0.08, 0.08], [-0.11, 0.11]]\\r\\n xcb = [0.068, 0.385, 0.705]\\r\\n ###########################################################################\\r\\n # Set the threshold S/N for smoothing\\r\\n # Higher values than this values are not smoothed\\r\\n sn_thres = [50, 50, 1000, 1000]\\r\\n ###########################################################################\\r\\n # Read values of other authors\\r\\n tab1a, tab1b = get_richtler()\\r\\n tab2 = get_ventimiglia()\\r\\n ###########################################################################\\r\\n # Set the colormap\\r\\n cmap = \\\"Spectral_r\\\"\\r\\n ###########################################################################\\r\\n # Loop for figures\\r\\n for i, vector in enumerate(data):\\r\\n print \\\"Producing figure for {0}...\\\".format(names[i])\\r\\n good = np.where(((~np.isnan(vector)) & (sn > sn_cut)))[0]\\r\\n sn_high = np.where(((~np.isnan(vector)) & (sn >= sn_thres[i])))[0]\\r\\n sn_low = np.delete(good, sn_high)\\r\\n vector_low = ll.loess_2d(xall[sn_low], yall[sn_low], vector[sn_low],\\r\\n frac=frac_loess)\\r\\n vector_high = vector[sn_high]\\r\\n good = np.hstack((sn_high, sn_low))\\r\\n v_loess = np.hstack((vector_high, vector_low))\\r\\n v = vector[good]\\r\\n vmin = lims[i][0] if lims[i][0] else v_loess.min()\\r\\n vmax = lims[i][1] if lims[i][1] else v_loess.max()\\r\\n fig = plt.figure(figsize=(15, 5.1))\\r\\n gs = gridspec.GridSpec(1, 3)\\r\\n gs.update(left=0.051, right=0.985, bottom=0.11, top=0.975, hspace=0.06,\\r\\n wspace=0.06)\\r\\n vs = [v, v_loess, v_loess]\\r\\n ylabels = [1, 0, 0]\\r\\n contours = [\\\"vband\\\", \\\"vband\\\", \\\"residual\\\"]\\r\\n cb_fmts = [\\\"%i\\\", \\\"%i\\\", \\\"%.2f\\\", \\\"%.2f\\\"]\\r\\n ####################################################\\r\\n # Produces pannels\\r\\n ####################################################\\r\\n for j in range(3):\\r\\n ax = plt.subplot(gs[j])\\r\\n # if i <1:\\r\\n # norm = LogNorm(vmin=vmin, vmax=vmax)\\r\\n # else:\\r\\n # norm = Normalize(vmin=vmin, vmax=vmax)\\r\\n norm = Normalize(vmin=vmin, vmax=vmax)\\r\\n coll = PolyCollection(polygons_bins[good], array=vs[j],\\r\\n cmap=cmap, edgecolors='w', norm=norm,\\r\\n linewidths=0.4)\\r\\n draw_map(fig, ax, coll)\\r\\n draw_contours(contours[j], fig, ax)\\r\\n plt.gca().add_patch(\\r\\n Rectangle((18, -36), 20, 10, alpha=1, zorder=10000,\\r\\n color=\\\"w\\\"))\\r\\n draw_colorbar(fig, ax, coll, cblabel=cb_label[i],\\r\\n cbar_pos=[xcb[j], 0.18, 0.08, 0.04],\\r\\n ticks=np.linspace(vmin, vmax, 4), cb_fmt=cb_fmts[i])\\r\\n xylabels(ax, y=ylabels[j])\\r\\n if j > 0:\\r\\n ax.set_yticklabels([])\\r\\n #####################################################\\r\\n # Draw long slits of other papers\\r\\n #####################################################\\r\\n if i > 1:\\r\\n continue\\r\\n bc = [\\\"g\\\", \\\"g\\\", \\\"b\\\", \\\"b\\\"]\\r\\n for k, tab in enumerate([tab1a, tab1b, tab2[4:], tab2[:4]]):\\r\\n norm = Normalize(vmin=vmin, vmax=vmax)\\r\\n idx = np.argsort(tab[:, 0])\\r\\n points = np.array([tab[:, 0][idx], tab[:, 1][idx]]).T.reshape(\\r\\n -1, 1, 2)\\r\\n segments = np.concatenate([points[:-1], points[1:]],\\r\\n axis=1)\\r\\n lc = LineCollection(segments, array=tab[:, i + 2],\\r\\n cmap=cmap, norm=norm, lw=5)\\r\\n ax.add_collection(lc)\\r\\n add_borders(ax, points, c=bc[k])\\r\\n # plt.savefig(\\\"figs/{0}.pdf\\\".format(names[i]))\\r\\n plt.savefig(\\\"figs/{0}.png\\\".format(names[i]))\\r\\n # plt.savefig(\\\"figs/{0}.eps\\\".format(names[i]), fmt=\\\"eps\\\")\\r\",\n \"def plot_NHI_model(lls_dict, ax, lsz=12., touch=False, scl=1., csz=10.):\\n from linetools.spectra.plotting import get_flux_plotrange\\n\\n spec, xspec, gdp, NHI, tau0 = setup_lls_fit_analy(lls_dict['spec_fil'], lls_dict['z'], lls_dict['windows'], lls_dict['NHI_mnx'])\\n # Scale\\n xspec.data['flux'] *= scl\\n # Limits\\n xmnx = [lls_dict['windows'][0][0], 940.*(1+lls_dict['z'])]\\n if lls_dict['cdict']['type'] == 'Gaussian':\\n ymnx = [-1*lls_dict['cdict']['sig'], lls_dict['cdict']['best']+4*lls_dict['cdict']['sig']]\\n elif lls_dict['cdict']['type'] == 'Fixed':\\n ymnx = [-0.1*lls_dict['cdict']['value'], 1.5*lls_dict['cdict']['value']]\\n elif lls_dict['cdict']['type'] == 'Fit_const':\\n ymnx = [-1*(lls_dict['cdict']['fit_val'][0]-lls_dict['cdict']['fit_val'][1]),\\n 3*(lls_dict['cdict']['fit_val'][2]-lls_dict['cdict']['fit_val'][0])+\\n lls_dict['cdict']['fit_val'][0]]\\n elif lls_dict['cdict']['type'] == 'Fit_line':\\n if gdp is None:\\n gdp = (xspec.wavelength>xmnx[0]*u.AA) & (xspec.wavelength<xmnx[1]*u.AA)\\n conti = lls_dict['cdict']['best'][0] + lls_dict['cdict']['best'][1]*(\\n xspec.wavelength[gdp].value-lls_dict['cdict']['slope_pivot']*(1+lls_dict['z']))\\n mx = np.max(conti)\\n ymnx = [-0.1*mx, mx*1.3]\\n else:\\n raise ValueError(\\\"Need to setup this continuum model\\\")\\n # Extend xmnx\\n if lls_dict['cdict']['type'] in ['Fit_line', 'Fit_const']:\\n xmx = 0.\\n for rng in lls_dict['cdict']['analy']:\\n xmx = max(xmx, rng[1])\\n xmnx[1] = xmx+3.\\n # Scale\\n ymnx = np.array(ymnx)*scl\\n # Finally\\n #idx = (xspec.wavelength > xmnx[0]*u.AA) & (xspec.wavelength < xmnx[1]*u.AA)\\n idx = gdp\\n f_ymnx = get_flux_plotrange(xspec.flux[idx].value)\\n ymnx[1] = max(ymnx[1],f_ymnx[1])\\n\\n\\n # Axes\\n #ax.xaxis.set_minor_locator(plt.MultipleLocator(0.5))\\n ax.xaxis.set_major_locator(plt.MultipleLocator(20.))\\n #ax.yaxis.set_minor_locator(plt.MultipleLocator(0.1))\\n #ax.yaxis.set_major_locator(plt.MultipleLocator(0.2))\\n ax.set_xlim(xmnx)\\n ax.set_ylim(ymnx)\\n if scl == 1.:\\n ax.set_ylabel(r'$f_\\\\lambda$ (cgs)', size=lsz)\\n else:\\n ax.set_ylabel(r'$f_\\\\lambda$ ($10^{-15}$ cgs)', size=lsz)\\n\\n\\n # Plot data\\n ax.plot(xspec.wavelength, xspec.flux, color='black', drawstyle='steps-mid',\\n zorder=2)\\n try:\\n ax.plot(xspec.wavelength, scl*xspec.sig, ':', color='red', zorder=1)\\n except ValueError:\\n pdb.set_trace()\\n\\n # Binned\\n if False:\\n binsz = 5.\\n binwv = np.arange(1040., 1200., binsz)*u.AA\\n binspec = xspec.rebin(binwv)\\n gdp = binspec.wavelength.value < 910.*(1+lls_dict['z'])\\n ax.scatter(binspec.wavelength.value[gdp]+binsz/2., binspec.flux[gdp],\\n color='yellow', zorder=300)\\n #edgecolor='none')#, alpha=0.5)\\n\\n # Best continuum\\n if lls_dict['cdict']['type'] == 'Gaussian':\\n conti = lls_dict['cdict']['best']*np.ones_like(xspec.flux.value)\\n elif lls_dict['cdict']['type'] == 'Fixed':\\n conti = lls_dict['cdict']['value']*np.ones_like(xspec.flux.value)\\n elif lls_dict['cdict']['type'] == 'Fit_const':\\n conti = lls_dict['cdict']['fit_val'][0]*np.ones_like(xspec.flux.value)\\n elif lls_dict['cdict']['type'] == 'Fit_line':\\n conti = lls_dict['cdict']['best'][0] + lls_dict['cdict']['best'][1]*(\\n xspec.wavelength.value-lls_dict['cdict']['slope_pivot']*(1+lls_dict['z']))\\n ax.plot(xspec.wavelength, conti*scl, '--', color='green', zorder=3)\\n ax.minorticks_on()\\n if touch is True:\\n pass\\n #ax.get_xaxis().set_ticks([])\\n else:\\n ax.set_xlabel('Wavelength (Ang)', size=lsz)\\n\\n # Best Model\\n mclr = 'lightblue'\\n wv_rest = xspec.wavelength / (lls_dict['z']+1)\\n energy = wv_rest.to(u.eV, equivalencies=u.spectral())\\n tau0 = (10.**lls_dict['fit_NHI'][0] / u.cm**2) * ltaa.photo_cross(1, 1, energy)\\n if lls_dict['analy_type'] in ['Fit_Conti', 'Vary_Conti']:\\n if lls_dict['fit_NHI'][0] != lls_dict['fit_NHI'][2]:\\n best_model = scl*conti * np.exp(-1*tau0)\\n abs = tau0 > 0.\\n ax.plot(xspec.wavelength[abs], best_model[abs], color=mclr, zorder=100)\\n\\n # Continuum Error\\n clr_ce = 'lightgreen'\\n alpha_ce = 0.4\\n if lls_dict['cdict']['type'] == 'Gaussian':\\n cwv = tau0 == 0.\\n npix = np.sum(cwv)\\n ax.fill_between(xspec.wavelength.value[cwv],\\n [scl*lls_dict['cdict']['best']+lls_dict['cdict']['sig']]*npix,\\n [scl*lls_dict['cdict']['best']-lls_dict['cdict']['sig']]*npix,\\n color=clr_ce, alpha=alpha_ce, zorder=50)\\n elif lls_dict['cdict']['type'] == 'Fit_const':\\n for rng in lls_dict['cdict']['analy']:\\n idx = ((xspec.wavelength > rng[0]*u.AA) &\\n (xspec.wavelength < rng[1]*u.AA) &\\n (xspec.sig > 0))\\n gdC = np.where(idx)[0]\\n ax.fill_between(xspec.wavelength.value[gdC],\\n [scl*lls_dict['cdict']['fit_val'][1]]*gdC.size,\\n [scl*lls_dict['cdict']['fit_val'][2]]*gdC.size,\\n color=clr_ce, alpha=alpha_ce, zorder=50)\\n elif lls_dict['cdict']['type'] == 'Fit_line':\\n #xdb.set_trace()\\n if 'fit_val' in lls_dict['cdict']:\\n for rng in lls_dict['cdict']['analy']:\\n idx = ((xspec.wavelength > rng[0]*u.AA) &\\n (xspec.wavelength < rng[1]*u.AA) &\\n (xspec.sig > 0))\\n gdC = np.where(idx)[0]\\n #\\n sig0 = (lls_dict['cdict']['fit_val'][0][2]-lls_dict['cdict']['fit_val'][0][1])/2.\\n sig1 = (lls_dict['cdict']['fit_val'][1][2]-lls_dict['cdict']['fit_val'][1][1])/2.\\n sigl = np.sqrt(sig0**2 +\\n sig1**2*(lls_dict['cdict']['slope_pivot']*(1+lls_dict['z'])-\\n xspec.wavelength.value[gdC])**2)\\n ax.fill_between(xspec.wavelength.value[gdC],\\n scl*(conti[gdC] + sigl),\\n scl*(conti[gdC] - sigl),\\n color=clr_ce, alpha=alpha_ce, zorder=50)\\n\\n # Model with error (limits too)\\n taulow = (10.**lls_dict['fit_NHI'][1] / u.cm**2) * ltaa.photo_cross(1, 1, energy)\\n try:\\n low_model = scl*conti * np.exp(-1*taulow)\\n except ValueError:\\n pdb.set_trace()\\n tauhi = (10.**lls_dict['fit_NHI'][2] / u.cm**2) * ltaa.photo_cross(1, 1, energy)\\n hi_model = scl*conti * np.exp(-1*tauhi)\\n mwv = tau0 > 0.\\n ax.fill_between(xspec.wavelength.value[mwv], low_model[mwv],\\n hi_model[mwv], color=mclr, alpha=0.3, zorder=100)\\n\\n # Finish\\n ax.plot(xmnx, [0.,0.], '--', color='gray')\",\n \"def spore_integrals():\\n\\n path_tops = os.path.join(path_to_here, '../data/landscape_visualizations/DMSO/{}/{}_hours')\\n idx_epochs = [25, 30]\\n repeat_names = ['original', 'repeat_a', 'repeat_b']\\n pList_data = os.path.join(path_to_here, '../data/embeddings/lims13/lims13_DMSO.pickle')\\n pList_data = _load_and_resize_list(pList_data)\\n\\n\\n def _plot_from_idx_repeat(ax, repeat_name, idx_epoch, color, linewidth = 0.6, linestyle = '-'):\\n if os.path.isfile(path_tops.format(repeat_name, idx_epoch) + '/p_list_0.pickle'):\\n p_list_NN = _load_and_resize_list(path_tops.format(repeat_name, idx_epoch) + '/p_list_0.pickle')\\n NN_spore_integrals = [np.sum(i[427:442, 182:196])*(26**2)/(1000**2) for i in p_list_NN]\\n ax.plot([1, 2, 3, 4, 5, 6, 7, 8], NN_spore_integrals[1:], c = color, linewidth = linewidth)\\n\\n\\n data_spore_integrals = [np.sum(i[427:442, 182:196])*(26**2)/(1000**2) for i in pList_data]\\n\\n fig = plt.figure(figsize = (2.3, 1.5))\\n for i, idx_epoch in enumerate(idx_epochs):\\n ax = fig.add_subplot(len(idx_epochs), 1, i+1)\\n ax.plot([1, 2, 3, 4, 5, 6, 7, 8], data_spore_integrals[1:], linewidth = 1, c = 'red')\\n if idx_epoch is not idx_epochs[-1]:\\n ax.set_xticks([])\\n for repeat_name, color in zip(repeat_names, ['blue', 'green', 'orange']):\\n _plot_from_idx_repeat(ax = ax, repeat_name = repeat_name, idx_epoch = idx_epoch, color = color)\\n if idx_epoch == idx_epochs[-1]:\\n _plot_from_idx_repeat(ax = ax, repeat_name = 'original', idx_epoch = 60, color = 'black', linewidth = 1, linestyle = '--')\\n\\n ax.set_ylabel(r'$\\\\approx \\\\int_{spore} \\\\hat{p}(\\\\mathbf{x},t)$', fontsize = 6, labelpad = 1)\\n ax.set_xlabel('Snapshot', fontsize = 6, labelpad = 1)\\n for ax in fig.axes:\\n ax.tick_params(axis = 'both', labelsize = 6)\\n\\n plt.subplots_adjust(hspace = 0)\\n plt.tight_layout()\\n plt.savefig(path_to_here+'/../outputs/'+'spore_integrals.png', dpi = 1200)\",\n \"def process_dl_model(self, raw_dl_model, roi_scale=0.75, input_size=(28, 28)):\\n # Redirect the information to console\\n start_console()\\n\\n # Receive model\\n raw_dl_model = raw_dl_model.split(\\\",\\\")[-1]\\n raw_dl_model_bytes = raw_dl_model.encode('ascii')\\n raw_dl_model_bytes = base64.b64decode(raw_dl_model_bytes)\\n\\n # Load ONNX model\\n ort_session = None\\n try:\\n with open(self.aux_model_fname, \\\"wb\\\") as f:\\n f.write(raw_dl_model_bytes)\\n ort_session = onnxruntime.InferenceSession(self.aux_model_fname)\\n except Exception:\\n exc_type, exc_value, exc_traceback = sys.exc_info()\\n print(str(exc_value))\\n print(\\\"ERROR: Model couldn't be loaded\\\")\\n\\n try:\\n # Init auxiliar variables used for stabilized predictions\\n previous_pred = 0\\n previous_established_pred = \\\"-\\\"\\n count_same_digit = 0\\n while not self.reload:\\n start_time = datetime.now()\\n start = time.time()\\n\\n # Get input webcam image\\n input_image = self.hal.getImage()\\n input_image_gray = np.mean(input_image, axis=2).astype(np.uint8)\\n\\n # Get original image and ROI dimensions\\n h_in, w_in = input_image.shape[:2]\\n min_dim_in = min(h_in, w_in)\\n h_roi, w_roi = (int(min_dim_in * roi_scale), int(min_dim_in * roi_scale))\\n h_border, w_border = (int((h_in - h_roi) / 2.), int((w_in - w_roi) / 2.))\\n\\n # Extract ROI and convert to tensor format required by the model\\n roi = input_image_gray[h_border:h_border + h_roi, w_border:w_border + w_roi]\\n roi_norm = (roi - np.mean(roi)) / np.std(roi)\\n roi_resized = cv2.resize(roi_norm, input_size)\\n input_tensor = roi_resized.reshape((1, 1, input_size[0], input_size[1])).astype(np.float32)\\n\\n # Inference\\n ort_inputs = {ort_session.get_inputs()[0].name: input_tensor}\\n output = ort_session.run(None, ort_inputs)[0]\\n pred = int(np.argmax(output, axis=1)) # get the index of the max log-probability\\n\\n end = time.time()\\n frame_time = round(end-start, 3)\\n fps = 1.0/frame_time\\n # number of consecutive frames that must be reached to consider a validprediction\\n n_consecutive_frames = int(fps/2)\\n\\n # For stability, only show digit if detected in more than n consecutive frames\\n if pred != previous_established_pred:\\n if count_same_digit < n_consecutive_frames:\\n if previous_pred == pred:\\n count_same_digit += 1\\n else:\\n count_same_digit = 0\\n previous_established_pred = \\\"-\\\" # no prediction\\n else:\\n print(\\\"Digit found: {}\\\".format(pred))\\n previous_established_pred = pred\\n count_same_digit = 0\\n previous_pred = pred\\n\\n # Show region used as ROI\\n cv2.rectangle(input_image,pt2=(w_border, h_border),pt1=(w_border + w_roi, h_border + h_roi),color=(255, 0, 0),thickness=3)\\n # Show FPS count\\n cv2.putText(input_image, \\\"FPS: {}\\\".format(int(fps)), (7,25), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255), 1)\\n\\n # Send result\\n self.gui.showResult(input_image, str(previous_established_pred))\\n\\n # Template specifics to run!\\n finish_time = datetime.now()\\n dt = finish_time - start_time\\n ms = (dt.days * 24 * 60 * 60 + dt.seconds) * 1000 + dt.microseconds / 1000.0\\n\\n self.iteration_counter += 1\\n\\n # The code should be run for atleast the target time step\\n # If it's less put to sleep\\n if (ms < self.time_cycle):\\n time.sleep((self.time_cycle - ms) / 1000.0)\\n\\n close_console()\\n print(\\\"Current Thread Joined!\\\")\\n\\n # To print the errors that the user submitted through the Javascript editor (ACE)\\n except Exception:\\n exc_type, exc_value, exc_traceback = sys.exc_info()\\n print(str(exc_value))\",\n \"def plotFilterOutputs(laplace_in=None, time_domain_fn=None, \\n lp_range=(0,1e-3), hp_range=(0,1e-3), points=1e3,\\n input_name=\\\"Input\\\"):\\n \\n t_lp = linspace(*lp_range,points)\\n t_hp = linspace(*hp_range,points)\\n\\n \\n if laplace_in != None:\\n \\n A,b,V_lowpass = lowpass(Vi=laplace_in)\\n t_lp,y_lp = inverseLaplace(V_lowpass[-1],t=t_lp)\\n \\n \\n A,b,V_highpass = highpass(Vi=laplace_in)\\n t_hp,y_hp = inverseLaplace(V_highpass[-1],t=t_hp)\\n \\n elif time_domain_fn != None:\\n \\n A,b,V_lowpass = lowpass()\\n lowsys = symToTransferFn(V_lowpass[-1])\\n t_lp,y_lp,svec = sp.lsim(lowsys, time_domain_fn(t_lp), t_lp)\\n \\n \\n A,b,V_highpass = highpass()\\n highsys = symToTransferFn(V_highpass[-1])\\n t_hp,y_hp,svec = sp.lsim(highsys, time_domain_fn(t_hp), t_hp)\\n \\n else:\\n print(\\\"No input given.\\\")\\n \\n \\n fig,axes = plt.subplots(1,2,figsize=(18,6))\\n ax1,ax2 = axes[0],axes[1]\\n \\n # low pass response plot\\n ax1.set_ylabel('$V_o$')\\n ax1.set_xlabel('$t$')\\n ax1.plot(t_lp,y_lp)\\n ax1.grid()\\n ax1.set_title(\\\"Response of low pass filter to {}\\\".format(input_name))\\n \\n # high pass response plot\\n ax2.set_ylabel('$V_o$')\\n ax2.set_xlabel('$t$')\\n ax2.plot(t_hp,y_hp)\\n ax2.grid()\\n ax2.set_title(\\\"Response of high pass filter to {}\\\".format(input_name))\\n \\n plt.show()\\n return t_lp,y_lp, t_hp,y_hp\",\n \"def img_lex_disp(data_word,search):\\n\\n x_vals, y_vals = lex_disp(data_word,search)\\n\\n imgdata = BytesIO()\\n fig, ax = plt.subplots()\\n ax.plot(x_vals,y_vals,\\\"rx\\\")\\n plt.ioff()\\n plt.yticks(range(len(search)), search)\\n plt.ylim(-1, len(search))\\n plt.xlim(-1, len(data_word))\\n plt.title(\\\"Lexical Dispersion Plot\\\")\\n plt.xlabel(\\\"Word Offset\\\")\\n plt.tight_layout()\\n fig.savefig(imgdata, format = 'png', dpi = 200)\\n\\n return imgdata\",\n \"def plot_visualization(path_results, x_data, y_data, variant_mode, nb_classes, signal_test, args):\\n\\n\\t#path_tsne = path_results + \\\"/Visualization/train/\\\" + str(args.step) + \\\"_2d.csv\\\"\\n\\t#data_frame = pd.read_csv(path_tsne)\\n\\t\\n\\tpath_maping = path_results + \\\"/Maping/\\\" + str(args.subject).split(\\\".txt\\\")[0] + \\\"/\\\"\\n\\tfilename = path_maping + \\\"maping_\\\" + str(args.step) + \\\"_\\\" + str(args.subject).split(\\\".txt\\\")[0] + \\\"_stick\\\" + str(args.stick) + \\\".png\\\"\\n\\n\\tprint(\\\"path_save maping\\\", path_maping)\\n\\n\\tif not os.path.exists(path_maping):\\n\\t\\tos.makedirs(path_maping)\\n\\n\\t#print(\\\"path_tsne\\\", path_tsne)\\n\\n\\tlabel_maping = np.array([10])\\n\\n\\tx_data = np.concatenate((x_data,signal_test),axis=0)\\n\\ty_data = np.concatenate((y_data,label_maping),axis=0)\\n\\n\\tprint(\\\"x_data concatenate\\\",x_data.shape)\\n\\tprint(\\\"y_data concatenate\\\",y_data.shape)\\n\\n\\tdata_frame = tsne_2d(x_data, y_data)\\n\\n\\t\\n\\t\\n\\tgroups = data_frame.groupby('label')\\n\\n\\tcluster_names, cluster_colors = get_target_names_dr(nb_classes, args.mode, args, variant_mode)\\n\\n\\tfig = plt.figure(figsize=(20, 10))\\n\\tax = fig.add_subplot(111)\\n\\tax.margins(0.05) # Optional, just adds 5% padding to the autoscaling\\n\\tfor name, group in groups:\\n\\t\\t\\n\\t\\tif cluster_names[name] == str(args.subject):\\n\\t\\t\\tax.scatter(group.x, group.y, marker='D', s=150, edgecolors = 'face',label=cluster_names[name], color=cluster_colors[name])\\n\\t\\telse:\\n\\t\\t\\tax.scatter(group.x, group.y, marker='o', label=cluster_names[name], color=cluster_colors[name])\\n\\n\\tax.legend(numpoints=1) #show legend with only 1 point\\n\\tplt.savefig(filename) #save the plot\",\n \"def display4(*args):\\n #-------------------- unpack\\n twiss_func = args[0]\\n cos_like = args[1]\\n sin_like = args[2]\\n lat_plot = args[3]\\n #-------------------- beta x,y & dispersion x\\n s = [twiss_func(i,'s') for i in range(twiss_func.nbpoints)] # Abszisse\\n bx = [twiss_func(i,'bx') for i in range(twiss_func.nbpoints)] # beta x\\n by = [twiss_func(i,'by') for i in range(twiss_func.nbpoints)] # beta y\\n dx = [twiss_func(i,'dx') for i in range(twiss_func.nbpoints)] # dispersion x\\n#-------------------- longitudinal trajectories\\n z1= [cos_like(i,'s') for i in range(cos_like.nbpoints)]\\n cz= [cos_like(i,'cz') for i in range(cos_like.nbpoints)]\\n cdp= [cos_like(i,'cdp') for i in range(cos_like.nbpoints)]\\n\\n z2= [sin_like(i,'s') for i in range(sin_like.nbpoints)]\\n sz= [sin_like(i,'sz') for i in range(sin_like.nbpoints)]\\n sdp= [sin_like(i,'sdp') for i in range(sin_like.nbpoints)]\\n #-------------------- lattice viseo\\n vzero = [0. for i in range(lat_plot.nbpoints)] # zero line\\n vis_abszisse = [lat_plot(i,'s') for i in range(lat_plot.nbpoints)]\\n vis_ordinate = [lat_plot(i,'viseo') for i in range(lat_plot.nbpoints)]\\n #-------------------- figure frame\\n width=14; height=7.6\\n # fighdr = 'lattice version = {}, input file = {}'.format(PARAMS['lattice_version'],PARAMS['input_file'])\\n fig = plt.figure(num=1,figsize=(width,height),facecolor='#eaecef',tight_layout=False)\\n\\n #-------------------- beta functions\\n splot211=plt.subplot(211)\\n splot211.set_title('beta x,y')\\n # mapping box\\n splot211.text(0.01, 1.1, UTIL.FLAGS.get('mapping'),transform=splot211.transAxes,fontsize=8,bbox=dict(boxstyle='round',facecolor='wheat',alpha=0.5),verticalalignment='top')\\n # function plots\\n plt.plot(s,bx, label=r\\\"$\\\\beta$x [m]\\\", color='black', linestyle='-')\\n plt.plot(s,by, label=r\\\"$\\\\beta$y [m]\\\", color='red', linestyle='-')\\n plt.plot(s,dx, label=r'$\\\\eta_x$ [m]' , color='green', linestyle='-') # dispersion x\\n vscale=splot211.axis()[3]*0.25\\n viseoz = [x*vscale for x in vis_ordinate]\\n plt.plot(vis_abszisse,viseoz,label='',color='black')\\n plt.plot(vis_abszisse,vzero,color='green',linestyle='--')\\n # zero line\\n splot211.plot(vis_abszisse,vzero,color='green',linestyle='--')\\n plt.legend(loc='lower right',fontsize='x-small')\\n\\n #-------------------- longitudinal tracks z, dP/P\\n # ax_l = left abszisse\\n ax_l=plt.subplot(212)\\n # ax_l=plt.subplot(10,1,(7,9))\\n ax_l.set_title('synchrotron oscillation')\\n ax_l.set_ylabel(r\\\"z [mm]\\\")\\n ax_l.tick_params(axis='y', colors='green')\\n ax_l.yaxis.label.set_color('green')\\n ax_l.plot(z1,cz,label='C',color='green')\\n ax_l.plot(z2,sz,label='S',color='green',linestyle=':')\\n plt.legend(loc='lower left',fontsize='x-small')\\n # ax_r = right abszisse\\n ax_r = ax_l.twinx()\\n ax_r.set_ylabel(r'$\\\\Delta$p/p [%]')\\n ax_r.tick_params(axis='y', colors='red')\\n ax_r.yaxis.label.set_color('red')\\n ax_r.plot(z2,cdp,label='C',color='red')\\n ax_r.plot(z2,sdp,label='S',color='red',linestyle=':')\\n ax_r.plot(vis_abszisse,vzero,color='red', linestyle='--')\\n plt.legend(loc='lower right',fontsize='x-small')\\n # lattice elements\\n vscale=ax_l.axis()[3]*0.25\\n viseoz = [x*vscale for x in vis_ordinate]\\n ax_l.plot(vis_abszisse,viseoz,label='',color='black')\\n ax_l.plot(vis_abszisse,vzero,color='green',linestyle='--')\",\n \"def __init__(self, obj_top, goal_top, las_top, invertX=False, invertY=False):\\n\\n rospy.init_node('create_map', anonymous=True)\\n\\n # Topics\\n self._objectTopic = obj_top\\n self._goalTopic = goal_top\\n self._laserTopic = las_top\\n\\n # Stores position of Robot and Goal\\n self._Position = Position(orientation=0.0, xPos=0.0, zPos=0.0)\\n self._goalPosition = Position()\\n\\n # Scatter Plot\\n self._fig, self._scatPlot = plt.subplots()\\n\\n # Inverters\\n self._invertX = invertX\\n self._invertY = invertY\\n\\n # =========================================\\n # Lists for storing data\\n # =========================================\\n\\n self._summitX, self._summitZ = [], []\\n self._laserX, self._laserZ = [], []\\n self._goalX, self._goalZ = [], []\\n self._objectX, self._objectZ = [], []\\n self._objectNames = []\\n self._objectDetected = False\\n # =========================================\\n # Create Plots\\n # =========================================\\n\\n self._summitPoints = self._scatPlot.scatter(\\n self._summitX, self._summitZ, c='green', edgecolors='none', s=100, marker=\\\"s\\\")\\n\\n self._laserPoints = self._scatPlot.scatter(\\n self._laserX, self._laserZ, c='red', edgecolors='none')\\n\\n self._goalPoints = self._scatPlot.scatter(\\n self._goalX, self._goalZ, c='blue', edgecolors='none', s=150, marker=\\\"*\\\")\\n\\n self._objectPoints = self._scatPlot.scatter(\\n self._laserX, self._laserZ, c='magenta', edgecolors='none')\\n\\n # =========================================\\n # Lists for Annotation Objects\\n # =========================================\\n self._summitAnnotation = None\\n self._goalAnnotation = None\\n self._objectAnnotations = []\\n\\n # Set Limits\\n self._set_plot_limits(4)\\n\\n self._get_position()\",\n \"def main():\\n \\n data_base = '/local/duman/SIMULATIONS/many_polymers_5/'\\n save_base = '/usr/users/iff_th2/duman/RolfData/many_polymers_5'\\n \\n \\n ## Index the data\\n# density = [0.08, 0.2, 0.4]\\n# xi_L = [0.05, 0.1, 0.2, 1.0, 2.5, 5.0, 8.0, 16.0]\\n# Pe = [3.0, 7.0, 15.0, 50.0, 150.0, 500.0, 750.0, 1500.0, 4375.0, 8000.0, 10000.0]\\n# kappa = [1.25, 2.5, 5.0, 25.0, 62.5, 125.0, 200.0, 400.0]\\n# fp = [0.0, 0.0048, 0.0112, 0.024, 0.08, 0.24, 0.8, 1.2, 2.4, 7.0]\\n \\n density = [0.2]\\n kappa = [1.25, 2.5, 5.0, 25.0, 62.5, 125.0, 200.0, 400.0]\\n xi_L = [0.05, 0.1, 0.2, 1.0, 2.5, 5.0, 8.0, 16.0]\\n fp = [0.0048, 0.0112, 0.024, 0.08, 0.24, 0.8, 1.2, 2.4, 7.0]\\n Pe = [3.0, 7.0, 15.0, 50.0, 150.0, 500.0, 750.0, 1500.0, 4375.0]\\n \\n ## Create points\\n points = []\\n for i, x in enumerate(xi_L):\\n for j, p in enumerate(Pe):\\n points.append( Phase(x, p, kappa[i], fp[j], 'short') ) \\n \\n for point in points:\\n point.analyse_type()\\n point.set_plot_props()\\n \\n long_xil = [0.05, 0.2, 1.0, 2.5, 16.0]\\n long_pe = [3.0, 150.0, 750.0, 8000.0, 10000.0]\\n long_kappa = [5.0, 20.0, 100.0, 250.0, 1600.0]\\n long_fp = [0.0003, 0.015, 0.075, 0.0, 0.0]\\n long_points = []\\n for i, x in enumerate(long_xil):\\n for j, p in enumerate(long_pe):\\n long_points.append( Phase(x, p, long_kappa[i], long_fp[j], 'long') ) \\n \\n for point in long_points:\\n point.determine_type()\\n point.set_plot_props()\\n \\n plot_data(points, long_points, save_base, xi_L, Pe)\",\n \"def ols_data():\\n\\n xs = [35.3, 29.7, 30.8, 58.8, 61.4, 71.3, 74.4, 76.7, 70.7, 57.5,\\n 46.4, 28.9, 28.1, 39.1, 46.8, 48.5, 59.3, 70, 70, 74.5, 72.1,\\n 58.1, 44.6, 33.4, 28.6]\\n ys = [10.98, 11.13, 12.51, 8.4, 9.27, 8.73, 6.36, 8.50,\\n 7.82, 9.14, 8.24, 12.19, 11.88, 9.57, 10.94, 9.58,\\n 10.09, 8.11, 6.83, 8.88, 7.68, 8.47, 8.86, 10.36, 11.08]\\n\\n\\n # self.Xk = 28.6\\n # self.ypred_k = 0.3091\\n solution = {'slope': -0.0798,\\n 'y_intercept': 13.623,\\n 'n': len(xs),\\n 'pred_x': 28.6,\\n 'pred_error': 0.309}\\n\\n return xs, ys, solution\",\n \"def lstm():\\n if request.method == 'POST':\\n return jsonify(message='Post message')\\n elif request.method == 'GET':\\n data = plots.lstm_df\\n data['ds'] = data['ds'].astype(str)\\n data = {'ds': data['ds'].tolist(),\\n 'yhat': data['yhat'].tolist(),\\n 'y_actual': data['y_actual'].tolist(),\\n 'yhat_lower': data['yhat_lower'].tolist(),\\n 'yhat_upper': data['yhat_upper'].tolist()\\n }\\n\\n return jsonify(isError=False,\\n message=\\\"Success\\\",\\n statusCode=200,\\n data=data), 200\",\n \"def ISOMAPEmbbeding(TurosR=10,Torusr=4,Classes=[3,5,7],nei=[5,10,20], DataSet = {'Turos', 'Digits'}):\\n\\n S, dig = CreateDS_Torus_Digits(TurosR=TurosR,Torusr=Torusr,Classes=[3,5,7])\\n ### ------ Isomap ------###\\n nei = nei\\n\\n if 'Turos' in DataSet:\\n # Ploting Torus Isomapping\\n fig = plt.figure(figsize=(30, 10))\\n for i, j in enumerate(nei):\\n Torus_isomap = Isomap(S, 2, j)\\n neighbors = j\\n method = 'Torus ISOMAP'\\n ax = fig.add_subplot(1, len(nei), i + 1)\\n scatter = ax.scatter(Torus_isomap[:, 0], Torus_isomap[:, 1], c=S[:, 0:1], cmap=plt.cm.Spectral)\\n # legend = ax.legend(*scatter.legend_elements(), loc=\\\"lower left\\\", title=\\\"Classes\\\")\\n # ax.add_artist(legend)\\n # ax.legend()\\n ax.set_title('{} with {} Neighbours'.format(method, neighbors))\\n # making_plot(Torus_isomap, pallete=S[:, 0:1], neighbors=j, method='Torus ISOMAP') #An option to plot single graphs\\n plt.savefig('Torus ISOMAP embbeding for {} neighbour'.format(nei))\\n\\n if 'Digits' in DataSet:\\n # Plotting Digits Isomapping\\n for Argclass, Specificcalss in enumerate(dig):\\n fig = plt.figure(figsize=(30, 10))\\n for i, j in enumerate(nei):\\n neighbors = j\\n Digit_isomap = Isomap(Specificcalss[0], 2, j)\\n method = 'Digit ISOMAP'\\n ax = fig.add_subplot(1, len(nei), i + 1)\\n scatter = ax.scatter(Digit_isomap[:, 0], Digit_isomap[:, 1], c=Specificcalss[1], cmap=plt.cm.Spectral)\\n legend = ax.legend(*scatter.legend_elements(), loc=\\\"lower left\\\", title=\\\"Classes\\\")\\n ax.add_artist(legend)\\n ax.legend()\\n ax.set_title('{} with {} Neighbours'.format(method, neighbors))\\n # making_plot(Digit_isomap, Specificcalss[1], neighbors=j, method='Digit ISOMAP') #An option to plot single graphs\\n plt.savefig('Digits up to {} - ISOMAP embbeding for {} neighbour'.format(Classes[Argclass], nei))\",\n \"def lcfig( z=7 ):\\n\\n for modelname in ['z15G','z25G','z40G'] :\\n\\n # initialize a supernova model :\\n snmodel = sncosmo.Model(source=modelname)\\n\\n # Fix the redshift for this instantiation of the model\\n # (NOTE: this does not apply any cosmological dimming. It only\\n # shifts the wavelengths)\\n snmodel.set( z = z )\\n\\n # generate the H band light curve\\n tobs = np.arange( 0, 1000, 10 )\\n M160 = snmodel.bandmag( 'f160w', 'ab', tobs ) # Absolute Magnitude\\n m160 = M160 + cosmo.distmod( z ).value # apparent magnitude\\n\\n pl.plot( tobs, m160 )\\n ax = pl.gca()\\n ax.invert_yaxis()\\n ax.set_xlabel('Time (observer-frame days)')\\n ax.set_ylabel('Apparent Magnitude in F160W')\\n ax.set_xlim( 0, 1000 )\\n ax.set_ylim( 36, 28 )\\n\\n pl.draw()\",\n \"def morph_CII(**kwargs):\\n\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n GR = glo.global_results()\\n \\n L_line = np.log10(getattr(GR,'L_'+p.line+'_sun'))\\n SFR = np.log10(getattr(GR,'SFR'))\\n\\n fig,ax = plt.subplots(figsize=(20,16))\\n\\n for i in range(len(L_line)):\\n \\n im = mpimg.imread('plots/sim_data/stamps/%s%s_G%i.png' % (p.sim_name,p.sim_run,i))\\n imbox = OffsetImage(im, zoom=0.02)\\n ab = AnnotationBbox(imbox, (SFR[i],L_line[i]), pad=0, frameon=False)\\n ax.add_artist(ab)\\n\\n ax.set_xlabel('log ' + getlabel('SFR'))\\n ax.set_ylabel('log ' + getlabel(p.line))\\n\\n if not p.xlim: p.xlim = np.array([-3,4])\\n if not p.ylim: \\n p.ylim = [np.median(L_line)-6,np.median(L_line)+4]\\n ax.set_xlim(p.xlim)\\n ax.set_ylim(p.ylim)\\n\\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \\n plt.savefig(p.d_plot + 'luminosity/morph_CII_%s%s' % (p.sim_name,p.sim_run),dpi=350)\",\n \"def run_laser_predictor(self, laser_arr):\",\n \"def visualize(self):\\n # TODO\\n #pyLDAvis.enable_notebook()\\n #vis = pyLDAvis.gensim.prepare(self.lda_model, self.stemmed_corpus)\\n return\",\n \"def lens_model_plot(ax, lensModel, kwargs_lens, numPix=500, deltaPix=0.01, sourcePos_x=0, sourcePos_y=0, point_source=False, with_caustics=False):\\n from lenstronomy.SimulationAPI.simulations import Simulation\\n simAPI = Simulation()\\n kwargs_data = simAPI.data_configure(numPix, deltaPix)\\n data = Data(kwargs_data)\\n _frame_size = numPix * deltaPix\\n _coords = data._coords\\n x_grid, y_grid = data.coordinates\\n lensModelExt = LensModelExtensions(lensModel)\\n\\n #ra_crit_list, dec_crit_list, ra_caustic_list, dec_caustic_list = lensModelExt.critical_curve_caustics(\\n # kwargs_lens, compute_window=_frame_size, grid_scale=deltaPix/2.)\\n x_grid1d = util.image2array(x_grid)\\n y_grid1d = util.image2array(y_grid)\\n kappa_result = lensModel.kappa(x_grid1d, y_grid1d, kwargs_lens)\\n kappa_result = util.array2image(kappa_result)\\n im = ax.matshow(np.log10(kappa_result), origin='lower',\\n extent=[0, _frame_size, 0, _frame_size], cmap='Greys', vmin=-1, vmax=1) #, cmap=self._cmap, vmin=v_min, vmax=v_max)\\n if with_caustics is True:\\n ra_crit_list, dec_crit_list = lensModelExt.critical_curve_tiling(kwargs_lens, compute_window=_frame_size,\\n start_scale=deltaPix, max_order=10)\\n ra_caustic_list, dec_caustic_list = lensModel.ray_shooting(ra_crit_list, dec_crit_list, kwargs_lens)\\n plot_line_set(ax, _coords, ra_caustic_list, dec_caustic_list, color='g')\\n plot_line_set(ax, _coords, ra_crit_list, dec_crit_list, color='r')\\n if point_source:\\n from lenstronomy.LensModel.Solver.lens_equation_solver import LensEquationSolver\\n solver = LensEquationSolver(lensModel)\\n theta_x, theta_y = solver.image_position_from_source(sourcePos_x, sourcePos_y, kwargs_lens)\\n mag_images = lensModel.magnification(theta_x, theta_y, kwargs_lens)\\n x_image, y_image = _coords.map_coord2pix(theta_x, theta_y)\\n abc_list = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K']\\n for i in range(len(x_image)):\\n x_ = (x_image[i] + 0.5) * deltaPix\\n y_ = (y_image[i] + 0.5) * deltaPix\\n ax.plot(x_, y_, 'dk', markersize=4*(1 + np.log(np.abs(mag_images[i]))), alpha=0.5)\\n ax.text(x_, y_, abc_list[i], fontsize=20, color='k')\\n x_source, y_source = _coords.map_coord2pix(sourcePos_x, sourcePos_y)\\n ax.plot((x_source + 0.5) * deltaPix, (y_source + 0.5) * deltaPix, '*k', markersize=10)\\n ax.get_xaxis().set_visible(False)\\n ax.get_yaxis().set_visible(False)\\n ax.autoscale(False)\\n #image_position_plot(ax, _coords, self._kwargs_else)\\n #source_position_plot(ax, self._coords, self._kwargs_source)\\n return ax\",\n \"def visualize(self):\\n\\n self.check_model()\\n show(prepare(self.model, self.vectorized_data, self.vectorizer, mds='tsne'))\",\n \"def plot_MDS():\\n lds = {} #lds is a dictionary of dictionaries: {\\\"slovenian.txt\\\": {\\\"abc\\\":3,\\\"efg\\\":4...}, \\\"macedonian.txt\\\":{\\\"abc\\\":5,\\\"efg\\\":6...},...}\\n for fn in listdir(\\\"clustering\\\"):\\n if fn.lower().endswith(\\\".txt\\\"):\\n with open(join(\\\"clustering\\\", fn), encoding=\\\"utf8\\\") as f:\\n text = f.read()\\n nter = terke(text, n=3)\\n lds[fn] = nter\\n \\n distances={} #a dictionary of dictionaries that saves the distances between a language and all other languages\\n \\n for x in lds.keys():\\n distances[x]={}\\n for y in lds.keys():\\n if x == y: distances[x][y]=0.0\\n else: distances[x][y]=cosine_dist(lds[x],lds[y])\\n\\n dst=np.zeros([len(lds.keys()), len(lds.keys())])\\n i=0\\n j=0\\n for x in lds.keys():\\n j=0\\n for y in lds.keys():\\n dst[i,j]=distances[x][y]\\n j+=1\\n i+=1\\n\\n X, languages = prepare_data_matrix()\\n\\n transformer = MDS(n_components=2, dissimilarity='precomputed')\\n transformed = transformer.fit_transform(dst)\\n\\n plt.scatter(transformed [:,0], transformed [:,1])\\n for i in range(len(transformed)):\\n plt.text(transformed[i,0], transformed[i,1], languages[i][:3])\\n plt.show()\",\n \"def ISM_lums(line,**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n GR = glo.global_results()\\n\\n L_tot = getattr(GR,'L_%s_sun' % line)\\n L_H2 = getattr(GR,'L_%s_H2_sun' % line)\\n L_HI = getattr(GR,'L_%s_HI_sun' % line)\\n L_HII = getattr(GR,'L_%s_HII_sun' % line)\\n fig, ax = plt.subplots(figsize=(8, 6 ),facecolor='w')\\n x=ax.hist(np.log10(L_tot[L_tot > 0]),bins=100,alpha=0.6,label='tot',color='grey')\\n x=ax.hist(np.log10(L_H2[L_H2 > 0]),bins=100,alpha=0.6,label='H2',color='r')\\n x=ax.hist(np.log10(L_HI[L_HI > 0]),bins=100,alpha=0.8,label='HI',color='orange')\\n x=ax.hist(np.log10(L_HII[L_HII > 0]),bins=100,alpha=0.5,label='HII',color='b')\\n ax.set_xlabel(getlabel('l'+line))\\n ax.set_ylabel('Number of galaxies')\\n plt.legend()\\n if p.savefig:\\n plt.savefig(p.d_plot + 'luminosity/ISM_lums_%s.png' % line)\",\n \"def plot_lineratios(modeldata,modeldata2='None',line1='CIV1551',line2='CIII1908',line3='CIV1551',line4='HeII1640',\\n plotname='./TESTPLOT.pdf',Zgas=False,logU=False,xid=0.3,nh=100,COratio=0.38,Mcutoff=100,\\n logx=True,logy=True,logp1=False,logp2=False,fixxrange=False,fixyrange=False,\\n showobs=None,noobserr=False,verbose=True):\\n NFalse = 0\\n freeparam = []\\n inforstr = \\\"\\\"\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n legenddic = {}\\n legenddic['Zgas'] = r'Z$_\\\\textrm{gas}$'\\n legenddic['logUs'] = r'log$_\\\\textrm{10}$(U)'\\n legenddic['xid'] = r'$\\\\xi_\\\\textrm{d}$'\\n legenddic['nh'] = r'n$_\\\\textrm{H}$ / [cm$^3$]'\\n legenddic['COCOsol'] = r'C/O / [C/O]$_\\\\textrm{sun}$'\\n legenddic['mup'] = r'M$_\\\\textrm{cut IMF}$ / [M$_\\\\textrm{sun}]$'\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not Zgas:\\n Zgasrange = [0.0,1.0]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' Zgas:vary, '\\n freeparam.append('Zgas')\\n else:\\n Zgasrange = [Zgas-1e-6,Zgas+1e-6]\\n inforstr = inforstr+' '+legenddic['Zgas']+'='+str(Zgas)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not logU:\\n logUrange = [-5.0,0.0]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' logU:vary, '\\n freeparam.append('logUs')\\n else:\\n logUrange = [logU-0.1,logU+0.1]\\n inforstr = inforstr+' '+legenddic['logUs']+'='+str(logU)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not xid:\\n xidrange = [0.0,0.6]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' xid:vary, '\\n freeparam.append('xid')\\n else:\\n xidrange = [xid-0.01,xid+0.01]\\n inforstr = inforstr+' '+legenddic['xid']+'='+str(xid)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not nh:\\n nhrange = [0.0,1.0e6]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' nH:vary, '\\n freeparam.append('nh')\\n else:\\n nhrange = [nh-1.0,nh+1.0]\\n inforstr = inforstr+' '+legenddic['nh']+'='+str(nh)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not COratio:\\n COratiorange = [0.0,2.0]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' C/O:vary, '\\n freeparam.append('COCOsol')\\n else:\\n COratiorange = [COratio-0.001,COratio+0.001]\\n inforstr = inforstr+' '+legenddic['COCOsol']+'='+str(COratio)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not Mcutoff:\\n Mcutoffrange = [0.0,400.0]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' Mcutoff:vary, '\\n freeparam.append('mup')\\n else:\\n Mcutoffrange = [Mcutoff-1.0,Mcutoff+1.0]\\n inforstr = inforstr+' '+legenddic['mup']+'='+str(Mcutoff)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n\\n if NFalse != 2:\\n sys.exit(' Two and only two of the model parameters (Zgas,logU,xid,nh,COratio,Mcutoff) '\\n 'should be set to Flase to define the model grid; however it appears '+str(NFalse)+\\n ' parameters where not set')\\n\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n goodent = np.where( (modeldata['Zgas'] > Zgasrange[0]) & (modeldata['Zgas'] < Zgasrange[1]) &\\n (modeldata['logUs'] > logUrange[0]) & (modeldata['logUs'] < logUrange[1]) &\\n (modeldata['xid'] > xidrange[0]) & (modeldata['xid'] < xidrange[1]) &\\n (modeldata['nh'] > nhrange[0]) & (modeldata['nh'] < nhrange[1]) &\\n (modeldata['COCOsol'] > COratiorange[0]) & (modeldata['COCOsol'] < COratiorange[1]) &\\n (modeldata['mup'] > Mcutoffrange[0]) & (modeldata['mup'] < Mcutoffrange[1]) )\\n\\n Ngoodent = len(goodent[0])\\n\\n if Ngoodent > 1:\\n if verbose: print(' - Getting data for '+str(Ngoodent)+' data points satisfying (SFR)model selection ')\\n param1_1 = modeldata[freeparam[0]][goodent]\\n if logp1:\\n param1_1 = np.log10(param1_1)\\n\\n param1_2 = modeldata[freeparam[1]][goodent]\\n if logp2:\\n param1_2 = np.log10(param1_2)\\n\\n ratio1_1 = modeldata[line1][goodent]/modeldata[line2][goodent]\\n ratio1_2 = modeldata[line3][goodent]/modeldata[line4][goodent]\\n else:\\n if verbose: print(' WARNING: Less than 2 (SFR)model grid points to plot; no output generated')\\n return\\n\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if modeldata2 != 'None':\\n goodent2 = np.where( (modeldata2['Zgas'] > Zgasrange[0]) & (modeldata2['Zgas'] < Zgasrange[1]) &\\n (modeldata2['logUs'] > logUrange[0]) & (modeldata2['logUs'] < logUrange[1]) &\\n (modeldata2['xid'] > xidrange[0]) & (modeldata2['xid'] < xidrange[1]) &\\n (modeldata2['nh'] > nhrange[0]) & (modeldata2['nh'] < nhrange[1]) )\\n\\n Ngoodent2 = len(goodent2[0])\\n\\n if Ngoodent > 1:\\n if verbose: print(' - Getting data for '+str(Ngoodent2)+' data points satisfying (AGN)model selection ')\\n param2_1 = modeldata2[freeparam[0]][goodent2]\\n if logp1:\\n param2_1 = np.log10(param2_1)\\n\\n param2_2 = modeldata2[freeparam[1]][goodent2]\\n if logp2:\\n param2_2 = np.log10(param2_2)\\n\\n l2s = ['x','x','x','x'] # line names to use for Feltre+16 file\\n for ll, linestr in enumerate([line1,line2,line3,line4]):\\n if '1908' in linestr:\\n l2 = linestr.replace('1908','1907')\\n else:\\n l2 = linestr\\n\\n l2s[ll] = l2\\n\\n ratio2_1 = modeldata2[l2s[0]][goodent2]/modeldata2[l2s[1]][goodent2]\\n ratio2_2 = modeldata2[l2s[2]][goodent2]/modeldata2[l2s[3]][goodent2]\\n else:\\n if verbose: print(' WARNING: Less than 2 (AGN)model grid points to plot; no output generated')\\n return\\n\\n # - - - - - - - - - - - PLOTTING - - - - - - - - - - -\\n if verbose: print(' - Setting up and generating plot')\\n plotname = plotname\\n fig = plt.figure(figsize=(9, 5))\\n fig.subplots_adjust(wspace=0.1, hspace=0.1,left=0.1, right=0.99, bottom=0.10, top=0.95)\\n Fsize = 10\\n lthick = 1\\n marksize = 3\\n plt.rc('text', usetex=True)\\n plt.rc('font', family='serif',size=Fsize)\\n plt.rc('xtick', labelsize=Fsize)\\n plt.rc('ytick', labelsize=Fsize)\\n plt.clf()\\n plt.ioff()\\n plt.title(inforstr[:-2],fontsize=Fsize)\\n\\n margin = 0.1\\n dx = np.abs(np.max(ratio1_1)-np.min(ratio1_1))\\n dy = np.abs(np.max(ratio1_2)-np.min(ratio1_2))\\n\\n\\n if fixxrange:\\n xrange = fixxrange\\n else:\\n if logx:\\n xrange = [np.min(ratio1_1)-np.min(ratio1_1)/2.,np.max(ratio1_1)+np.max(ratio1_1)/2.]\\n else:\\n xrange = [np.min(ratio1_1)-dx*margin,np.max(ratio1_1)+dx*margin]\\n\\n if fixyrange:\\n yrange = fixyrange\\n else:\\n if logy:\\n yrange = [np.min(ratio1_2)-np.min(ratio1_2)/2.,np.max(ratio1_2)+np.max(ratio1_2)/2.]\\n else:\\n yrange = [np.min(ratio1_2)-dy*margin,np.max(ratio1_2)+dy*margin]\\n\\n # ------------ PARAM1 ------------\\n cmap = plt.cm.get_cmap('winter')\\n cmin = np.min(param1_1)\\n cmax = np.max(param1_1)\\n colnorm = matplotlib.colors.Normalize(vmin=cmin,vmax=cmax)\\n cmaparr = np.linspace(cmin, cmax, 30) #cmax-cmin)\\n mm = plt.cm.ScalarMappable(cmap=cmap)\\n mm.set_array(cmaparr)\\n cb1 = plt.colorbar(mm)#shrink=0.25\\n\\n pstr1 = legenddic[freeparam[0]]\\n if logp1:\\n pstr1 = r'log$_\\\\textrm{10}$('+pstr1+')'\\n\\n cb1.set_label(pstr1+' (outer circle) - Fixed: black line')\\n\\n for p1 in np.unique(param1_1):\\n p1col = cmap(colnorm(p1))\\n p1ent = np.where(param1_1 == p1)\\n\\n plt.plot(ratio1_1[p1ent],ratio1_2[p1ent],'-',lw=lthick, color='k',zorder=1)\\n\\n plt.errorbar(ratio1_1[p1ent],ratio1_2[p1ent],xerr=None,yerr=None,\\n marker='o',lw=0, markersize=marksize*3,\\n markerfacecolor=p1col,ecolor=p1col,markeredgecolor = 'k',zorder=10)\\n\\n if modeldata2 is not 'None':\\n p1ent = np.where(param2_1 == p1)\\n\\n plt.plot(ratio2_1[p1ent],ratio2_2[p1ent],'-',lw=lthick, color='k',zorder=1)\\n\\n plt.errorbar(ratio2_1[p1ent],ratio2_2[p1ent],xerr=None,yerr=None,\\n marker='D',lw=0, markersize=marksize*3,\\n markerfacecolor=p1col,ecolor=p1col,markeredgecolor = 'k',zorder=10)\\n\\n\\n # ------------ PARAM2 ------------\\n cmap = plt.cm.get_cmap('spring')\\n cmin = np.min(param1_2)\\n cmax = np.max(param1_2)\\n colnorm = matplotlib.colors.Normalize(vmin=cmin,vmax=cmax)\\n cmaparr = np.linspace(cmin, cmax, 30) #cmax-cmin)\\n mm = plt.cm.ScalarMappable(cmap=cmap)\\n mm.set_array(cmaparr)\\n cb2 = plt.colorbar(mm)#shrink=0.25\\n\\n pstr2 = legenddic[freeparam[1]]\\n if logp2:\\n pstr2 = 'log10('+pstr2+')'\\n\\n cb2.set_label(pstr2+' (inner circle) - Fixed: gray line')\\n\\n for p2 in np.unique(param1_2):\\n p2col = cmap(colnorm(p2))\\n p2ent = np.where(param1_2 == p2)\\n\\n plt.plot(ratio1_1[p2ent],ratio1_2[p2ent],'-',lw=lthick, color='gray',zorder=2)\\n\\n plt.errorbar(ratio1_1[p2ent],ratio1_2[p2ent],xerr=None,yerr=None,\\n marker='o',lw=0, markersize=marksize*1.5,\\n markerfacecolor=p2col,ecolor=p2col,markeredgecolor = 'k',zorder=20)\\n\\n if modeldata2 is not 'None':\\n p2ent = np.where(param2_2 == p2)\\n\\n plt.plot(ratio2_1[p2ent],ratio2_2[p2ent],'-',lw=lthick, color='gray',zorder=2)\\n\\n plt.errorbar(ratio2_1[p2ent],ratio2_2[p2ent],xerr=None,yerr=None,\\n marker='D',lw=0, markersize=marksize*1.5,\\n markerfacecolor=p2col,ecolor=p2col,markeredgecolor = 'k',zorder=20)\\n\\n\\n if showobs != None:\\n for ii, objid in enumerate(showobs[:,0]):\\n if (showobs[:,7][ii] > xrange[0]) & (showobs[:,7][ii] < xrange[1]) & \\\\\\n (showobs[:,9][ii] > yrange[0]) & (showobs[:,9][ii] < yrange[1]):\\n\\n if noobserr:\\n obsxerr = None\\n obsyerr = None\\n else:\\n obsxerr = showobs[:,8][ii]\\n obsyerr = showobs[:,10][ii]\\n plt.errorbar(showobs[:,7][ii],showobs[:,9][ii],xerr=obsxerr,yerr=obsyerr,\\n marker='*',lw=lthick, markersize=marksize*2,\\n markerfacecolor='k',ecolor='k',markeredgecolor = 'k',zorder=30)\\n\\n plt.xlabel(line1+'/'+line2)\\n plt.ylabel(line3+'/'+line4)\\n\\n plt.xlim(xrange)\\n plt.ylim(yrange)\\n\\n if logx:\\n plt.xscale('log')\\n if logy:\\n plt.yscale('log')\\n\\n #--------- LEGEND ---------\\n # plt.errorbar(-1,-1,xerr=None,yerr=None,fmt='o',lw=lthick,ecolor='white', markersize=marksize*2,\\n # markerfacecolor='white',markeredgecolor = 'k',label='Ground-based spec')\\n #\\n # leg = plt.legend(fancybox=True, loc='upper center',prop={'size':Fsize},ncol=1,numpoints=1)\\n # #bbox_to_anchor=(1.25, 1.03)) # add the legend\\n # leg.get_frame().set_alpha(0.7)\\n #--------------------------\\n\\n if verbose: print(' Saving plot to'+plotname)\\n plt.savefig(plotname)\\n plt.clf()\\n plt.close('all')\",\n \"def AGN_SB_diagnostic(**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n GR = glo.global_results()\\n\\n fig,ax = plt.subplots()\\n L_CII = getattr(GR,'L_[CII]158_sun')\\n\\n # x = getattr(GR,'L_[CII]158_sun')/getattr(GR,'L_[NII]122_sun')\\n x = getattr(GR,'L_[OIV]25_sun')/getattr(GR,'L_[OIII]88_sun')\\n y = getattr(GR,'L_[NeIII]15_sun')/getattr(GR,'L_[NeII]12_sun')\\n sc = ax.scatter(x,y,marker='o',s=3,alpha=0.6,c=np.log10(getattr(GR,'SFR')))\\n ax.set_xscale('log')\\n ax.set_yscale('log')\\n ax.set_xlim([8e-5,200])\\n ax.set_ylim([0.02,150])\\n # ax.set_xlabel('[CII]$_{158}$/[NII]$_{122}$')\\n plt.colorbar(sc,label='log(SFR)')\\n ax.set_xlabel('[OIV]$_{25.9}$/[OIII]$_{88}$')\\n ax.set_ylabel('[NeIII]$_{15.6}$/[NeII]$_{12.8}$')\\n if p.savefig:\\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \\n plt.savefig(p.d_plot + 'luminosity/ratio_%s' % ratio_name,dpi=300)\",\n \"def test_lrp_svm(self, syn_genomic_data, syn_fm, syn_idx, rep, tmp_path, syn_true_pvalues): \\n rep_to_plot = 0\\n ttbrs = [0.5, 1,1.5]\\n idx = syn_idx[str(rep_to_plot)]\\n fig, axes = plt.subplots(len(ttbrs), 5, figsize=[30,15])\\n x_3d = syn_fm(\\\"3d\\\")[str(rep_to_plot)][:]\\n x_2d = syn_fm(\\\"2d\\\")[str(rep_to_plot)][:]\\n indices_true= [inds_true for inds_true, x in enumerate(syn_true_pvalues[0].flatten()) if x]\\n\\n for i, ttbr in enumerate(ttbrs):\\n print('Using tbrr={}'.format(ttbr))\\n labels = generate_syn_phenotypes(tower_to_base_ratio=ttbr, quantity=rep)\\n labels_cat = {}\\n for key, l in labels.items():\\n labels_cat[key] = tensorflow.keras.utils.to_categorical((l+1)/2)\\n \\n best_params_montaez['n_snps']= x_3d.shape[1]\\n \\n l_0b=labels_cat[str(rep_to_plot)]\\n\\n model = create_montaez_dense_model(best_params_montaez)\\n y_integers = np.argmax(l_0b[idx.train], axis=1)\\n class_weights = class_weight.compute_class_weight('balanced', np.unique(y_integers), y_integers)\\n d_class_weights = dict(enumerate(class_weights))\\n\\n model.fit(x=x_3d[idx.train], y=l_0b[idx.train], validation_data=(x_3d[idx.test], l_0b[idx.test]), epochs=best_params_montaez['epochs'], class_weight=d_class_weights, callbacks=[ ReduceLROnPlateau(monitor='val_loss', factor=best_params_montaez['factor'], patience=best_params_montaez['patience'], mode='min'),],)\\n\\n model = iutils.keras.graph.model_wo_softmax(model)\\n analyzer = innvestigate.analyzer.LRPAlpha1Beta0(model)\\n weights = analyzer.analyze(x_3d).sum(0)\\n\\n top_indices_sorted, filtered_weights = postprocess_weights(weights, top_k, filter_window_size, p_svm, p_pnorm_filter)\\n\\n complete_pvalues = chi_square(syn_genomic_data[str(rep_to_plot)][:], labels[str(rep_to_plot)])\\n \\n pvalues_filled_deep = np.ones(n_total_snps)\\n pvalues_filled_deep[top_indices_sorted] = complete_pvalues[top_indices_sorted]\\n\\n # Plot RPVT\\n plot_pvalues(complete_pvalues, indices_true, axes[i][0])\\n if i==0:\\n axes[i][0].set_title('RPVT $-log_{10}$(p-values)', fontsize=22)\\n axes[i][0].set_ylabel('$-log_{10}$(p-value)', fontsize=18)\\n plt.setp(axes[i][0].get_yticklabels(), fontsize=16)\\n plt.setp(axes[i][0].get_xticklabels(), fontsize=16)\\n\\n # Plot svm weights \\n clf = LinearSVC(penalty='l2', loss='hinge', C=0.0022, dual=True, tol=1e-3, verbose=0, class_weight='balanced')\\n idx_now, pvalues, raw_weights = combi_method(clf, syn_genomic_data[str(rep_to_plot)][:],x_2d, labels[str(rep_to_plot)], 35, 2, 2, 30)\\n #filtered_svm_weights = postprocess_weights_without_avg(raw_weights, p_svm)\\n pvalues_filled_combi = np.ones(len(complete_pvalues))\\n pvalues_filled_combi[idx_now] = pvalues\\n #svm_weights = toy_classifier.fit(x_2d, labels[str(rep_to_plot)]).coef_\\n axes[i][1].scatter(range(len(np.absolute(raw_weights).sum(1))), 1000*np.absolute(raw_weights).sum(1), marker='.', color='darkblue')\\n axes[i][1].scatter(indices_true,1000*np.absolute(raw_weights).sum(1)[indices_true], color='fuchsia')\\n axes[i][1].set_ylim(0,1000*(np.max(np.absolute(raw_weights).sum(1))+0.001))\\n if i==0:\\n axes[i][1].set_title('Absolute SVM weights * 1000', fontsize=22)\\n plt.setp(axes[i][1].get_yticklabels(), fontsize=16)\\n plt.setp(axes[i][1].get_xticklabels(), fontsize=16)\\n\\t\\t\\t\\n # Plot COMBI\\n plot_pvalues(pvalues_filled_combi, indices_true, axes[i][2])\\n if i==0:\\n axes[i][2].set_title('COMBI $-log_{10}$(p-values)', fontsize=22)\\n if i==2:\\n axes[i][2].set_xlabel('SNP position', fontsize=18)\\n plt.setp(axes[i][2].get_yticklabels(), fontsize=16)\\n plt.setp(axes[i][2].get_xticklabels(), fontsize=16)\\n\\t\\t\\t\\n # Plot LRP relevance scores\\n axes[i][3].scatter(range(len(np.absolute(weights).reshape(-1, 3).sum(1))), np.absolute(weights).reshape(-1, 3).sum(1), marker='.', color='darkblue')\\n axes[i][3].scatter(indices_true,np.absolute(weights).reshape(-1, 3).sum(1)[indices_true], color='fuchsia')\\n #axes[i][1].legend()\\n axes[i][3].set_ylim(0,np.max(np.absolute(weights).reshape(-1, 3).sum(1))+1)\\n if i==0:\\n axes[i][3].set_title('LRP relevance scores', fontsize=22)\\n plt.setp(axes[i][3].get_yticklabels(), fontsize=16)\\n plt.setp(axes[i][3].get_xticklabels(), fontsize=16)\\n\\t\\t\\t\\n # Plot DeepCOMBI\\n plot_pvalues(pvalues_filled_deep, indices_true, axes[i][4])\\n if i==0:\\n axes[i][4].set_title('DeepCOMBI $-log_{10}$(p-value)', fontsize=22)\\n plt.setp(axes[i][4].get_yticklabels(), fontsize=16)\\n plt.setp(axes[i][4].get_xticklabels(), fontsize=16)\\n\\t\\t\\t\\n ## Plot distribution of postprocessed vectors\\n #axes[i][2].plot(postprocessed_weights)\\n #axes[i][2].set_title('Postprocessed relevance')\\n\\n fig.savefig(os.path.join(IMG_DIR, 'manhattan-example-toy-NAR.png'), bbox_inches='tight')\",\n \"def odemisSEM_to_hyperspy(filename='sampledata/cltest.h5') :\\r\\n\\r\\n f=h5.File(filename,'r')\\r\\n shome = 'Acquisition1//ImageData/'\\r\\n x = f[shome + 'Image']\\r\\n cdesc =f['Acquisition1/PhysicalData/ChannelDescription'].value[0].decode('utf-8')\\r\\n #print(cdesc)\\r\\n\\r\\n\\r\\n print('<' + filename + '> original shape :' ,x.shape)\\r\\n # strip unused dimensions and transpose/ reverse index order\\r\\n xx=x[0,0,0,:,:].transpose((1,0))\\r\\n\\r\\n s = hs.signals.Signal2D(xx)\\r\\n print('hyperspy shape :' ,s.data.shape)\\r\\n\\r\\n\\r\\n s.metadata.General.title = 'Odemis: ' + cdesc\\r\\n s.metadata.General.original_filename = filename\\r\\n #s.metadata.General.notes = cltype\\r\\n s.axes_manager[0].name = 'pos x'\\r\\n s.axes_manager[0].scale = f[shome + 'DimensionScaleX'].value * 1e6\\r\\n s.axes_manager[0].offset = f[shome + 'XOffset'].value * 1e6\\r\\n s.axes_manager[0].units = 'um'\\r\\n\\r\\n\\r\\n s.axes_manager[1].name = 'pos y'\\r\\n s.axes_manager[1].scale = f[shome + 'DimensionScaleX'].value * 1e6\\r\\n s.axes_manager[1].offset = f[shome + 'YOffset'].value * 1e6\\r\\n s.axes_manager[1].units = 'um'\\r\\n\\r\\n\\r\\n f.close()\\r\\n return( s )\\r\\n #end odemisSEM_to_hyperspy\\r\\n #######################\\r\",\n \"def plot_ablation_losses():\\n\\n path1 = os.path.join(path_to_here, '../data/landscape_visualizations/DMSO/original/losses00-54.pickle')\\n file = open(path1, 'rb')\\n losses_array_1 = pickle.load(file)\\n losses_array_1 = losses_array_1[1:, :]\\n\\n path2 = os.path.join(path_to_here, '../data/landscape_visualizations/DMSO/D_t/losses00-44.pickle')\\n file = open(path2, 'rb')\\n losses_array_2 = pickle.load(file)\\n losses_array_2 = losses_array_2\\n\\n path3 = os.path.join(path_to_here, '../data/landscape_visualizations/DMSO/D_x_y/losses00-44.pickle')\\n file = open(path3, 'rb')\\n losses_array_3 = pickle.load(file)\\n losses_array_3 = losses_array_3\\n\\n path4 = os.path.join(path_to_here, '../data/landscape_visualizations/DMSO/homog/losses00-76.pickle')\\n file = open(path4, 'rb')\\n losses_array_4 = pickle.load(file)\\n losses_array_4 = losses_array_4[1:, :]\\n\\n paths = [path1, path2, path3, path4]\\n\\n\\n\\n\\n # 'pdf', 'BC', 'pde', 'total', 'norm'\\n fig = plt.figure(figsize = (2.1, 1.5))\\n\\n\\n for path, losses_array, label in zip(paths, [losses_array_1, losses_array_2, losses_array_3, losses_array_4], ['D(x, y, t)', 'D(t)', 'D(x, y)', 'D']):\\n\\n print('shape', losses_array.shape)\\n\\n losses_base = os.path.basename(path)\\n total_losses = losses_array[3, :] # total losses are idx 3 for these runs\\n idxs = []\\n means = []\\n for idx in range(len(total_losses)-200):\\n num_half_hrs = int(losses_base[6:8]) + idx*(int(losses_base[9:11])-int(losses_base[6:8]))/len(total_losses)\\n if num_half_hrs < 55:\\n idxs.append(num_half_hrs)\\n means.append(np.mean(total_losses[idx:idx+200]))\\n\\n\\n plt.scatter([i/2 for i in idxs], np.log10(means), s = 0.1, label = label)\\n\\n plt.ylabel(r'$log_{10}L_{total}$', fontsize = 6, labelpad = 1)\\n plt.xlabel('Hours trained', fontsize = 6, labelpad = 1)\\n plt.tick_params(axis = 'both', labelsize = 6)\\n plt.tight_layout()\\n plt.legend(fontsize = 6)\\n\\n\\n\\n plt.savefig(path_to_here+'/../outputs/ablation.png', dpi = 1200)\",\n \"def _plot_predictions_one_model(\\n top_prediction_dir_name, border_latitudes_deg_n,\\n border_longitudes_deg_e, valid_time_string, title_string, font_size,\\n figure_object, axes_object, smoothing_radius_px=None):\\n\\n prediction_file_name = prediction_io.find_file(\\n top_directory_name=top_prediction_dir_name,\\n valid_date_string=valid_time_string[:10].replace('-', ''),\\n radar_number=None, prefer_zipped=True, allow_other_format=True,\\n raise_error_if_missing=True\\n )\\n\\n print('Reading data from: \\\"{0:s}\\\"...'.format(prediction_file_name))\\n prediction_dict = prediction_io.read_file(prediction_file_name)\\n\\n valid_time_unix_sec = time_conversion.string_to_unix_sec(\\n valid_time_string, TIME_FORMAT\\n )\\n prediction_dict = prediction_io.subset_by_time(\\n prediction_dict=prediction_dict,\\n desired_times_unix_sec=numpy.array([valid_time_unix_sec], dtype=int)\\n )[0]\\n\\n good_lat_indices = numpy.where(numpy.logical_and(\\n prediction_dict[prediction_io.LATITUDES_KEY] >= MIN_PLOT_LATITUDE_DEG_N,\\n prediction_dict[prediction_io.LATITUDES_KEY] <= MAX_PLOT_LATITUDE_DEG_N\\n ))[0]\\n\\n good_lng_indices = numpy.where(numpy.logical_and(\\n prediction_dict[prediction_io.LONGITUDES_KEY] >=\\n MIN_PLOT_LONGITUDE_DEG_E,\\n prediction_dict[prediction_io.LONGITUDES_KEY] <=\\n MAX_PLOT_LONGITUDE_DEG_E\\n ))[0]\\n\\n prediction_dict[prediction_io.LATITUDES_KEY] = (\\n prediction_dict[prediction_io.LATITUDES_KEY][good_lat_indices]\\n )\\n prediction_dict[prediction_io.LONGITUDES_KEY] = (\\n prediction_dict[prediction_io.LONGITUDES_KEY][good_lng_indices]\\n )\\n\\n these_keys = [\\n prediction_io.TARGET_MATRIX_KEY, prediction_io.PROBABILITY_MATRIX_KEY\\n ]\\n for this_key in these_keys:\\n prediction_dict[this_key] = (\\n prediction_dict[this_key][:, good_lat_indices, ...]\\n )\\n prediction_dict[this_key] = (\\n prediction_dict[this_key][:, :, good_lng_indices, ...]\\n )\\n\\n if smoothing_radius_px is not None:\\n prediction_dict = prediction_io.smooth_probabilities(\\n prediction_dict=prediction_dict,\\n smoothing_radius_px=smoothing_radius_px\\n )\\n\\n model_file_name = prediction_dict[prediction_io.MODEL_FILE_KEY]\\n model_metafile_name = neural_net.find_metafile(model_file_name)\\n\\n print('Reading model metadata from: \\\"{0:s}\\\"...'.format(\\n model_metafile_name\\n ))\\n model_metadata_dict = neural_net.read_metafile(model_metafile_name)\\n\\n mask_matrix = model_metadata_dict[neural_net.FULL_MASK_MATRIX_KEY]\\n mask_matrix = mask_matrix[good_lat_indices, :]\\n mask_matrix = mask_matrix[:, good_lng_indices]\\n\\n target_matrix = prediction_dict[prediction_io.TARGET_MATRIX_KEY][0, ...]\\n target_matrix[mask_matrix == False] = 0\\n probability_matrix = prediction_io.get_mean_predictions(prediction_dict)[\\n 0, ...\\n ]\\n\\n latitudes_deg_n = prediction_dict[prediction_io.LATITUDES_KEY]\\n longitudes_deg_e = prediction_dict[prediction_io.LONGITUDES_KEY]\\n\\n plotting_utils.plot_borders(\\n border_latitudes_deg_n=border_latitudes_deg_n,\\n border_longitudes_deg_e=border_longitudes_deg_e,\\n axes_object=axes_object, line_width=BORDER_WIDTH\\n )\\n\\n axes_object.contour(\\n longitudes_deg_e, latitudes_deg_n, mask_matrix, numpy.array([0.999]),\\n colors=(MASK_OUTLINE_COLOUR,), linewidths=MASK_OUTLINE_WIDTH,\\n linestyles='solid'\\n )\\n\\n colour_map_object, colour_norm_object = (\\n prediction_plotting.get_prob_colour_scheme(\\n max_probability=1., make_lowest_prob_grey=False\\n )\\n )\\n\\n prediction_plotting.plot_probabilistic(\\n target_matrix=target_matrix, probability_matrix=probability_matrix,\\n figure_object=figure_object, axes_object=axes_object,\\n min_latitude_deg_n=latitudes_deg_n[0],\\n min_longitude_deg_e=longitudes_deg_e[0],\\n latitude_spacing_deg=numpy.diff(latitudes_deg_n[:2])[0],\\n longitude_spacing_deg=numpy.diff(longitudes_deg_e[:2])[0],\\n colour_map_object=colour_map_object,\\n colour_norm_object=colour_norm_object\\n )\\n\\n plotting_utils.plot_grid_lines(\\n plot_latitudes_deg_n=latitudes_deg_n,\\n plot_longitudes_deg_e=longitudes_deg_e, axes_object=axes_object,\\n parallel_spacing_deg=2., meridian_spacing_deg=2.,\\n font_size=font_size\\n )\\n\\n axes_object.set_title(title_string)\\n\\n return target_matrix, mask_matrix\",\n \"def plot_lollipop(clinvar_path_count):\\n os.chdir(\\\"/Users/Files/nogit/generisk/lollipop/figure\\\")\\n app = '/Users/files/work/bin/lollipops'\\n for i in x.itertuples(False, None):\\n # uid, variants, gn\\n os.system(\\\"%s -domain-labels=fit -U %s -o %s.svg %s\\\" % (app, i[0], i[2], i[1]))\\n # os.system(\\\"rsvg-convert %s.svg -o %s_rsvg.png\\\"%(i[2],i[2]))\\n os.system(\\\"convert -density 500 -units pixelsperinch %s.svg %s.png\\\" % (i[2], i[2]))\",\n \"def model(Prio: NNEmbeddings, plot_emb: bool = False, pickle_file: str = None):\\n # New Predicitons\\n df_metrics = Prio.predict(pickle_file=pickle_file)\\n plot_single(df_metrics)\\n\\n if plot_emb:\\n # TSNE Plots\\n Prio.plot_embeddings()\\n Prio.plot_embeddings_labeled(layer='tests')\\n Prio.plot_embeddings_labeled(layer='files')\\n\\n # UMAP Plots\\n Prio.plot_embeddings(method='UMAP')\\n Prio.plot_embeddings_labeled(layer='tests', method='UMAP')\\n Prio.plot_embeddings_labeled(layer='files', method='UMAP')\",\n \"def odemis_to_hyperspy(filename='sampledata/cltest.h5',specbin=1) :\\r\\n\\r\\n f=h5.File(filename,'r')\\r\\n shome = 'Acquisition2//ImageData/'\\r\\n x = f[shome + 'Image']\\r\\n cdesc =f['Acquisition2/PhysicalData/ChannelDescription'].value[0].decode('utf-8')\\r\\n #print(cdesc)\\r\\n\\r\\n cltype = None\\r\\n if 'Spectrum' in cdesc :\\r\\n cltype = 'spectrum'\\r\\n elif 'CL intensity' in cdesc:\\r\\n cltype = 'panchrom'\\r\\n\\r\\n print('<' + filename + '> original shape :' ,x.shape, cltype)\\r\\n\\r\\n # strip unused dimensions and transpose/ reverse index order\\r\\n if cltype == 'panchrom' :\\r\\n xx=x[0,0,0,:,:].transpose((1,0))\\r\\n # just an image..\\r\\n else :\\r\\n xx=x[:,0,0,:,:].transpose((2,1,0))\\r\\n\\r\\n if cltype == 'spectrum' :\\r\\n #interpolate data to linearize the wavelength scale\\r\\n w = f[shome + 'DimensionScaleC'].value *1e9\\r\\n wx = np.linspace(w.min(),w.max(),w.size)\\r\\n for i in np.arange(xx.shape[0]) :\\r\\n for k in np.arange(xx.shape[1]) :\\r\\n xx[i,k,:] = np.interp(wx,w,xx[i,k,:])\\r\\n\\r\\n wslope = wx[1]-wx[0]\\r\\n woffset = wx.min()\\r\\n #wx = np.arange(w.size)\\r\\n #wslope,woffset=np.polyfit(wx,w,1)\\r\\n s = hs.signals.Signal1D(xx)\\r\\n\\r\\n elif cltype == 'panchrom' :\\r\\n s = hs.signals.Signal2D(xx)\\r\\n else :\\r\\n print('unknown type')\\r\\n\\r\\n print('hyperspy shape :' ,s.data.shape)\\r\\n\\r\\n\\r\\n s.metadata.General.title = 'Odemis: ' + cdesc\\r\\n s.metadata.General.original_filename = filename\\r\\n s.metadata.General.notes = cltype\\r\\n s.axes_manager[0].name = 'pos x'\\r\\n s.axes_manager[0].scale = f[shome + 'DimensionScaleX'].value * 1e6\\r\\n s.axes_manager[0].offset = f[shome + 'XOffset'].value * 1e6\\r\\n s.axes_manager[0].units = 'um'\\r\\n\\r\\n\\r\\n s.axes_manager[1].name = 'pos y'\\r\\n s.axes_manager[1].scale = f[shome + 'DimensionScaleX'].value * 1e6\\r\\n s.axes_manager[1].offset = f[shome + 'YOffset'].value * 1e6\\r\\n s.axes_manager[1].units = 'um'\\r\\n\\r\\n if cltype == 'spectrum' :\\r\\n s.axes_manager[2].name = 'wavelength'\\r\\n s.axes_manager[2].units = 'nm'\\r\\n s.axes_manager[2].offset = woffset\\r\\n s.axes_manager[2].scale = wslope\\r\\n s.metadata.signal_type = 'CL'\\r\\n\\r\\n f.close()\\r\\n if (specbin > 1) and (cltype == 'spectrum'):\\r\\n return( s.rebin(scale=[1,1,specbin]) )\\r\\n else :\\r\\n return( s )\\r\\n #end odemis_to_hyperspy\\r\\n #######################\\r\",\n \"def appelDlr():\\n try:\\n if os.path.getsize('aspifile/dlr.json'):\\n subprocess.call('aspifile/aspidlr.py', shell=True)\\n label['text'] = (\\\"Date: \\\" + textDate.get() +\\\" -- \\\"+ \\\"Nom: \\\" + textName.get() +\\n \\\"\\\\nDouleurs: \\\" + textDlrs.get())\\n except FileNotFoundError as errorgraph7:\\n print('Sorry the Dlrs plot doesn\\\\'t work ! Data missing !', errorgraph7)\\n label['text'] = \\\"Sorry the Dlrs plot doesn\\\\'t work ! Data missing !\\\"\",\n \"def plot_LvsL_multiple(line1='CIV1548',line2='CIII1908',line1range=[1e3,1e8],line2range=[1e0,1e8],\\n outputdir='./',verbose=True):\\n modeldata = nm.load_model('combined',verbose=verbose)\\n\\n if verbose: print(' - Putting together permutations of chosen setups for plotting')\\n infodic = {}\\n infodic['Zgas'] = [False,0.0001,0.006,0.040], True\\n infodic['logUs'] = [False,-1.0,-2.5,-4.0] , False\\n infodic['xid'] = [False,0.1,0.3,0.5] , False\\n infodic['nh'] = [False,10,100,1000,10000] , False\\n infodic['CO'] = [False,0.1,0.38,1.4] , False\\n infodic['Mcut'] = [False,100,300] , False\\n\\n variables = [infodic['Zgas'][0],infodic['logUs'][0],infodic['xid'][0],\\n infodic['nh'][0],infodic['CO'][0],infodic['Mcut'][0]]\\n\\n permutations = list(itertools.product(*variables))\\n permutations_with2false = [sublist for sublist in permutations if sublist.count(False) == 2.]\\n Nplots = len(permutations_with2false)\\n\\n if verbose: print(' - With the restriction Nfalse=2 the setup will results in '+str(Nplots)+\\\\\\n ' plots (if model data allows)')\\n if verbose: print(' - These will be saved to the output directory: '+outputdir)\\n for pp, perm in enumerate(permutations_with2false):\\n Zval = perm[0]\\n Uval = perm[1]\\n Xival = perm[2]\\n Nhval = perm[3]\\n COval = perm[4]\\n Mval = perm[5]\\n\\n plotname = outputdir+'NEOGALmodelgrid_Zgas'+str(Zval).replace('.','p')+\\\\\\n '_logU'+str(Uval).replace('.','p')+\\\\\\n '_xid'+str(Xival).replace('.','p')+\\\\\\n '_nH'+str(Nhval).replace('.','p')+\\\\\\n '_CO'+str(COval).replace('.','p')+\\\\\\n '_Mcut'+str(Mval).replace('.','p')+'.pdf'\\n\\n plotname = plotname.replace('False','Free')\\n\\n if verbose:\\n plotno = pp+1\\n infostr = ' - Generating plot '+str(\\\"%.4d\\\" % plotno)+'/'+str(\\\"%.4d\\\" % Nplots)+': '+plotname.split('/')[-1]+' '\\n sys.stdout.write(\\\"%s\\\\r\\\" % infostr)\\n sys.stdout.flush()\\n\\n if not Zval:\\n logp1 = True\\n else:\\n logp1 = False\\n\\n nm.plot_LvsL(modeldata,line1=line1,line2=line2,logx=True,logy=True,logp1=logp1,logp2=False,verbose=False,\\n Zgas=Zval,logU=Uval,xid=Xival,nh=Nhval,COratio=COval,Mcutoff=Mval,\\n fixxrange=line1range,fixyrange=line2range,plotname=plotname)\\n\\n print('\\\\n ... done')\",\n \"def map_plot(self, iter_no):\\n \\n m = self._m\\n n = self._n\\n plt.figure()\\n label=np.zeros(m*n)\\n self._trained = True\\n mapped = self.map_vects(datanorm)\\n mapped=tuple(map(tuple, mapped))\\n c=Counter(mapped)\\n \\n c= sorted(c.items(), key=itemgetter(1))\\n a=[m*n]\\n for i in range(0,len(c)):\\n x=(((c[i])[0])[0])\\n y=(((c[i])[0])[1])\\n z=((c[i])[1])\\n plt.plot(x, y, 'ro', markersize= z/(2*m*n)) \\n plt.savefig('exoplanet{}.png'.format(iter_no))\\n p=plt.imread('exoplanet{}.png'.format(iter_no))\\n imgs.append(p)\\n plt.show()\\n plt.close()\\n print(c)\\n self._trained = False\",\n \"def main():\\n\\n # Create argument parser\\n parser = ArgumentParser()\\n parser.add_argument('datadir', type=str, help='Directory of LC files')\\n parser.add_argument('metatable', type=str,\\n help='Metatable containing each object, redshift, peak time guess, mwebv, object type')\\n parser.add_argument('--zpt', type=float, default=DEFAULT_ZPT, help='Zero point of LCs')\\n parser.add_argument('--lm', type=float, default=DEFAULT_LIM_MAG, help='Survey limiting magnitude')\\n parser.add_argument('--outdir', type=str, default='./products/',\\n help='Path in which to save the LC data (single file)')\\n args = parser.parse_args()\\n\\n objs, redshifts, obj_types, peaks, ebvs = read_in_meta_table(args.metatable)\\n\\n # Grab all the LC files in the input directory\\n file_names = []\\n for obj in objs:\\n file_name = args.datadir + 'PS1_PS1MD_' + obj + '.snana.dat'\\n file_names.append(file_name)\\n\\n # Create a list of LC objects from the data files\\n lc_list = read_in_LC_files(file_names, objs)\\n\\n # This needs to be redone when retrained\\n # TODO: Need to change this whenever you retrain...\\n filt_dict = {'g': 0, 'r': 1, 'i': 2, 'z': 3}\\n wvs = np.asarray([5460, 6800, 7450, 8700])\\n\\n # Update the LC objects with info from the metatable\\n my_lcs = []\\n for i, my_lc in enumerate(lc_list):\\n my_lc.add_LC_info(zpt=args.zpt, mwebv=ebvs[i],\\n redshift=redshifts[i], lim_mag=args.lm,\\n obj_type=obj_types[i])\\n my_lc.get_abs_mags()\\n my_lc.sort_lc()\\n pmjd = my_lc.find_peak(peaks[i])\\n my_lc.shift_lc(pmjd)\\n my_lc.correct_time_dilation()\\n my_lc.filter_names_to_numbers(filt_dict)\\n my_lc.correct_extinction(wvs)\\n my_lc.cut_lc()\\n my_lc.make_dense_LC(4)\\n my_lcs.append(my_lc)\\n save_lcs(my_lcs, args.outdir)\",\n \"def litchi(args):\\n p = OptionParser(litchi.__doc__)\\n opts, args, iopts = p.set_image_options(args, figsize=\\\"9x6\\\")\\n\\n if len(args) != 4:\\n sys.exit(not p.print_help())\\n\\n datafile, bedfile, slayout, switch = args\\n fig = plt.figure(1, (iopts.w, iopts.h))\\n root = fig.add_axes([0, 0, 1, 1])\\n\\n Synteny(fig, root, datafile, bedfile, slayout, switch=switch)\\n\\n # legend showing the orientation of the genes\\n draw_gene_legend(root, 0.4, 0.7, 0.82)\\n\\n # On the left panel, make a species tree\\n fc = \\\"lightslategrey\\\"\\n\\n coords = {}\\n xs, xp = 0.16, 0.03\\n coords[\\\"lychee\\\"] = (xs, 0.37)\\n coords[\\\"clementine\\\"] = (xs, 0.5)\\n coords[\\\"cacao\\\"] = (xs, 0.6)\\n coords[\\\"strawberry\\\"] = (xs, 0.7)\\n coords[\\\"grape\\\"] = (xs, 0.8)\\n xs -= xp\\n coords[\\\"Sapindales\\\"] = join_nodes(root, coords, \\\"clementine\\\", \\\"lychee\\\", xs)\\n xs -= xp\\n coords[\\\"Rosid-II\\\"] = join_nodes(root, coords, \\\"cacao\\\", \\\"Sapindales\\\", xs)\\n xs -= xp\\n coords[\\\"Rosid\\\"] = join_nodes(root, coords, \\\"strawberry\\\", \\\"Rosid-II\\\", xs)\\n xs -= xp\\n coords[\\\"crown\\\"] = join_nodes(root, coords, \\\"grape\\\", \\\"Rosid\\\", xs, circle=False)\\n\\n # Names of the internal nodes\\n for tag in (\\\"Rosid\\\", \\\"Rosid-II\\\", \\\"Sapindales\\\"):\\n nx, ny = coords[tag]\\n nx, ny = nx - 0.01, ny - 0.02\\n root.text(nx, ny, tag, rotation=90, ha=\\\"right\\\", va=\\\"top\\\", color=fc)\\n\\n root.set_xlim(0, 1)\\n root.set_ylim(0, 1)\\n root.set_axis_off()\\n\\n pf = \\\"litchi\\\"\\n image_name = pf + \\\".\\\" + iopts.format\\n savefig(image_name, dpi=iopts.dpi, iopts=iopts)\",\n \"def convert_yolo_to_ls(input_dir, out_file,\\n to_name='image', from_name='label', out_type=\\\"annotations\\\",\\n image_root_url='/data/local-files/?d=', image_ext='.jpg'):\\n\\n tasks = []\\n logger.info('Reading YOLO notes and categories from %s', input_dir)\\n\\n # build categories=>labels dict\\n notes_file = os.path.join(input_dir, 'classes.txt')\\n with open(notes_file) as f:\\n lines = [line.strip() for line in f.readlines()]\\n categories = {i: line for i, line in enumerate(lines)}\\n logger.info(f'Found {len(categories)} categories')\\n\\n # generate and save labeling config\\n label_config_file = out_file.replace('.json', '') + '.label_config.xml'\\n generate_label_config(categories, to_name, from_name, label_config_file)\\n\\n # labels, one label per image\\n labels_dir = os.path.join(input_dir, 'labels')\\n logger.info('Converting labels from %s', labels_dir)\\n\\n for f in os.listdir(labels_dir):\\n image_file_base = f[0:-4] + image_ext\\n image_file = os.path.join(input_dir, 'images', image_file_base)\\n label_file = os.path.join(labels_dir, f)\\n\\n if not f.endswith('.txt'):\\n continue\\n\\n if not os.path.exists(image_file):\\n logger.error(\\\"Can't convert YOLO to Label Studio JSON without image source: %s\\\", image_file)\\n continue\\n\\n task = {\\n # 'annotations' or 'predictions'\\n out_type: [\\n {\\n \\\"result\\\": [],\\n \\\"ground_truth\\\": False,\\n }\\n ],\\n \\\"data\\\": {\\n \\\"image\\\": os.path.join(image_root_url, image_file_base)\\n }\\n }\\n\\n # read image sizes\\n im = Image.open(image_file)\\n image_width, image_height = im.size\\n\\n with open(label_file) as file:\\n # convert all bounding boxes to Label Studio Results\\n lines = file.readlines()\\n for line in lines:\\n label_id, x, y, width, height = line.split()\\n x, y, width, height = float(x), float(y), float(width), float(height)\\n item = {\\n \\\"id\\\": uuid.uuid4().hex[0:10],\\n \\\"type\\\": \\\"rectanglelabels\\\",\\n \\\"value\\\": {\\n \\\"x\\\": (x-width/2) * 100,\\n \\\"y\\\": (y-height/2) * 100,\\n \\\"width\\\": width * 100,\\n \\\"height\\\": height * 100,\\n \\\"rotation\\\": 0,\\n \\\"rectanglelabels\\\": [\\n categories[int(label_id)]\\n ]\\n },\\n \\\"to_name\\\": to_name,\\n \\\"from_name\\\": from_name,\\n \\\"image_rotation\\\": 0,\\n \\\"original_width\\\": image_width,\\n \\\"original_height\\\": image_height\\n }\\n task['annotations'][0]['result'].append(item)\\n\\n tasks.append(task)\\n\\n if len(tasks) > 0:\\n logger.info('Saving Label Studio JSON to %s', out_file)\\n with open(out_file, 'w') as out:\\n json.dump(tasks, out)\\n\\n print('\\\\n'\\n f' 1. Create a new project in Label Studio\\\\n'\\n f' 2. Use Labeling Config from \\\"{label_config_file}\\\"\\\\n'\\n f' 3. Setup serving for images [e.g. you can use Local Storage (or others):\\\\n'\\n f' https://labelstud.io/guide/storage.html#Local-storage]\\\\n'\\n f' 4. Import \\\"{out_file}\\\" to the project\\\\n')\\n else:\\n logger.error('No labels converted, maybe ')\",\n \"def dline_dSFR(**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n GR = glo.global_results(sim_run=p.sim_run,nGal=p.nGal)\\n \\n marker = 'o'\\n if p.sim_run == p.sim_runs[0]: marker = '^'\\n\\n L_line = getattr(GR,'L_'+p.line+'_sun')#[380:400]#[0:100]\\n SFR = getattr(GR,'SFR')#[380:400]#[0:100]\\n M_star = getattr(GR,'M_star')#[380:400]#[0:100]\\n Zsfr = getattr(GR,'Zsfr')#[380:400]#[0:100]\\n R_gas = getattr(GR,'R2_gas')#[380:400]#[0:100]\\n M_H2 = getattr(GR,'M_H2_R2_gas')#[380:400]#[0:100]\\n\\n SFR = SFR[L_line > 0]\\n M_star = M_star[L_line > 0]\\n Zsfr = Zsfr[L_line > 0]\\n R_gas = R_gas[L_line > 0]\\n M_H2 = M_H2[L_line > 0]\\n L_line = L_line[L_line > 0]\\n print('%i data points ' % (len(L_line)))\\n\\n # Distance from MS\\n dlSFR = aux.distance_from_salim18(GR.M_star,GR.SFR)\\n\\n if p.add:\\n ax = p.ax\\n else:\\n fig,ax = plt.subplots(figsize=(8,6))\\n\\n # Distance from observed relation\\n L_obs,SFR_obs,fit,std = add_line_SFR_obs(p.line,[1e6,1e6],ax,plot=False,select=p.select)\\n ldL_line = np.log10(L_line) - fit.predict(np.log10(SFR.reshape(-1, 1))).flatten()\\n\\n labs = {'_M10':'Mach=10 power-law',\\\\\\n '_arepoPDF_ext':'AREPO parametric PDF with extinction',\\\\\\n '_arepoPDF':'SIGAME v3',\\\\\\n '_arepoPDF_CMZ':'SIGAME v3',\\\\\\n '_arepoPDF_M51':'SIGAME v3'}\\n lab = labs[p.table_ext]\\n\\n\\n ax.text(0.05,0.9,p.line,transform=ax.transAxes,fontsize=13)\\n ax.set_xlabel('log SFR - log SFR$_{MS,Salim+18}$')\\n ax.set_ylabel('log L - log L$_{obs}$(SFR)')\\n if not p.xlim: p.xlim = np.array([-3,3])\\n if not p.ylim: \\n p.ylim = [np.median(ldL_line) - 4,np.median(ldL_line) + 3]\\n # if p.line == '[OI]63': p.ylim = [np.median(ldL_line) - 5,np.median(ldL_line) + 4]\\n # if 'CO' in p.line: p.ylim = [np.median(ldL_line) - 4,np.median(ldL_line) + 4]\\n\\n ax.set_xlim(p.xlim)\\n ax.set_ylim(p.ylim)\\n ax.plot([0,0],ax.get_ylim(),'--k',lw=1)\\n ax.plot(ax.get_xlim(),[0,0],'--k',lw=1)\\n\\n if p.select == 'Sigma_M_H2':\\n Sigma_M_H2 = M_H2/(np.pi*R_gas**2)/1e6 # per pc^-2\\n m = ax.scatter(dlSFR[np.argsort(Sigma_M_H2)],ldL_line[np.argsort(Sigma_M_H2)],marker=marker,s=14,\\\\\\n c=np.log10(Sigma_M_H2[np.argsort(Sigma_M_H2)]),vmin=-2.5,vmax=2.2,label=lab,alpha=0.5,zorder=10)\\n if p.cb:\\n cbar = plt.colorbar(m,ax=ax)\\n cbar.set_label(label=r'log $\\\\Sigma_{H2}$ [M$_{\\\\odot}$/pc$^2$]',size=15)\",\n \"def plot_analysis(opt):\\n LOG.debug(\\\"Plotting GetLLM analysis.\\\")\\n mdl_analysis = opt.subnode in mdl_subnodes\\n\\n ps.set_style(\\\"standard\\\", MANUAL_STYLE)\\n xmin = min(opt.xplot_xmin, opt.yplot_xmin)\\n xmax = max(opt.xplot_xmax, opt.yplot_xmax)\\n\\n gs = gridspec.GridSpec(2, 1, height_ratios=[1, 1])\\n ax_x = plt.subplot(gs[0])\\n ax_y = None\\n ir_pos = None\\n\\n paths = opt.path.split(',')\\n\\n if opt.label == 'None':\\n if mdl_analysis:\\n labels = [\\\"mo_\\\" + opt.path.rsplit('/', 1)[-1], \\\"me_\\\" + opt.path.rsplit('/', 1)[-1]]\\n else:\\n labels = paths\\n else:\\n labels = opt.label.split(',')\\n\\n for idx, path in enumerate(paths):\\n data_x, data_y = get_data(path, opt.mainnode, opt.subnode)\\n plot_data(ax_x, data_x, labels, idx, opt.change_marker)\\n\\n if ir_pos is None:\\n ir_pos = get_irpos(data_x, opt.accel)\\n\\n if data_y is not None:\\n if ax_y is None:\\n ax_x.axes.get_xaxis().set_visible(False)\\n ax_y = plt.subplot(gs[1])\\n plot_data(ax_y, data_y, labels, idx, opt.change_marker)\\n\\n ax_x.set_xlim(xmin, xmax)\\n ax_x.set_ylim(opt.xplot_ymin, opt.xplot_ymax)\\n set_yaxis_label(ax_x, 'x', opt.subnode)\\n\\n if ax_y is not None:\\n ax_y.set_xlim(xmin, xmax)\\n ax_y.set_ylim(opt.yplot_ymin, opt.yplot_ymax)\\n set_yaxis_label(ax_y, 'y', opt.subnode)\\n ps.set_xaxis_label(ax_y)\\n if ir_pos:\\n ps.show_ir(ir_pos, ax_y, mode='outside')\\n ps.show_ir(ir_pos, ax_x, mode='lines')\\n else:\\n ax_x.axes.get_xaxis().set_visible(True)\\n ps.set_xaxis_label(ax_x)\\n if ir_pos:\\n ps.show_ir(ir_pos, ax_x, mode='outside')\\n\\n if int(opt.legendh) > 12:\\n show_legend(ax_x, int(opt.legendx), int(opt.legendy))\\n return gs\",\n \"def SLTrace(self,NSL=12,Pts=[]):\\n \\n #Grid edge\\n Bound_vert=[(0,0),(1,0),(1,1),(0,1),(0,0)]\\n Bound_vert_phy=[]\\n for i in range(len(Bound_vert)):\\n Bound_vert_phy.append(self.Pts2Physic(Bound_vert[i]))\\n \\n #Streamline\\n if(len(Pts)==0): #if the initial Pts are not provided\\n Pts=PointOnUnitSquare(NSL,Endpoint=False)\\n else:\\n NSL=len(Pts)\\n \\n SL=[]\\n SL_phy=[]\\n TOF_phy=[]\\n \\n for i in range(len(Pts)):\\n temp=self.Trace1SL(Pts[i])\\n SL.append(temp[2])\\n SL_phy.append(temp[3])\\n TOF_phy.append(temp[5])\\n \\n #SL_phy=self.RotateSL(SL_phy)\\n #SL_phy=self.TranslateSL(SL_phy)\\n \\n fig, axs = plt.subplots(ncols=2)\\n \\n ax=axs[0]\\n ax.plot(*np.asarray(Bound_vert).T,lw=3,color='red')\\n for i in range(len(Pts)):\\n ax.plot(*np.asarray(SL[i]).T,lw=1,marker='o',markersize=1,color='blue')\\n ax.set_ylim(bottom=0)\\n ax.set_aspect('equal')\\n ax.set_title(r'Transformed Space ($\\\\alpha,\\\\beta$)')\\n \\n ax=axs[1]\\n ax.plot(*np.asarray(Bound_vert_phy).T,lw=3,color='red')\\n for i in range(len(Pts)):\\n ax.plot(*np.asarray(SL_phy[i]).T,lw=1,marker='o',markersize=1,color='blue')\\n ax.set_ylim(bottom=0)\\n ax.set_aspect('equal')\\n ax.set_title(r'Physical Space ($x,y$)')\\n\\n fig.tight_layout()\\n plt.show()\\n return SL_phy,TOF_phy\",\n \"def plot_stream(x,y,gvx,gvy,oargs,outfile):\\r\\n\\t\\r\\n\\tme = \\\"LE_Plot.plot_stream: \\\"\\r\\n\\t\\r\\n\\t## Expand out parameters\\r\\n\\tb,X,xmax,ymax,BW,smooth = oargs\\r\\n\\tgv = np.sqrt(gvx*gvx+gvy*gvy)\\r\\n\\t\\t\\r\\n\\tshowplot = False\\r\\n\\r\\n\\t## Smooth data\\r\\n\\tif smooth is not 0.0:\\r\\n\\t\\tgvy = gaussian_filter(gvy, smooth)\\r\\n\\t\\tgvx = gaussian_filter(gvx, smooth)\\r\\n\\t\\tgv = gaussian_filter(gv, smooth)\\r\\n\\toutfile += \\\"_sm\\\"+str(smooth)\\r\\n\\t\\t\\r\\n\\t## --------------------------------------------------------------------\\t\\r\\n\\t\\r\\n\\t## Plotting\\r\\n\\t\\r\\n\\tt0 = time.time()\\r\\n\\tfs = 25\\r\\n\\t\\r\\n\\tfig = plt.figure(facecolor=\\\"white\\\")\\r\\n\\tfig.suptitle(outfile)\\r\\n\\t\\r\\n\\t## Add subplot with exact solution\\r\\n\\tif not BW:\\r\\n\\t\\tfrom LE_ExactHO import main as plot_exact\\r\\n\\t\\tax1 = fig.add_subplot(121,aspect=\\\"auto\\\")\\r\\n\\t\\tax2 = fig.add_subplot(122,aspect=\\\"auto\\\",sharey=ax1)\\r\\n\\t\\tplot_exact((ax2,xmax,ymax,b,False))\\r\\n\\t\\tfig.tight_layout();fig.subplots_adjust(top=0.93)\\r\\n\\t\\tprint me+\\\"Plotting exact\\\",round(time.time()-t0,1),\\\"seconds\\\"\\r\\n\\telse:\\r\\n\\t\\tax1 = fig.add_subplot(111)\\r\\n\\t\\r\\n\\t## Accoutrements\\t\\r\\n\\tax1.set_xlim([-xmax,xmax]);\\tax1.set_ylim([-ymax,ymax])\\r\\n\\tax1.set_xlabel(\\\"$x$\\\",fontsize=fs);ax1.set_ylabel(\\\"$\\\\eta$\\\",fontsize=fs)\\r\\n\\t## Plot wall positions if BW; plot separatrix if HO\\r\\n\\tif BW:\\tplot_walls(ax1, X, xmax,ymax,2)\\r\\n\\telse:\\tplot_separatrix(ax1, b, xmax, ymax, 2)\\r\\n\\t\\r\\n\\t## Line widths\\r\\n\\tlw1 = 3.0*gv/gv.max()\\r\\n\\t\\r\\n\\tt0=time.time()\\r\\n\\t## Plot absolute speed contour and streamplot\\r\\n\\t## NOTE fudge (-) to force agreement with exact\\r\\n\\t# ax1.contourf(xi,yi,gv, 4, alpha=0.4)\\r\\n\\tax1.streamplot(-x,y, -gvx,gvy, arrowsize=1.8, arrowstyle=\\\"->\\\", linewidth=lw1, minlength=xmax/20)\\r\\n\\t\\t\\t\\r\\n\\tprint me+\\\"Plotting data \\\",round(time.time()-t0,1),\\\"seconds\\\"; t0=time.time()\\r\\n\\t\\t\\r\\n\\t## Output\\r\\n\\tfig.savefig(outfile+\\\".png\\\",facecolor=fig.get_facecolor(), edgecolor=\\\"none\\\")\\r\\n\\tprint me+\\\"Plot saved\\\",outfile+\\\".png\\\"\\r\\n\\tif showplot:\\tplt.show()\\r\\n\\r\\n\\tplt.close()\\r\\n\\t\\t\\t\\r\\n\\treturn\",\n \"def load_nir_alcohol():\\n\\n # loading matlab data set\\n raw_data = sio.loadmat(__data_set_path)\\n\\n # ----------------\\n\\n # getting all variable/features labels\\n var_labels_all = raw_data['var_labels_all'].tolist()\\n\\n # getting spectra labels\\n var_labels_spectra = [int(l) for l in var_labels_all[3:]]\\n\\n # getting properties labels\\n var_labels_properties = var_labels_all[:3]\\n\\n # ----------------\\n\\n # getting all data (train-new-msc)\\n data_all = raw_data['data_all']\\n\\n # getting spectra data\\n data_spectra = data_all[:, 3:]\\n\\n # getting properties data\\n data_properties = data_all[:, :3]\\n\\n # ----------------\\n\\n obj_labels_train = raw_data['obj_labels_train'].tolist()\\n data_train = data_spectra[:27, :]\\n other_cols_train = {p_name: p_data for p_name, p_data in zip(var_labels_properties, data_properties[:27, :].T)}\\n\\n ds_train = utils.build_data_set(data_train, obj_labels_train, var_labels_spectra, extra_cols=other_cols_train)\\n\\n # ----------------\\n\\n obj_labels_new = raw_data['obj_labels_new'].tolist()\\n data_new = data_spectra[27:40, :]\\n other_cols_new = {p_name: p_data for p_name, p_data in zip(var_labels_properties, data_properties[27:40, :].T)}\\n\\n ds_new = utils.build_data_set(data_new, obj_labels_new, var_labels_spectra, extra_cols=other_cols_new)\\n\\n # ----------------\\n\\n obj_labels_msc = raw_data['obj_labels_mscorrected'].tolist()\\n data_msc = data_spectra[40:, :]\\n other_cols_msc = {p_name: p_data for p_name, p_data in zip(var_labels_properties, data_properties[40:, :].T)}\\n\\n ds_msc = utils.build_data_set(data_msc, obj_labels_msc, var_labels_spectra, extra_cols=other_cols_msc)\\n\\n # ----------------\\n\\n # training/validation data sets and labels\\n data_sets = [ds_train, ds_new, ds_msc]\\n labels = ['train', 'new', 'msc']\\n\\n # actually building the joint data set\\n ds = pd.concat(data_sets, keys=labels)\\n\\n # returning the final data set\\n return ds\",\n \"def plot_loss_landscape(\\n path: str,\\n **plot_kwargs,\\n):\\n a = np.load(path)\\n n = a['train_acc'].shape[0]\\n\\n plt.subplot(221)\\n for i in range(n):\\n plt.plot(a['ts'], a['train_acc'][i, :], \\\".-\\\",\\n **plot_kwargs)\\n plt.xlabel('Perturbation')\\n plt.ylabel('Train Accuracy')\\n\\n plt.subplot(222)\\n for i in range(n):\\n plt.plot(a['ts'], a['test_acc'][i, :], \\\".-\\\", **plot_kwargs)\\n plt.xlabel('Perturbation')\\n plt.ylabel('Test Accuracy')\\n\\n plt.subplot(223)\\n for i in range(n):\\n plt.plot(a['ts'], a['train_loss'][i, :], \\\".-\\\", **plot_kwargs)\\n plt.xlabel('Perturbation')\\n plt.ylabel('Train Loss')\\n\\n plt.subplot(224)\\n for i in range(n):\\n plt.plot(a['ts'], a['test_loss'][i, :], \\\".-\\\", label='$\\\\lambda = $' + str(a['eigvals'][a['idx'][i]]),\\n **plot_kwargs)\\n plt.xlabel('Perturbation')\\n plt.ylabel('Test Loss')\\n\\n plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\",\n \"def to_neptune(self, **kwargs) -> 'PlotLosses':\\n self.outputs.append(outputs.NeptuneLogger(**kwargs))\\n return self\",\n \"def make_llr_plots(self):\\n import matplotlib.pyplot as plt\\n plt.rcParams['text.usetex'] = True\\n\\n outdir = os.path.join(self.outdir, 'LLRDistributions')\\n mkdir(outdir)\\n\\n for injkey in self.values.keys():\\n\\n data = self.values[injkey]\\n metric_type = data['h0_fit_to_h0_fid']['metric_val']['type']\\n metric_type_pretty = self.tex_axis_label(metric_type)\\n h0_fid_metric = self.fid_values[injkey][\\n 'h0_fit_to_%s'%self.labels.dict['data']\\n ][\\n 'metric_val'\\n ]\\n h1_fid_metric = self.fid_values[injkey][\\n 'h1_fit_to_%s'%self.labels.dict['data']\\n ][\\n 'metric_val'\\n ]\\n\\n h0_fit_to_h0_fid_metrics = np.array(\\n data['h0_fit_to_h0_fid']['metric_val']['vals']\\n )\\n h1_fit_to_h0_fid_metrics = np.array(\\n data['h1_fit_to_h0_fid']['metric_val']['vals']\\n )\\n h0_fit_to_h1_fid_metrics = np.array(\\n data['h0_fit_to_h1_fid']['metric_val']['vals']\\n )\\n h1_fit_to_h1_fid_metrics = np.array(\\n data['h1_fit_to_h1_fid']['metric_val']['vals']\\n )\\n\\n # In the case of likelihood, the maximum metric is the better fit.\\n # With chi2 metrics the opposite is true, and so we must multiply\\n # everything by -1 in order to apply the same treatment.\\n if 'chi2' in metric_type:\\n logging.info('Converting chi2 metric to likelihood equivalent.')\\n h0_fid_metric *= -1\\n h1_fid_metric *= -1\\n h0_fit_to_h0_fid_metrics *= -1\\n h1_fit_to_h0_fid_metrics *= -1\\n h0_fit_to_h1_fid_metrics *= -1\\n h1_fit_to_h1_fid_metrics *= -1\\n\\n if h1_fid_metric < h0_fid_metric:\\n bestfit = 'h0'\\n altfit = 'h1'\\n critical_value = h0_fid_metric-h1_fid_metric\\n else:\\n bestfit = 'h1'\\n altfit = 'h0'\\n critical_value = h1_fid_metric-h0_fid_metric\\n\\n if bestfit == 'h0':\\n llrbest = h0_fit_to_h0_fid_metrics - h1_fit_to_h0_fid_metrics\\n llralt = h0_fit_to_h1_fid_metrics - h1_fit_to_h1_fid_metrics\\n else:\\n llrbest = h1_fit_to_h1_fid_metrics - h0_fit_to_h1_fid_metrics\\n llralt = h1_fit_to_h0_fid_metrics - h0_fit_to_h0_fid_metrics\\n\\n minllr = min(min(llrbest), min(llralt))\\n maxllr = max(max(llrbest), max(llralt))\\n rangellr = maxllr - minllr\\n # Special case for low numbers of trials. Here, the plot\\n # can't really be interpreted but the numbers printed on\\n # it can still be useful, so we need to make something.\\n if self.num_trials < 100:\\n binning = np.linspace(minllr - 0.1*rangellr,\\n maxllr + 0.1*rangellr,\\n 10)\\n elif self.num_trials < 2000:\\n binning = np.linspace(minllr - 0.1*rangellr,\\n maxllr + 0.1*rangellr,\\n int(self.num_trials/40))\\n else:\\n binning = np.linspace(minllr - 0.1*rangellr,\\n maxllr + 0.1*rangellr,\\n 50)\\n binwidth = binning[1]-binning[0]\\n\\n llrbesthist, llrbestbinedges = np.histogram(llrbest, bins=binning)\\n llralthist, llraltbinedges = np.histogram(llralt, bins=binning)\\n\\n llrhistmax = max(max(llrbesthist), max(llralthist))\\n\\n best_median = np.median(llrbest)\\n\\n if self.labels.dict['data_name'] == '':\\n inj_name = \\\"data\\\"\\n else:\\n inj_name = \\\"true %s\\\"%self.tex_axis_label(\\n self.labels.dict['data_name']\\n )\\n best_name = self.labels.dict['%s_name'%bestfit]\\n alt_name = self.labels.dict['%s_name'%altfit]\\n\\n # Calculate p values\\n ## First for the preferred hypothesis based on the fiducial fit\\n crit_p_value, unc_crit_p_value = self.calc_p_value(\\n llrdist=llralt,\\n critical_value=critical_value\\n )\\n ## Then for the alternate hypothesis based on the fiducial fit\\n alt_crit_p_value, alt_unc_crit_p_value = self.calc_p_value(\\n llrdist=llrbest,\\n critical_value=critical_value\\n )\\n ## Combine these to give a cls value based on arXiv:1407.5052\\n cls_value = (1 - alt_crit_p_value) / (1 - crit_p_value)\\n unc_cls_value = cls_value * np.sqrt(\\n np.power(alt_unc_crit_p_value/alt_crit_p_value, 2.0) + \\\\\\n np.power(unc_crit_p_value/crit_p_value, 2.0)\\n )\\n ## Then for the preferred hypothesis based on the median. That\\n ## is, the case of a median experiment from the distribution\\n ## under the preferred hypothesis.\\n med_p_value, unc_med_p_value, median_error = self.calc_p_value(\\n llrdist=llralt,\\n critical_value=best_median,\\n median_p_value=True,\\n llrbest=llrbest\\n )\\n\\n if metric_type == 'llh':\\n plot_title = (r\\\"\\\\begin{center}\\\"\\\\\\n +\\\"%s %s Event Selection \\\"%(self.detector,\\n self.selection)\\\\\\n +r\\\"\\\\\\\\\\\"+\\\" llr Distributions for %s (%i trials)\\\"%(\\n inj_name, self.num_trials)\\\\\\n +r\\\"\\\\end{center}\\\")\\n\\n else:\\n plot_title = (r\\\"\\\\begin{center}\\\"\\\\\\n +\\\"%s %s Event Selection \\\"%(self.detector,\\n self.selection)\\\\\\n +r\\\"\\\\\\\\\\\"+\\\" %s \\\\\\\"llr\\\\\\\" Distributions for \\\"\\n %(metric_type_pretty)\\\\\\n +\\\"%s (%i trials)\\\"%(inj_name,\\n self.num_trials)\\\\\\n +r\\\"\\\\end{center}\\\")\\n\\n # Factor with which to make everything visible\\n plot_scaling_factor = 1.55\\n\\n # In case of median plot, draw both best and alt histograms\\n ## Set up the labels for the histograms\\n llr_labels = [\\n r\\\"%s Pseudo-Experiments - \\\"%(self.tex_axis_label(best_name)) + \\\\\\n r\\\"$\\\\log\\\\left[\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\"%(best_name) + \\\\\\n r\\\"\\\\right)/\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\\right)\\\\right]$\\\"%(\\n alt_name),\\n r\\\"%s Pseudo-Experiments - \\\"%(self.tex_axis_label(alt_name)) + \\\\\\n r\\\"$\\\\log\\\\left[\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\"%(best_name) + \\\\\\n r\\\"\\\\right)/\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\\right)\\\\right]$\\\"%(\\n alt_name)\\n ]\\n self.plot_llr_histograms(\\n llrarrays=[llrbest, llralt],\\n llrhistmax=llrhistmax,\\n binning=binning,\\n colors=['r', 'b'],\\n labels=llr_labels,\\n best_name=best_name,\\n alt_name=alt_name,\\n critical_value=best_median,\\n critical_label=r\\\"%s Median = $%.4f\\\\pm%.4f$\\\"%(\\n self.tex_axis_label(best_name),\\n best_median,\\n median_error),\\n critical_height=float(max(llrbesthist))/float(\\n plot_scaling_factor*llrhistmax),\\n llrhist=llralthist\\n )\\n plt.legend(loc='upper left')\\n plt.title(plot_title)\\n # Write the p-value on the plot\\n plt.figtext(\\n 0.15,\\n 0.66,\\n r\\\"$\\\\mathrm{p}\\\\left(\\\\mathcal{H}_{%s}\\\\right) = %.4f\\\\pm%.4f$\\\"%(\\n best_name, med_p_value, unc_med_p_value),\\n color='k',\\n size='xx-large'\\n )\\n self.save_plot(\\n outdir=outdir,\\n end='%s_llrDistribution_median_%i_Trials'%(\\n metric_type, self.num_trials)\\n )\\n # Add the extra points if they exist\\n if self.extra_points is not None:\\n plt.legend(loc='upper left', fontsize=11)\\n curleg = plt.gca().get_legend()\\n linelist = self.add_extra_points(\\n ymax=float(max(llrbesthist))/float(\\n plot_scaling_factor*llrhistmax)\\n )\\n handles, labels = plt.gca().get_legend_handles_labels()\\n newhandles = []\\n for l, h in zip(labels, handles):\\n if l in linelist:\\n newhandles.append(h)\\n newleg = plt.legend(\\n handles=newhandles,\\n loc='upper right',\\n fontsize=11\\n )\\n plt.gca().add_artist(newleg)\\n plt.gca().add_artist(curleg)\\n self.save_plot(\\n outdir=outdir,\\n end='%s_llrDistribution_median_w_extra_points_%i_Trials'%(\\n metric_type, self.num_trials)\\n )\\n plt.close()\\n\\n # Make some debugging plots\\n ## Set up the labels for the histograms\\n llr_labels = [\\n r\\\"%s Pseudo-Experiments - \\\"%(self.tex_axis_label(best_name)) + \\\\\\n r\\\"$\\\\log\\\\left[\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\"%(best_name) + \\\\\\n r\\\"\\\\right)/\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\\right)\\\\right]$\\\"%(\\n alt_name),\\n r\\\"%s Pseudo-Experiments - \\\"%(self.tex_axis_label(alt_name)) + \\\\\\n r\\\"$\\\\log\\\\left[\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\"%(best_name) + \\\\\\n r\\\"\\\\right)/\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\\right)\\\\right]$\\\"%(\\n alt_name)\\n ]\\n self.plot_llr_histograms(\\n llrarrays=[llrbest, llralt],\\n llrhistmax=llrhistmax,\\n binning=binning,\\n colors=['r', 'b'],\\n labels=llr_labels,\\n best_name=best_name,\\n alt_name=alt_name,\\n critical_value=best_median,\\n critical_label=r\\\"%s Median = $%.4f\\\\pm%.4f$\\\"%(\\n self.tex_axis_label(best_name),\\n best_median,\\n median_error),\\n critical_height=float(max(llrbesthist))/float(\\n plot_scaling_factor*llrhistmax),\\n llrhist=None\\n )\\n plt.legend(loc='upper left')\\n plt.title(plot_title)\\n self.save_plot(\\n outdir=outdir,\\n end='%s_llrDistribution_median_both_fit_dists_%i_Trials'%(\\n metric_type, self.num_trials)\\n )\\n plt.close()\\n ## Set up the labels for the histograms\\n llr_labels = [\\n r\\\"%s Pseudo-Experiments - \\\"%(self.tex_axis_label(best_name)) + \\\\\\n r\\\"$\\\\log\\\\left[\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\" + \\\\\\n r\\\"\\\\right)/\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\\right)\\\\right]$\\\"%(\\n alt_name),\\n ]\\n self.plot_llr_histograms(\\n llrarrays=[llrbest],\\n llrhistmax=llrhistmax,\\n binning=binning,\\n colors=['r'],\\n labels=llr_labels,\\n best_name=best_name,\\n alt_name=alt_name,\\n critical_value=None,\\n critical_label=None,\\n critical_height=None,\\n llrhist=None\\n )\\n plt.legend(loc='upper left')\\n plt.title(plot_title)\\n self.save_plot(\\n outdir=outdir,\\n end='%s_llrDistribution_best_fit_dist_%i_Trials'%(\\n metric_type, self.num_trials)\\n )\\n plt.close()\\n ## Set up the labels for the histograms\\n llr_labels = [\\n r\\\"%s Pseudo-Experiments - \\\"%(self.tex_axis_label(best_name)) + \\\\\\n r\\\"$\\\\log\\\\left[\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\"%(best_name) + \\\\\\n r\\\"\\\\right)/\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\\right)\\\\right]$\\\"%(\\n alt_name),\\n ]\\n self.plot_llr_histograms(\\n llrarrays=[llrbest],\\n llrhistmax=llrhistmax,\\n binning=binning,\\n colors=['r'],\\n labels=llr_labels,\\n best_name=best_name,\\n alt_name=alt_name,\\n critical_value=best_median,\\n critical_label=r\\\"%s Median = $%.4f\\\\pm%.4f$\\\"%(\\n self.tex_axis_label(best_name),\\n best_median,\\n median_error),\\n critical_height=float(max(llrbesthist))/float(\\n plot_scaling_factor*llrhistmax),\\n llrhist=None\\n )\\n plt.legend(loc='upper left')\\n plt.title(plot_title)\\n self.save_plot(\\n outdir=outdir,\\n end='%s_llrDistribution_median_best_fit_dist_%i_Trials'%(\\n metric_type, self.num_trials)\\n )\\n plt.close()\\n ## Set up the labels for the histograms\\n llr_labels = [\\n r\\\"%s Pseudo-Experiments - \\\"%(self.tex_axis_label(alt_name)) + \\\\\\n r\\\"$\\\\log\\\\left[\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\"%(best_name) + \\\\\\n r\\\"\\\\right)/\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\\right)\\\\right]$\\\"%(\\n alt_name)\\n ]\\n self.plot_llr_histograms(\\n llrarrays=[llralt],\\n llrhistmax=llrhistmax,\\n binning=binning,\\n colors=['b'],\\n labels=llr_labels,\\n best_name=best_name,\\n alt_name=alt_name,\\n critical_value=None,\\n critical_label=None,\\n critical_height=None,\\n llrhist=None\\n )\\n plt.legend(loc='upper left')\\n plt.title(plot_title)\\n self.save_plot(\\n outdir=outdir,\\n end='%s_llrDistribution_alt_fit_dist_%i_Trials'%(\\n metric_type, self.num_trials)\\n )\\n plt.close()\\n ## Set up the labels for the histograms\\n llr_labels = [\\n r\\\"%s Pseudo-Experiments - \\\"%(self.tex_axis_label(alt_name)) + \\\\\\n r\\\"$\\\\log\\\\left[\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\" + \\\\\\n r\\\"\\\\right)/\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\\right)\\\\right]$\\\"%(\\n alt_name)\\n ]\\n self.plot_llr_histograms(\\n llrarrays=[llralt],\\n llrhistmax=llrhistmax,\\n binning=binning,\\n colors=['b'],\\n labels=llr_labels,\\n best_name=best_name,\\n alt_name=alt_name,\\n critical_value=best_median,\\n critical_label=r\\\"%s Median = $%.4f\\\\pm%.4f$\\\"%(\\n self.tex_axis_label(best_name),\\n best_median,\\n median_error),\\n critical_height=float(max(llrbesthist))/float(\\n plot_scaling_factor*llrhistmax),\\n llrhist=llralthist\\n )\\n plt.legend(loc='upper left')\\n plt.title(plot_title)\\n # Write the p-value on the plot\\n plt.figtext(\\n 0.15,\\n 0.66,\\n r\\\"$\\\\mathrm{p}\\\\left(\\\\mathcal{H}_{%s}\\\\right) = %.4f\\\\pm%.4f$\\\"%(\\n best_name, med_p_value, unc_med_p_value),\\n color='k',\\n size='xx-large'\\n )\\n self.save_plot(\\n outdir=outdir,\\n end='%s_llrDistribution_median_alt_fit_dist_%i_Trials'%(\\n metric_type, self.num_trials)\\n )\\n plt.close()\\n\\n # In case of critical plot, draw just alt histograms\\n ## Set up the label for the histogram\\n llr_labels = [\\n r\\\"%s Pseudo-Experiments - \\\"%(self.tex_axis_label(alt_name)) + \\\\\\n r\\\"$\\\\log\\\\left[\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\"%(best_name) + \\\\\\n r\\\"\\\\right)/\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\\right)\\\\right]$\\\"%(\\n alt_name)\\n ]\\n self.plot_llr_histograms(\\n llrarrays=[llralt],\\n llrhistmax=llrhistmax,\\n binning=binning,\\n colors=['b'],\\n labels=llr_labels,\\n best_name=best_name,\\n alt_name=alt_name,\\n critical_value=critical_value,\\n critical_label=r\\\"Critical Value = %.4f\\\"%(critical_value),\\n critical_height=float(max(llrbesthist))/float(\\n plot_scaling_factor*llrhistmax),\\n llrhist=llralthist\\n )\\n plt.legend(loc='upper left')\\n plt.title(plot_title)\\n # Write the p-value on the plot\\n plt.figtext(\\n 0.15,\\n 0.70,\\n r\\\"$\\\\mathrm{p}\\\\left(\\\\mathcal{H}_{%s}\\\\right) = %.4f\\\\pm%.4f$\\\"%(\\n best_name, crit_p_value, unc_crit_p_value),\\n color='k',\\n size='xx-large'\\n )\\n self.save_plot(\\n outdir=outdir,\\n end='%s_llrDistribution_critical_%i_Trials'%(\\n metric_type, self.num_trials)\\n )\\n plt.close()\\n\\n # Make a second critical plot for the alt hypothesis, so we draw the\\n # preferred hypothesis\\n ## Set up the label for the histogram\\n llr_labels = [\\n r\\\"%s Pseudo-Experiments - \\\"%(self.tex_axis_label(best_name)) + \\\\\\n r\\\"$\\\\log\\\\left[\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\"%(best_name) + \\\\\\n r\\\"\\\\right)/\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\\right)\\\\right]$\\\"%(\\n alt_name)\\n ]\\n self.plot_llr_histograms(\\n llrarrays=[llrbest],\\n llrhistmax=llrhistmax,\\n binning=binning,\\n colors=['r'],\\n labels=llr_labels,\\n best_name=best_name,\\n alt_name=alt_name,\\n critical_value=critical_value,\\n critical_label=r\\\"Critical Value = %.4f\\\"%(critical_value),\\n critical_height=float(max(llrbesthist))/float(\\n plot_scaling_factor*llrhistmax),\\n llrhist=llrbesthist\\n )\\n plt.legend(loc='upper left')\\n plt.title(plot_title)\\n # Write the p-value on the plot\\n plt.figtext(\\n 0.15,\\n 0.70,\\n r\\\"$\\\\mathrm{p}\\\\left(\\\\mathcal{H}_{%s}\\\\right) = %.4f\\\\pm%.4f$\\\"%(\\n alt_name, alt_crit_p_value, alt_unc_crit_p_value),\\n color='k',\\n size='xx-large'\\n )\\n self.save_plot(\\n outdir=outdir,\\n end='%s_llrDistribution_critical_alt_%i_Trials'%(\\n metric_type, self.num_trials)\\n )\\n plt.close()\\n\\n # Lastly, show both exclusion regions and then the joined cls value\\n ## Set up the labels for the histograms\\n llr_labels = [\\n r\\\"%s Pseudo-Experiments - \\\"%(self.tex_axis_label(best_name)) + \\\\\\n r\\\"$\\\\log\\\\left[\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\"%(best_name) + \\\\\\n r\\\"\\\\right)/\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\\right)\\\\right]$\\\"%(\\n alt_name),\\n r\\\"%s Pseudo-Experiments - \\\"%(self.tex_axis_label(alt_name)) + \\\\\\n r\\\"$\\\\log\\\\left[\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\"%(best_name) + \\\\\\n r\\\"\\\\right)/\\\\mathcal{L}\\\\left(\\\\mathcal{H}_{%s}\\\\right)\\\\right]$\\\"%(\\n alt_name)\\n ]\\n self.plot_llr_histograms(\\n llrarrays=[llrbest, llralt],\\n llrhistmax=llrhistmax,\\n binning=binning,\\n colors=['r', 'b'],\\n labels=llr_labels,\\n best_name=best_name,\\n alt_name=alt_name,\\n critical_value=critical_value,\\n critical_label=r\\\"Critical Value = %.4f\\\"%(critical_value),\\n critical_height=float(max(llrbesthist))/float(\\n plot_scaling_factor*llrhistmax),\\n llrhist=[llrbesthist, llralthist],\\n cls=True,\\n )\\n plt.legend(loc='upper left')\\n plt.title(plot_title)\\n # Write the p-values on the plot\\n plt.figtext(\\n 0.50,\\n 0.66,\\n r\\\"$\\\\mathrm{CL}_{s}\\\\left(\\\\mathcal{H}_{%s}\\\"%(best_name) + \\\\\\n r\\\"\\\\right)= %.4f\\\\pm%.4f$\\\"%(cls_value, unc_cls_value),\\n horizontalalignment='center',\\n color='k',\\n size='xx-large'\\n )\\n plt.figtext(\\n 0.12,\\n 0.55,\\n r\\\"$\\\\mathrm{p}\\\\left(\\\\mathcal{H}_{%s}\\\\right) = %.2f\\\\pm%.2f$\\\"%(\\n alt_name, alt_crit_p_value, alt_unc_crit_p_value),\\n bbox=dict(facecolor='none', edgecolor='red', boxstyle='round'),\\n horizontalalignment='left',\\n color='k',\\n size='x-large'\\n )\\n plt.figtext(\\n 0.88,\\n 0.55,\\n r\\\"$\\\\mathrm{p}\\\\left(\\\\mathcal{H}_{%s}\\\\right) = %.2f\\\\pm%.2f$\\\"%(\\n best_name, crit_p_value, unc_crit_p_value),\\n horizontalalignment='right',\\n bbox=dict(facecolor='none', edgecolor='blue', boxstyle='round'),\\n color='k',\\n size='x-large'\\n )\\n self.save_plot(\\n outdir=outdir,\\n end='%s_llrDistribution_CLs_%i_Trials'%(\\n metric_type, self.num_trials)\\n )\\n plt.close()\",\n \"def plot_raft_map(data, img, TITLE, OUTDIR, vmin=None, vmax=None):\\n\\n map = np.zeros((6, 24))\\n for i, fli in enumerate(img):\\n x = (fli.dev_index / 3) * 2 # [0, 2, 4]\\n y = (fli.dev_index % 3) * 8 # [0, 8, 16]\\n for j in range(16):\\n xx = x + j / 8 # [0, 1,..., 5]\\n yy = y + j % 8 # [0, 1,..., 23]\\n map[xx, yy] = data[i, j]\\n\\n yseg = range(6)\\n ylab = [\\\"00-07\\\", \\\"10-17\\\", \\\"00-07\\\", \\\"10-17\\\", \\\"00-07\\\", \\\"10-17\\\"]\\n xseg = range(0, 24, 4)\\n xlab = [\\\"0\\\", \\\"4\\\", \\\"0\\\", \\\"4\\\", \\\"0\\\", \\\"4\\\"]\\n\\n fig = plt.figure(figsize=(10, 10))\\n ax1 = fig.add_subplot(111)\\n im = ax1.imshow(map, interpolation='nearest', cmap='jet', aspect=4, vmin=vmin, vmax=vmax)\\n plt.yticks(yseg, ylab)\\n plt.xticks(xseg, xlab)\\n plt.annotate('S22', xy=(0, 0), xytext=(4, -0.8), fontsize=15, ha='center', va='center')\\n plt.annotate('S12', xy=(0, 0), xytext=(12, -0.8), fontsize=15, ha='center', va='center')\\n plt.annotate('S02', xy=(0, 0), xytext=(20, -0.8), fontsize=15, ha='center', va='center')\\n plt.annotate('S02', xy=(0, 0), xytext=(24., 0.5), fontsize=15, ha='left', va='center')\\n plt.annotate('S01', xy=(0, 0), xytext=(24., 2.5), fontsize=15, ha='left', va='center')\\n plt.annotate('S00', xy=(0, 0), xytext=(24., 4.5), fontsize=15, ha='left', va='center')\\n ax1.vlines(7.5, -0.5, 5.5)\\n ax1.vlines(15.5, -0.5, 5.5)\\n ax1.hlines(1.5, -0.5, 23.5)\\n ax1.hlines(3.5, -0.5, 23.5)\\n plt.subplots_adjust(left=0.07, bottom=0.05, right=0.8, top=0.95, wspace=0, hspace=0)\\n #cbar_ax = fig.add_axes([0.15, 0.03, 0.7, 0.05])\\n #fig.colorbar(im, cax=cbar_ax, orientation=\\\"horizontal\\\")\\n cbar_ax = fig.add_axes([0.87, 0.15, 0.05, 0.7])\\n fig.colorbar(im, cax=cbar_ax)\\n fig.suptitle(TITLE, y=0.98, size=19)\\n plt.savefig(OUTDIR + TITLE + '.png')\\n plt.show()\\n plt.close(fig)\",\n \"def logplot(in_dir, fname, xlim, ylim, title):\\n\\n with open(in_dir + fname,'r') as logfile:\\n lf_lines = logfile.readlines()\\n\\n traj_x = []\\n traj_y = []\\n\\n for row in lf_lines:\\n if row[:4] == 'pose':\\n #print(float(row[10:-2]))\\n tup = row[7:]\\n sep_pos = tup.find(' , ')\\n traj_x.append(float(tup[:sep_pos]))\\n traj_y.append(float(tup[sep_pos+3:]))\\n\\n liveplot(traj_x, traj_y, xlim, ylim, title)\",\n \"def add_lvs_correspondence_points(self):\\n\\n pin = self.rbl_inv_inst.get_pin(\\\"A\\\")\\n self.add_label_pin(text=\\\"bl[0]\\\",\\n layer=pin.layer,\\n offset=pin.ll(),\\n height=pin.height(),\\n width=pin.width())\\n\\n pin = self.dc_inst.get_pin(\\\"out\\\")\\n self.add_label_pin(text=\\\"delayed_en\\\",\\n layer=pin.layer,\\n offset=pin.ll(),\\n height=pin.height(),\\n width=pin.width())\",\n \"def streamlines(ax, mesh, umean):\\n Nx,Ny = 1001, 401\\n xcart = np.linspace(0,10,Nx)\\n ycart = np.linspace(0,4,Ny)\\n meshcart = np.vstack( map(lambda x: x.flatten(), np.meshgrid(xcart, ycart)) ).T\\n interp_u = tri.LinearTriInterpolator(mesh, umean[:,0])\\n interp_v = tri.LinearTriInterpolator(mesh, umean[:,1])\\n ucart = interp_u(meshcart[:,0], meshcart[:,1])\\n vcart = interp_v(meshcart[:,0], meshcart[:,1])\\n X = meshcart[:,0].reshape(Ny,Nx)\\n Y = meshcart[:,1].reshape(Ny,Nx)\\n U = ucart.reshape(Ny,Nx)\\n V = vcart.reshape(Ny,Nx)\\n lw = np.sqrt(U**2+V**2)*3\\n start_points=np.vstack((np.ones(10)*0.1, np.linspace(1,3,10))).T\\n ###ax.streamplot(X, Y, U, V, density=.8, color='k', linewidth=1.)\\n strm = ax.streamplot(xcart, ycart, U, V, start_points=[[4,2]], color='k', linewidth=1.)\\n for path in strm.lines.get_paths():\\n path.vertices\",\n \"def line_sSFR(**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n GR = glo.global_results()\\n \\n L_line = getattr(GR,'L_'+p.line+'_sun')#[0:100]\\n SFR = getattr(GR,'SFR')#[0:100]\\n Zsfr = getattr(GR,'Zsfr')#[0:100]\\n R_gas = getattr(GR,'R2_gas')#[0:100]\\n M_H2 = getattr(GR,'M_H2_R2_gas')#[0:100]\\n M_star = getattr(GR,'M_star')#[0:100]\\n\\n # Take only MS galaxies?\\n if p.select == '_MS':\\n indices = aux.select_salim18(GR.M_star,GR.SFR)\\n L_line = L_line[indices]\\n SFR = SFR[indices]\\n Zsfr = Zsfr[indices]\\n print('With MS selection criteria: only %i galaxies' % (len(L_line)))\\n\\n SFR = SFR[L_line > 0]\\n Zsfr = Zsfr[L_line > 0]\\n R_gas = R_gas[L_line > 0]\\n M_H2 = M_H2[L_line > 0]\\n M_star = M_star[L_line > 0]\\n sSFR = SFR/M_star\\n L_line = L_line[L_line > 0]\\n\\n print('%i data points ' % (len(L_line)))\\n\\n labs = {'_M10':'Mach=10 power-law',\\\\\\n '_arepoPDF_dim':'AREPO parametric PDF with extinction',\\\\\\n '_arepoPDF':'AREPO parametric PDF'}\\n lab = labs[p.table_ext]\\n\\n if p.add:\\n ax = p.ax\\n else:\\n fig,ax = plt.subplots(figsize=(8,6))\\n\\n if p.select == 'Sigma_M_H2':\\n Sigma_M_H2 = M_H2/(np.pi*R_gas**2)\\n m = ax.scatter(sSFR[np.argsort(Sigma_M_H2)],L_line[np.argsort(Sigma_M_H2)],marker='o',s=20,\\\\\\n c=np.log10(Sigma_M_H2[np.argsort(Sigma_M_H2)]),vmin=3.5,label=lab,alpha=0.6,zorder=10)\\n cbar = plt.colorbar(m,ax=ax)\\n cbar.set_label(label=r'log $\\\\Sigma_{H2}$ [M$_{\\\\odot}$/kpc$^2$]',size=15)\\n else:\\n m = ax.scatter(sSFR,L_line,marker='o',s=20,\\\\\\n c=Zsfr,label=lab,alpha=0.6,zorder=10)\\n cbar = plt.colorbar(m,ax=ax)\\n cbar.set_label(label=r'$\\\\langle Z\\\\rangle_{\\\\mathrm{SFR}}$ [Z$_{\\\\odot}$]',size=15)\\n\\n if p.add_obs:\\n add_line_sSFR_obs(p.line,L_line,ax,select=p.select)\\n\\n ax.set_xscale('log')\\n ax.set_yscale('log')\\n ax.set_xlabel(getlabel('sSFR'))\\n ax.set_ylabel(getlabel(p.line))\\n handles,labels = ax.get_legend_handles_labels()\\n handles = np.flip(handles)\\n labels = np.flip(labels)\\n # ax.legend(handles,labels,loc='upper left',fontsize=7)\\n ax.legend(handles,labels,loc='lower right',fontsize=7,frameon=True,framealpha=0.5) \\n print(np.min(sSFR),np.max(sSFR))\\n if not p.xlim: p.xlim = 10.**np.array([-13,-7])\\n if not p.ylim: \\n p.ylim = [np.median(L_line)/1e6,np.median(L_line)*1e4]\\n ax.set_xlim(p.xlim)\\n ax.set_ylim(p.ylim)\\n ax.grid(ls='--')\\n\\n if p.savefig & (not p.add):\\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \\n plt.savefig(p.d_plot + 'luminosity/%s_sSFR.png' % p.line, format='png', dpi=300)\",\n \"def __init__(self,\\n logs_dirs = ['LOGS'],\\n profile_paths = [],\\n history_paths = [],\\n clean_data = True,\\n extra_history_cols = [],\\n identifier = \\\"eps_nuc\\\",\\n extractor = default_extractor,\\n log10_on_data = True,\\n contour_colormap = plt.get_cmap(\\\"Blues\\\"),\\n levels = [],\\n log_levels = True,\\n num_levels = 8,\\n xaxis = \\\"model_number\\\",\\n xaxis_divide = 1.0,\\n time_units = \\\"Myr\\\",\\n function_on_xaxis = lambda x: x,\\n yaxis = \\\"mass\\\",\\n yaxis_normalize = False,\\n show_conv = True, show_therm = True, show_semi = True, show_over = True, show_rot = False,\\n core_masses = [\\\"He\\\",\\\"C\\\",\\\"O\\\"],\\n yresolution = 1000,\\n mass_tolerance = 0.0000001,\\n radius_tolerance = 0.0000001,\\n decorate_plot = True,\\n show_plot = False,\\n save_file = True,\\n save_filename = \\\"Kippenhahn.png\\\"):\\n\\n self.logs_dirs = logs_dirs\\n self.profile_paths = profile_paths\\n self.history_paths = history_paths\\n self.clean_data = clean_data\\n self.extra_history_cols = extra_history_cols\\n self.identifier = identifier\\n self.extractor = extractor\\n self.log10_on_data = log10_on_data\\n self.contour_colormap = contour_colormap\\n self.levels = levels\\n self.log_levels = log_levels\\n self.num_levels = num_levels\\n self.xaxis = xaxis\\n self.xaxis_divide = xaxis_divide\\n self.time_units = time_units\\n self.function_on_xaxis = function_on_xaxis\\n self.yaxis = yaxis\\n self.yaxis_normalize = yaxis_normalize\\n self.show_conv = show_conv\\n self.show_therm = show_therm\\n self.show_semi = show_semi\\n self.show_over = show_over\\n self.show_rot = show_rot\\n self.core_masses = core_masses\\n self.yresolution = yresolution\\n self.mass_tolerance = mass_tolerance\\n self.radius_tolerance = radius_tolerance\\n self.decorate_plot = decorate_plot\\n self.show_plot = show_plot\\n self.save_file = save_file\\n self.save_filename = save_filename\",\n \"def plot_model(model, inputs, outputs, tss=90):\\n mdl = np.load(model)\\n sys = ss(mdl['A'], mdl['B'], mdl['C'], mdl['D'],1)\\n gain_matrix = dcgain(sys).T\\n num_i = len(inputs)\\n num_o = len(outputs)\\n fig, axs = plt.subplots(num_i,num_o, figsize=(3*len(outputs), 2*len(inputs)), facecolor='w', edgecolor='k')\\n fig.suptitle('Step responce: '+model)\\n T = np.arange(tss)\\n for idx_i in range(num_i):\\n for idx_o in range(num_o):\\n ax = axs[idx_i][idx_o]\\n t,y_step = step_response(sys,T, input=idx_i, output=idx_o)\\n gain = round(gain_matrix[idx_i][idx_o],4)\\n ax.plot(t, y_step,color='r')\\n if idx_i == 0:\\n ax.set_title(outputs[idx_o], rotation='horizontal', ha='center', fontsize=10)\\n if idx_o == 0:\\n ax.set_ylabel(inputs[idx_i], rotation=90, fontsize=10)\\n ax.grid(color='k', linestyle='--', linewidth=0.5)\\n ax.tick_params(axis='x', colors='red',size=0,labelsize=4)\\n ax.tick_params(axis='y', colors='red',size=0,labelsize=4)\\n ax.annotate(str(gain),xy=(.72,.8),xycoords='axes fraction')\\n # fig.tight_layout()\\n plt.show()\",\n \"def test_plot_lin(self):\\n pname = os.path.join(self.datadir, 'monol_testA_E3-50_pds_fit') + \\\\\\n HEN_FILE_EXTENSION\\n cname = os.path.join(self.datadir, 'monol_test_E3-50_cpds_fit') + \\\\\\n HEN_FILE_EXTENSION\\n lname = os.path.join(self.datadir, 'monol_testA_E3-50_lc') + \\\\\\n HEN_FILE_EXTENSION\\n hen.plot.main([pname, cname, lname, '--noplot', '--xlin', '--ylin',\\n '-o', 'dummy.qdp'])\\n hen.plot.main([lname, '--noplot',\\n '--axes', 'time', 'counts', '--xlin', '--ylin',\\n '-o', 'dummy.qdp'])\",\n \"def __init__(self, vals, skel, scene=None, padding=0):\\r\\n self.skel = skel\\r\\n self.padding = padding\\r\\n connect = skel.connection_matrix()\\r\\n mocap_data_show_vpython.__init__(self, vals, scene=scene, connect=connect, radius=0.4)\",\n \"def add_line_SFR_obs(line,L_line,ax,plot_fit=True,**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n # --- Observations compiled in Observations.ipynb ---\\n\\n L_obs = np.array([])\\n SFR_obs = np.array([])\\n\\n if p.plot: print('\\\\nObserved galaxies with %s:' % line)\\n\\n c = 'dimgrey'\\n a = 0.8\\n mew = 1\\n\\n # Kamenetzky et al. 2016\\n df = pd.read_pickle('data/observations/AHIMSA_sample_lit')\\n df = df[(df.sizes < 47) & (df.SFR > 1e-4) & (df[line+ '_Lsun'].values > 0)] \\n try:\\n if p.plot: ax.plot(np.log10(df.SFR[(df.sizes < 47) & (df.SFR > 1e-4)]),\\\\\\n np.log10(df[line + '_Lsun'][(df.sizes < 47) & (df.SFR > 1e-4)]),'>',ms=6,fillstyle='none',mew=mew,\\\\\\n color=c,alpha=a,label='Mixed type galaxies [Kamenetzky+16]')\\n lo_err = np.array(np.log10(df[line+ '_Lsun'].values)-np.log10(df[line+ '_Lsun'].values-df['e_'+line+ '_Lsun'].values))\\n up_err = np.array(np.log10(df[line+ '_Lsun'].values+df['e_'+line+ '_Lsun'].values)-np.log10(df[line+ '_Lsun'].values))\\n lo_err[df[line+ '_Lsun'].values == 0] = 0\\n up_err[df[line+ '_Lsun'].values == 0] = 0\\n # ax.errorbar(np.log10(df.SFR),\\\\\\n # np.log10(df[line+ '_Lsun']),\\\\\\n # yerr=np.column_stack([lo_err,up_err]).T,\\\\\\n # elinewidth=1,marker='>',ms=6,mew=1,fillstyle='none',\\\\\\n # color='grey',alpha=0.8,lw=0,label='Mixed z~0 sample [Kamenetzky+16]')\\n L_obs = np.append(L_obs,df[line + '_Lsun'].values)\\n SFR_obs = np.append(SFR_obs,df.SFR.values)\\n if p.plot: print('%i galaxies from Kamenetzky+16 ' % (len(L_obs)))\\n except:\\n pass\\n\\n # print('min SFR: ',np.min(df.SFR.values[df.sizes < 47]))\\n\\n # Brauher et al. 2008\\n try:\\n df = pd.read_pickle('data/observations/Brauher_2008')\\n if p.plot: \\n # lo_err = np.array(np.log10(df['L_'+line].values)-np.log10(df['L_'+line].values-df['e_'+line].values))\\n # up_err = np.array(np.log10(df['L_'+line].values+df['e_'+line].values)-np.log10(df['L_'+line].values))\\n # print(lo_err)\\n # print(df['e_'+line].values/df['L_'+line])\\n # ax.errorbar(np.log10(df.SFR),np.log10(df['L_'+line]),\\\\\\n # yerr=np.column_stack([lo_err,up_err]).T,\\\\\\n # elinewidth=1,marker='o',ms=7,mew=1,fillstyle='none',\\\\\\n # color='grey',alpha=0.8,lw=0,label='MS/SB galaxies [Brauher+08]')\\n ax.plot(np.log10(df.SFR),np.log10(df['L_%s' % line]),'o',fillstyle='none',ms=4,mew=mew,color=c,\\\\\\n alpha=a,label='MS/SB galaxies [Brauher+08]')\\n L_ul = np.log10(df['L_%s' % line][df['f_'+line] == -1])\\n if len(L_ul) > 0:\\n # ax.plot(df.SFR[df['f_'+line] == -1],L_ul,'o',zorder=0,ms=7,mew=1,color='grey',alpha=0.8)\\n ax.errorbar(np.log10(df.SFR[df['f_'+line] == -1]),L_ul,capsize=3,color=c,alpha=a,elinewidth=1,\\\\\\n uplims=np.ones(len(L_ul)),\\\\\\n yerr=0.3,lw=0)\\n if p.plot: print('%i galaxies from Brauher+08 ' % (len(df)))\\n L =df['L_%s' % line].values\\n SFR =df['SFR'].values\\n L = L[SFR > 0]\\n SFR = SFR[SFR > 0]\\n L_obs = np.append(L_obs,L)\\n SFR_obs = np.append(SFR_obs,SFR)\\n # print('min SFR: ',np.min(df.SFR))\\n except:\\n pass\\n\\n if p.select != '_MS':\\n # Cormier et al. 2015\\n try:\\n df = pd.read_pickle('data/observations/DGS_Cormier_2015')\\n if p.plot: \\n # try: \\n # lo_err = np.array(np.log10(df['L_'+line].values)-np.log10(df['L_'+line].values-df['e_'+line].values))\\n # up_err = np.array(np.log10(df['L_'+line].values+df['e_'+line].values)-np.log10(df['L_'+line].values))\\n # ax.errorbar(df.SFR,np.log10(df['L_'+line]),\\\\\\n # yerr=np.column_stack([lo_err,up_err]).T,\\\\\\n # elinewidth=1,marker='x',ms=7,mew=mew,\\\\\\n # color=c,alpha=a,lw=0,label='Dwarf galaxies [Cormier+15]')\\n # except:\\n ax.plot(df.SFR,np.log10(df['L_%s' % line]),'x',zorder=0,ms=7,mew=mew,color=c,alpha=a,\\\\\\n label='Dwarf galaxies [Cormier+15]')\\n L_ul = np.log10(-1.*df['L_'+line][df['L_'+line] < 0])\\n if len(L_ul) > 0:\\n ax.plot(df.SFR[df['L_'+line] < 0],L_ul,'x',zorder=0,ms=7,mew=mew,color=c,alpha=a)\\n ax.errorbar(df.SFR[df['L_'+line] < 0],L_ul,capsize=3,color=c,alpha=a,elinewidth=1,\\\\\\n uplims=np.ones(len(L_ul)),\\\\\\n yerr=0.3,lw=0)\\n # np.log10(-1.*L_ul - 10.**(np.log10(-1.*L_ul)-0.3))\\n if p.plot: print('%i galaxies from Cormier+15 ' % (len(df)))\\n L_obs = np.append(L_obs,df['L_%s' % line].values)\\n SFR_obs = np.append(SFR_obs,10.**df.SFR.values)\\n except:\\n pass\\n\\n # Schruba et al. 2012\\n #try:\\n if (line == 'CO(1-0)') | (line == 'CO(2-1)'):\\n df = pd.read_pickle('data/observations/Schruba_2012')\\n if p.plot: \\n if line == 'CO(1-0)': label = 'Mixed type galaxies [Schruba+12]'\\n if line == 'CO(2-1)': label = 'Dwarf galaxies [Schruba+12]'\\n f_ul = df['f_%s' % line].values\\n L = df['L_%s' % line].values\\n SFR = df['SFR'].values\\n L_obs = np.append(L_obs,L[L > 0])\\n SFR_obs = np.append(SFR_obs,SFR[L > 0])\\n Z = df['Z'].values\\n if line == 'CO(2-1)': \\n SFR = SFR[L>0]\\n f_ul = f_ul[L>0]\\n Z = Z[L>0]\\n L = L[L>0]\\n print('Schruba min max Z: ',Z.min(),Z.max())\\n M_H2 = 1.8e9 * SFR # from S12 paper\\n area = np.array([1.33,1.79,1.75,7.74,11.47,12.37,26.69,83.85,12.23,39.40,19.21,7.78,14.75,59.54,31.19,39.19]) # kpc2\\n Sigma_M_H2 = M_H2 / (area*1000*1000)\\n if p.select == 'Zsfr': \\n ax.scatter(np.log10(SFR[L > 0]),np.log10(L[L > 0]),marker='*',zorder=0,facecolors='none',s=30,\\\\\\n linewidth=mew,c=np.log10(Z),alpha=a,label=label,vmin=p.vmin,vmax=p.vmax)\\n else:\\n ax.scatter(np.log10(SFR[L > 0]),np.log10(L[L > 0]),marker='*',zorder=0,facecolors='none',s=30,\\\\\\n linewidth=mew,c=np.log10(Sigma_M_H2),alpha=a,label=label,vmin=p.vmin,vmax=p.vmax)\\n if line == 'CO(1-0)': \\n ax.plot(np.log10(SFR[L > 0]),np.log10(L[L > 0]),'*',zorder=0,fillstyle='none',ms=7,mew=mew,color=c,alpha=a,\\\\\\n label=label)\\n if len(f_ul) > 0:\\n # ax.plot(np.log10(SFR[f_ul == 1]),np.log10(L[f_ul == 1]),'*',zorder=0,fillstyle='none',ms=7,mew=mew,color=c,alpha=a)\\n ax.errorbar(np.log10(SFR[f_ul == 1]),np.log10(L[f_ul == 1]),capsize=3,fillstyle='none',color=c,alpha=a,elinewidth=1,\\\\\\n uplims=np.ones(len(L[f_ul == 1])),\\\\\\n yerr=0.3,lw=0)\\n if p.plot: print('%i galaxies from Schruba+12 ' % (len(df)))\\n #except:\\n # pass\\n\\n # Accurso et al. 2017\\n try:\\n df = pd.read_pickle('data/observations/xCOLD_GASS_Accurso_2017')\\n df = df.loc[np.argwhere(df['L_CO(1-0)'].values > 0).flatten()]\\n if p.plot: ax.plot(np.log10(df['SFR']),df['L_%s' % line], 'd', zorder=0,ms=7,fillstyle='none',mew=mew,color=c,alpha=a,label='COLD GASS [Accurso+17]') #c=np.log10(A17['Z']), \\n L_obs = np.append(L_obs,10.**df['L_%s' % line].values)\\n if p.plot: print('%i galaxies from Accurso+17 ' % (len(df)))\\n SFR_obs = np.append(SFR_obs,df.SFR.values)\\n except:\\n pass\\n\\n # Vanzi et al. 2009\\n if line == 'CO(3-2)':\\n df = pd.read_pickle('data/observations/Vanzi_2009')\\n df = df.loc[np.argwhere(df['L_CO(3-2)'].values > 0).flatten()]\\n if p.plot: ax.plot(np.log10(df['SFR']),np.log10(df['L_%s' % line]), 'D', zorder=0,ms=7,fillstyle='none',mew=mew,\\\\\\n color=c,alpha=a,label='Dwarf galaxies [Vanzi+09]') #c=np.log10(A17['Z']), \\n L_obs = np.append(L_obs,df['L_%s' % line].values)\\n if p.plot: print('%i galaxies from Vanzi+09 ' % (len(df)))\\n SFR_obs = np.append(SFR_obs,df.SFR.values)\\n # except:\\n # pass\\n\\n\\n # Diaz-Santos et al. 2013\\n try:\\n df = pd.read_pickle('data/observations/Diaz-Santos_2013')\\n if p.plot: ax.plot(np.log10(df.SFR),np.log10(df['L_%s' % line]),'^',ms=6,zorder=0,fillstyle='none',mew=mew,color=c,alpha=a,label='LIRGs [Diaz-Santos+13]')\\n if p.plot: print('%i galaxies from Diaz-Santos+17 ' % (len(df)))\\n L_obs = np.append(L_obs,df['L_%s' % line].values)\\n SFR_obs = np.append(SFR_obs,df.SFR.values)\\n # print('min SFR: ',np.min(df.SFR))\\n except:\\n pass\\n # Farrah et al. 2013\\n # try:\\n # df = pd.read_pickle('data/observations/Farrah_2013')\\n # if p.plot: ax.plot(df.SFR,df['L_%s' % line],'<',fillstyle='none',mew=1,color='grey',alpha=0.8,label='Farrah+13 (ULIRGs)')\\n # if p.plot: print('%i galaxies from Farrah+13 ' % (len(df)))\\n # L_obs = np.append(L_obs,df['L_%s' % line].values)\\n # SFR_obs = np.append(SFR_obs,df.SFR.values)\\n # except:\\n # pass\\n # Zhao et al. 2016\\n try:\\n df = pd.read_pickle('data/observations/Zhao_2016')\\n if p.plot: ax.plot(np.log10(df.SFR),np.log10(df['L_%s' % line]),'<',ms=6,fillstyle='none',mew=mew,color=c,alpha=a,label='GOALS (U)LIRGs [Zhao+16]')\\n if p.plot: print('%i galaxies from Zhao+16 ' % (len(df)))\\n L_obs = np.append(L_obs,df['L_%s' % line].values)\\n SFR_obs = np.append(SFR_obs,df.SFR.values)\\n # print('min SFR: ',np.min(df.SFR))\\n except:\\n pass\\n\\n if line in ['[CII]158','[OI]63','[OIII]88']:\\n # De Looze 2014 relation\\n if np.min(L_line) == 0 : L_line[L_line == 0] = 1e-30\\n if p.plot: print(np.min(np.log10(L_line)),np.max(np.log10(L_line)))\\n logL_delooze = np.arange(np.min(np.log10(L_line)) - 3,np.max(np.log10(L_line)) + 3)\\n\\n if line == '[CII]158':\\n logSFR_delooze_DGS = -5.73 + 0.8 * logL_delooze\\n logSFR_delooze_SBG = -7.06 + 1.0 * logL_delooze\\n\\n if line == '[OI]63':\\n logSFR_delooze_DGS = -6.23 + 0.91 * logL_delooze\\n logSFR_delooze_SBG = -6.05 + 0.89 * logL_delooze\\n\\n if line == '[OIII]88':\\n logSFR_delooze_DGS = -6.71 + 0.92 * logL_delooze\\n logSFR_delooze_SBG = -3.89 + 0.69 * logL_delooze\\n\\n if p.plot: ax.plot(logSFR_delooze_DGS,logL_delooze,'--',color='grey',alpha=0.7,\\\\\\n label='Local dwarf galaxies [de Looze+ 2014]')\\n if p.plot: ax.plot(logSFR_delooze_SBG,logL_delooze,':',color='grey',alpha=0.7,\\\\\\n label='Local SB galaxies [de Looze+ 2014]')\\n # print(SFR_obs)\\n logSFR = np.arange(np.min(np.log10(SFR_obs[SFR_obs > 0])) - 3,np.max(np.log10(SFR_obs[SFR_obs > 0])) + 3)\\n # fit = np.polyfit(np.log10(SFR_obs[(L_obs > 0) & (SFR_obs > 0)]),\\\\\\n # np.log10(L_obs[(L_obs > 0) & (SFR_obs > 0)]),1)\\n # pfit = np.poly1d(fit)\\n # L_fit = 10.**pfit(logSFR)\\n\\n # Make log-linear fit to SFR-binned luminosities\\n SFRs = SFR_obs[(L_obs > 0) & (SFR_obs > 0)]\\n Ls = L_obs[(L_obs > 0) & (SFR_obs > 0)]\\n SFR_axis = np.linspace(np.log10(SFRs.min()),np.log10(SFRs.max()),20)\\n SFR_bins = SFR_axis[0:-1] + (SFR_axis[1]-SFR_axis[0])/2.\\n Ls_binned = np.zeros(len(SFR_axis)-1)\\n for i in range(len(Ls_binned)):\\n Ls1 = Ls[(SFRs >= 10.**SFR_axis[i]) & (SFRs <= 10.**SFR_axis[i+1])]\\n Ls_binned[i] = np.mean(np.log10(Ls1))\\n SFR_bins = SFR_bins[Ls_binned > 0]\\n Ls_binned = Ls_binned[Ls_binned > 0]\\n # ax.plot(10.**SFR_bins,10.**Ls_binned,'x',color='orange',mew=3)\\n fit = LinearRegression().fit(SFR_bins.reshape(-1, 1),\\\\\\n Ls_binned.reshape(-1, 1))\\n L_fit = 10.**fit.predict(logSFR.reshape(-1, 1))\\n if p.plot & plot_fit: ax.plot(logSFR,np.log10(L_fit),'--k',lw=1.5,zorder=0)\\n\\n # print(line)\\n # print(np.log10(L_obs[(L_obs > 0) & (SFR_obs > 0)]))\\n # print(fit.predict(SFR_obs[(L_obs > 0) & (SFR_obs > 0)].reshape(-1, 1)).flatten())\\n\\n std = np.std(np.log10(L_obs[(L_obs > 0) & (SFR_obs > 0)]) - \\\\\\n fit.predict(np.log10(SFR_obs[(L_obs > 0) & (SFR_obs > 0)]).reshape(-1, 1)).flatten())\\n\\n\\n # Read literature data from AHIMSA project\\n # obsdf = pd.read_pickle(p.d_data+'observations/sample_lit')\\n # print(obsdf.keys())\\n # print(L_obs)\\n # print(SFR_obs)\\n\\n if not p.plot: \\n return(L_obs.flatten(),SFR_obs.flatten(),fit,std)\",\n \"def dline_Mgas(**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n GR = glo.global_results(sim_run=p.sim_run,nGal=p.nGal)\\n \\n marker = 'o'\\n if p.sim_run == p.sim_runs[0]: marker = '^'\\n\\n L_line = getattr(GR,'L_'+p.line+'_sun')#[380:400]#[0:100]\\n SFR = getattr(GR,'SFR')#[380:400]#[0:100]\\n M_star = getattr(GR,'M_star')#[380:400]#[0:100]\\n Zsfr = getattr(GR,'Zsfr')#[380:400]#[0:100]\\n R_gas = getattr(GR,'R2_gas')#[380:400]#[0:100]\\n M_H2 = getattr(GR,'M_H2_R2_gas')#[380:400]#[0:100]\\n M_gas = getattr(GR,'M_gas')#[380:400]#[0:100]\\n\\n SFR = SFR[L_line > 0]\\n M_star = M_star[L_line > 0]\\n Zsfr = Zsfr[L_line > 0]\\n R_gas = R_gas[L_line > 0]\\n M_H2 = M_H2[L_line > 0]\\n M_gas = M_gas[L_line > 0]\\n L_line = L_line[L_line > 0]\\n print('%i data points ' % (len(L_line)))\\n\\n if p.add:\\n ax = p.ax\\n else:\\n fig,ax = plt.subplots(figsize=(8,6))\\n\\n # Distance from observed relation\\n L_obs,SFR_obs,fit,std = add_line_SFR_obs(p.line,[1e6,1e6],ax,plot=False,select=p.select)\\n ldL_line = np.log10(L_line) - fit.predict(np.log10(SFR.reshape(-1, 1))).flatten()\\n\\n labs = {'_M10':'Mach=10 power-law',\\\\\\n '_arepoPDF_ext':'AREPO parametric PDF with extinction',\\\\\\n '_arepoPDF':'SIGAME v3',\\\\\\n '_arepoPDF_CMZ':'SIGAME v3',\\\\\\n '_arepoPDF_M51':'SIGAME v3'}\\n lab = labs[p.table_ext]\\n\\n\\n ax.text(0.05,0.9,p.line,transform=ax.transAxes,fontsize=13)\\n ax.set_xlabel(getlabel('M_gas'))\\n ax.set_ylabel('log L - log L$_{obs}$(SFR)')\\n if not p.xlim: p.xlim = np.array([8,11])\\n if not p.ylim: \\n p.ylim = [np.median(ldL_line) - 4,np.median(ldL_line) + 3]\\n ax.set_xlim(p.xlim)\\n ax.set_ylim(p.ylim)\\n ax.plot([0,0],ax.get_ylim(),'--k',lw=1)\\n ax.plot(ax.get_xlim(),[0,0],'--k',lw=1)\\n\\n if p.select == 'Sigma_M_H2':\\n Sigma_M_H2 = M_H2/(np.pi*R_gas**2)/1e6 # per pc^-2\\n m = ax.scatter(np.log10(M_gas)[np.argsort(Sigma_M_H2)],ldL_line[np.argsort(Sigma_M_H2)],marker=marker,s=14,\\\\\\n c=np.log10(Sigma_M_H2[np.argsort(Sigma_M_H2)]),vmin=-2.5,vmax=2.2,label=lab,alpha=0.5,zorder=10)\\n if p.cb:\\n cbar = plt.colorbar(m,ax=ax)\\n cbar.set_label(label=r'log $\\\\Sigma_{H2}$ [M$_{\\\\odot}$/pc$^2$]',size=15)\\n\\n print(np.log10(M_gas.min()),np.log10(M_gas.max()))\",\n \"def preprocess_data(self, lidar_data):\\n return lidar_data\",\n \"def movie(l, zlim=0.7, zstep=0.01, nside=64, dump_plot_dir=None, nsn_func=None,\\n bands=['g', 'r', 'i', 'z'],\\n exclude_bands=['u', 'y'],\\n vmax_nsn=None,\\n min_cadence=0.5,\\n lc_template=None,\\n salt2=None):\\n \\n m = Metrics(l, model_filename=salt2, lc_template=lc_template, nside=nside)\\n nsn_tot = np.zeros(m.npix)\\n nsn_inst = np.zeros(m.npix)\\n cadence_tot = np.zeros(m.npix)\\n cadence_nhits = np.zeros(m.npix) \\n zmax_tot = np.zeros(m.npix)\\n zmax_nhits = np.zeros(m.npix)\\n tmp_map = np.zeros(m.npix)\\n\\n # median values \\n nsn_tot_history = []\\n nsn_inst_history = []\\n median_cadence_inst_history = []\\n zmax_inst_history = []\\n \\n # p = Plotter()\\n # for block in pxlog:\\n # for m,acc in metrics:\\n # r = m(block)\\n # a.accumulate(r)\\n # if a.do_plot:\\n # p.plot_maps(a)\\n \\n \\n \\n # loop on the survey mjd -- by steps of 1 day\\n for mjd in np.arange(m.mjd.min(), m.mjd.max()+1):\\n zmax = np.zeros(m.npix)\\n nsn = np.zeros(m.npix)\\n \\n # check that the sampling is ok at z=0\\n s,u = m.select_window(mjd, z=0., bands=bands, exclude_bands=exclude_bands)\\n c = m.cadence(u, z=0.)\\n first, last = m.first_last_visits(mjd, u, z=0.)\\n c[c<min_cadence] = 0.\\n c[first==0.] = 0.\\n c[last==0.] = 0.\\n c0_ok = c>0.\\n \\n # loop over the redshift range, and check the resolution in\\n # color as a function of redshift. Store the highest redshift\\n # that passes the cuts \\n for z in np.arange(0.1, zlim+zstep, zstep)[::-1]:\\n # select the window \\n s,u = m.select_window(mjd, z=z, exclude_bands=exclude_bands)\\n \\n # average cadence\\n # note: explore median dt\\n cz = m.cadence(u, z=z)\\n \\n # observations before -15 and after +30 ? \\n firstz, lastz = m.first_last_visits(mjd, u, z=z)\\n # cut in cadence \\n cz[(cz<min_cadence)] = 0.\\n \\n # cut on the last visit\\n cz[(firstz==0.)] = 0.\\n cz[(lastz==0)] = 0.\\n cz *= c0_ok\\n\\n # cut on sigma amplitude\\n if np.abs(z-0.3) <= 0.01:\\n snr_g = m.amplitude_snr(mjd, instrument_name + '::g', z, s)\\n snr_r = m.amplitude_snr(mjd, instrument_name + '::r', z, s)\\n snr_i = m.amplitude_snr(mjd, instrument_name + '::i', z, s)\\n snr_z = m.amplitude_snr(mjd, instrument_name + '::z', z, s) \\n if z <= 0.3:\\n snr_ok = m.cut_on_amplitude_snr(mjd, z, s, \\n snr_cuts = {instrument_name + '::g': 30., \\n instrument_name + '::r': 40., \\n instrument_name + '::i': 30., \\n instrument_name + '::z': 20.})\\n else:\\n snr_ok = m.cut_on_amplitude_snr(mjd, z, s, \\n snr_cuts = {instrument_name + '::r': 40., \\n instrument_name + '::i': 30., \\n instrument_name + '::z': 20.})\\n \\n # update max-z map \\n zmax[(cz>0) & (snr_ok>0.) & (zmax==0.)] = z\\n c[c==0] = cz[c==0]\\n # update the number of supernovae for that day \\n # we update (1) a map that contains the total\\n # number of SNe and (2) a NTuple that contains\\n # mjd, nsn, zmax\\n if nsn_func is not None:\\n nsn_inst[:] = 0.\\n nsn_inst[zmax>0.] = nsn_func(zmax[zmax>0])\\n nsn_tot[zmax>0.] += nsn_inst[zmax>0.]\\n else:\\n logging.warning('no function to compute number of SNe')\\n\\n # update the cumulative maps\\n cadence_tot += c\\n cadence_nhits[c>0] += 1\\n zmax_tot += zmax\\n zmax_nhits[zmax>0] += 1\\n \\n # m.plot_map(first, fig=1, vmin=0., vmax=1.25, sub=221, cbar=False)\\n # m.plot_map(last, fig=1, vmin=0., vmax=1.25, sub=222, cbar=False)\\n fig = plt.figure(1, figsize=(15.,7.5))\\n human_date = DateTimeFromMJD(mjd).strftime('%Y-%m-%d')\\n fig.suptitle('[%s mjd=%6.0f]' % (human_date, mjd))\\n m.plot_map(nsn_tot, fig=1, sub=231, vmin=0., vmax=vmax_nsn, cbar=True, title='$N_{SNe}: %6.0f$ (tot)' % nsn_tot.sum())\\n nsn_tot_history.append((mjd,nsn_tot.sum()))\\n tmp_map[:] = hp.UNSEEN ; idx = zmax_nhits>0\\n tmp_map[idx] = zmax_tot[idx] / zmax_nhits[idx]\\n med = np.median(tmp_map[tmp_map>0])\\n m.plot_map(tmp_map, fig=1, sub=232, vmin=0., vmax=0.5, cbar=True, title='$z_{max}$ (avg) [%4.2f]' % (med if ~np.isnan(med) else 0))\\n tmp_map[:] = hp.UNSEEN ; idx = cadence_nhits>0\\n tmp_map[idx] = cadence_tot[idx] / cadence_nhits[idx]\\n med = np.median(tmp_map[tmp_map>0])\\n m.plot_map(tmp_map, fig=1, sub=233, vmin=0., vmax=1., cbar=True, title='cadence [day$^{-1}$] (avg) [%4.2f]' % (med if ~np.isnan(med) else 0))\\n \\n m.plot_map(nsn_inst, fig=1, sub=234, vmin=0., vmax=0.015, cbar=True, title='$N_{SNe}: %4.0f$' % nsn_inst.sum())\\n nsn_inst_history.append((mjd,nsn_inst.sum()))\\n med = np.median(zmax[zmax>0])\\n m.plot_map(zmax, fig=1, vmin=0., vmax=0.5, sub=235, cbar=True, title='$z_{max}$ [%4.2f]' % (med if ~np.isnan(med) else 0))\\n zmax_inst_history.append((mjd,(med if ~np.isnan(med) else 0)))\\n med = np.median(c[c>0])\\n m.plot_cadence(c, fig=1, dump_plot_dir=dump_plot_dir, \\n vmin=0.,\\n vmax=1.,\\n min_cadence=min_cadence,\\n sub=236,\\n title='cadence [day$^{-1}$] [%4.2f]' % (med if ~np.isnan(med) else 0.),\\n cbar=True)\\n median_cadence_inst_history.append((mjd,(med if ~np.isnan(med) else 0.)))\\n\\n # SNR debug plots \\n fig = plt.figure(2)\\n fig.suptitle('[%s mjd=%6.0f]' % (human_date, mjd))\\n m.plot_map(snr_g, fig=2, sub=221, vmin=0., vmax=30., cbar=True, title='SNR[g]')\\n m.plot_map(snr_r, fig=2, sub=222, vmin=0., vmax=40., cbar=True, title='SNR[r]')\\n m.plot_map(snr_i, fig=2, sub=223, vmin=0., vmax=30., cbar=True, title='SNR[i]') \\n m.plot_map(snr_z, fig=2, sub=224, vmin=0., vmax=20., cbar=True, title='SNR[z]', dump_plot_dir=dump_plot_dir, prefix='snr')\\n\\n # cadence debug plots\\n\\n m.fig_odometer += 1\\n\\n\\n # dump history\\n nsn_tot_history = np.rec.fromrecords(nsn_tot_history, names=['mjd', 'val'])\\n nsn_inst_history = np.rec.fromrecords(nsn_inst_history, names=['mjd', 'val'])\\n zmax_inst_history = np.rec.fromrecords(zmax_inst_history, names=['mjd', 'val'])\\n median_cadence_inst_history = np.rec.fromrecords(median_cadence_inst_history, names=['mjd', 'val'])\\n np.save(dump_plot_dir + os.sep + 'nsn_tot_history.npy', nsn_tot_history)\\n np.save(dump_plot_dir + os.sep + 'nsn_inst_history.npy', nsn_inst_history)\\n np.save(dump_plot_dir + os.sep + 'zmax_inst_history.npy', zmax_inst_history)\\n np.save(dump_plot_dir + os.sep + 'median_cadence_inst_history.npy', median_cadence_inst_history)\",\n \"def plot_seaice_predict_components(anomlous = False, temporal_resolution = 'monthly', spatial_resolution = 1, detrend = False, imagefolder = 'images/timeseries/prediction/',seaice_source='nsidc'):\\n output_folder = 'processed_data/SIC/'\\n if seaice_source == 'ecmwf':\\n output_folder = 'processed_data/ERA5/SIC/'\\n\\n if anomlous:\\n temp_decomp = 'anomalous'\\n else:\\n temp_decomp = 'raw'\\n\\n\\n title = temp_decomp.capitalize() + ' '\\n\\n if detrend:\\n dt = 'detrended'\\n title += dt + ' '\\n else:\\n dt = 'raw'\\n\\n title += temporal_resolution\\n title += ' SIE prediction'\\n\\n\\n# Loading Seaice Trends\\n seaicename = f'{temp_decomp}_{temporal_resolution}_{spatial_resolution}_{dt}'\\n seaice = xr.open_dataset(output_folder + seaicename +'.nc')\\n area = xr.open_dataset('data/area_files/processed_nsidc.nc').area\\n seaice = seaice\\n\\n\\n# Index contributions\\n filename = f'processed_data/regressions/spatial_multiple/regr_{temp_decomp}_{temporal_resolution}_{dt}_{spatial_resolution}'\\n dataset = xr.open_dataset(filename + '.nc')\\n indicies = np.array([i for i in dataset])\\n values = np.array([dataset[i].values for i in dataset])\\n index_data = {}\\n for indexname in indicies[:-1]:\\n filename = f'{indexname}_{temp_decomp}_{temporal_resolution}_{dt}'\\n index_data[indexname] = xr.open_dataset('processed_data/INDICIES/' + filename +'.nc')[indexname]\\n index_data[indexname] = (index_data[indexname] - index_data[indexname].mean()) \\n index_data[indexname] = index_data[indexname] / index_data[indexname].std()\\n\\n times = list(set.intersection(set(seaice.time.values), *(set(index_data[i].time.values)for i in indicies[:-1])))\\n\\n prediction = seaice.copy() * 0\\n predictions = []\\n for indexname in indicies:\\n if indexname in index_data.keys():\\n prediction += index_data[indexname].sel(time=times).sortby('time') * dataset[indexname]\\n predictions += [index_data[indexname].sel(time=times).sortby('time') * dataset[indexname]]\\n else:\\n prediction += dataset[indexname]\\n predictions += [dataset[indexname]]\\n\\n\\n seaice = seaice.sortby('time').sel(time=times).sortby('time')\\n prediction = prediction.sortby('time').sel(time=times).sortby('time')\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n ax.axhline(y=0, alpha = 0.5)\\n data = (prediction[seaicename]*area/250).sum(dim = ('x', 'y'))\\n data_m, data_b, data_r_value, data_p_value, data_std_err = scipy.stats.linregress(data.time.values.astype(float), data)\\n plt.plot(data.time, data_m * data.time.values.astype(float) + data_b, color = '#EA1B10', alpha = 0.5)\\n data = (seaice[seaicename]*area/250).sum(dim = ('x', 'y'))\\n data_m, data_b, data_r_value, data_p_value, data_std_err = scipy.stats.linregress(data.time.values.astype(float), data)\\n plt.plot(data.time, data_m * data.time.values.astype(float) + data_b, color = '#177E89', alpha = 0.5)\\n\\n\\n ln1 = ax.plot(seaice.time, (seaice[seaicename]*area/250).sum(dim = ('x', 'y')), label = 'SIE', alpha = 0.5)\\n ln2 = ax.plot(seaice.time, (prediction[seaicename]*area/250).sum(dim = ('x', 'y')), label = 'Prediction', alpha = 0.5)\\n\\n lines = ln1 + ln2\\n i = 0\\n for indexname in indicies[:-1]:\\n predict = index_data[indexname] * dataset[indexname]\\n lines += ax.plot(predict.time, (predict*area/250).sum(dim = ('x', 'y')), '--', label = f'{indexname}', linewidth=1)\\n i += 1\\n\\n labels = [line.get_label() for line in lines]\\n plt.legend(lines,labels,bbox_to_anchor=(0.99, -0.15), ncol = 3, loc = 'upper right')\\n plt.title(title)\\n\\n plt.savefig(imagefolder + seaicename + '_components.pdf')\\n plt.show()\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n ax.axhline(y=0, alpha = 0.5)\\n data = (prediction[seaicename]*area/250).sum(dim = ('x', 'y'))\\n data_m, data_b, data_r_value, data_p_value, data_std_err = scipy.stats.linregress(data.time.values.astype(float), data)\\n # plt.plot(data.time, data_m * data.time.values.astype(float) + data_b, color = '#EA1B10', alpha = 0.5)\\n data = (seaice[seaicename]*area/250).sum(dim = ('x', 'y'))\\n data_m, data_b, data_r_value, data_p_value, data_std_err = scipy.stats.linregress(data.time.values.astype(float), data)\\n # plt.plot(data.time, data_m * data.time.values.astype(float) + data_b, color = '#177E89', alpha = 0.5)\\n\\n\\n norm = (seaice[seaicename]*area/250).sum(dim = ('x', 'y')) / 100\\n ln1 = ax.plot(seaice.time, (seaice[seaicename]*area/250).sum(dim = ('x', 'y')).sortby('time')/norm, label = 'SIE', alpha = 0.5)\\n ln2 = ax.plot(seaice.time, (prediction[seaicename]*area/250).sum(dim = ('x', 'y')).sortby('time')/norm, label = 'Prediction', alpha = 0.5)\\n\\n lines = ln1 + ln2\\n i = 0\\n for indexname in indicies[:-1]:\\n predict = index_data[indexname].sel(time=times).sortby('time') * dataset[indexname]\\n lines += ax.plot(predict.time, (predict*area/250).sum(dim = ('x', 'y'))/norm, '--', label = f'{indexname}', linewidth=1)\\n i += 1\\n\\n labels = [line.get_label() for line in lines]\\n plt.legend(lines,labels,bbox_to_anchor=(0.99, -0.15), ncol = 3, loc = 'upper right')\\n plt.title(title)\\n\\n plt.savefig(imagefolder + seaicename + '_components_normalised.pdf')\\n plt.show()\",\n \"def decoding(file_path, id2spo, logits_all, seq_len_all,\\n tok_to_orig_start_index_all, tok_to_orig_end_index_all):\\n example_all = []\\n with open(file_path, \\\"r\\\", encoding=\\\"utf-8\\\") as fp:\\n for line in fp:\\n example_all.append(json.loads(line))\\n\\n formatted_outputs = []\\n for (i, (example, logits, seq_len, tok_to_orig_start_index, tok_to_orig_end_index)) in \\\\\\n enumerate(zip(example_all, logits_all, seq_len_all, tok_to_orig_start_index_all, tok_to_orig_end_index_all)):\\n\\n logits = logits[1:seq_len +\\n 1] # slice between [CLS] and [SEP] to get valid logits\\n logits[logits >= 0.5] = 1\\n logits[logits < 0.5] = 0\\n tok_to_orig_start_index = tok_to_orig_start_index[1:seq_len + 1]\\n tok_to_orig_end_index = tok_to_orig_end_index[1:seq_len + 1]\\n predictions = []\\n for token in logits:\\n predictions.append(np.argwhere(token == 1).tolist())\\n\\n # format predictions into example-style output\\n formatted_instance = {}\\n text_raw = example['text']\\n complex_relation_label = [8, 10, 26, 32, 46]\\n complex_relation_affi_label = [9, 11, 27, 28, 29, 33, 47]\\n\\n # flatten predictions then retrival all valid subject id\\n flatten_predictions = []\\n for layer_1 in predictions:\\n for layer_2 in layer_1:\\n flatten_predictions.append(layer_2[0])\\n subject_id_list = []\\n for cls_label in list(set(flatten_predictions)):\\n if 1 < cls_label <= 56 and (cls_label + 55) in flatten_predictions:\\n subject_id_list.append(cls_label)\\n subject_id_list = list(set(subject_id_list))\\n\\n # fetch all valid spo by subject id\\n spo_list = []\\n for id_ in subject_id_list:\\n if id_ in complex_relation_affi_label:\\n continue # do this in the next \\\"else\\\" branch\\n if id_ not in complex_relation_label:\\n subjects = find_entity(text_raw, id_, predictions,\\n tok_to_orig_start_index,\\n tok_to_orig_end_index)\\n objects = find_entity(text_raw, id_ + 55, predictions,\\n tok_to_orig_start_index,\\n tok_to_orig_end_index)\\n for subject_ in subjects:\\n for object_ in objects:\\n spo_list.append({\\n \\\"predicate\\\": id2spo['predicate'][id_],\\n \\\"object_type\\\": {\\n '@value': id2spo['object_type'][id_]\\n },\\n 'subject_type': id2spo['subject_type'][id_],\\n \\\"object\\\": {\\n '@value': object_\\n },\\n \\\"subject\\\": subject_\\n })\\n else:\\n # traverse all complex relation and look through their corresponding affiliated objects\\n subjects = find_entity(text_raw, id_, predictions,\\n tok_to_orig_start_index,\\n tok_to_orig_end_index)\\n objects = find_entity(text_raw, id_ + 55, predictions,\\n tok_to_orig_start_index,\\n tok_to_orig_end_index)\\n for subject_ in subjects:\\n for object_ in objects:\\n object_dict = {'@value': object_}\\n object_type_dict = {\\n '@value': id2spo['object_type'][id_].split('_')[0]\\n }\\n if id_ in [8, 10, 32, 46\\n ] and id_ + 1 in subject_id_list:\\n id_affi = id_ + 1\\n object_dict[id2spo['object_type'][id_affi].split(\\n '_')[1]] = find_entity(text_raw, id_affi + 55,\\n predictions,\\n tok_to_orig_start_index,\\n tok_to_orig_end_index)[0]\\n object_type_dict[id2spo['object_type'][\\n id_affi].split('_')[1]] = id2spo['object_type'][\\n id_affi].split('_')[0]\\n elif id_ == 26:\\n for id_affi in [27, 28, 29]:\\n if id_affi in subject_id_list:\\n object_dict[id2spo['object_type'][id_affi].split('_')[1]] = \\\\\\n find_entity(text_raw, id_affi + 55, predictions, tok_to_orig_start_index, tok_to_orig_end_index)[0]\\n object_type_dict[id2spo['object_type'][id_affi].split('_')[1]] = \\\\\\n id2spo['object_type'][id_affi].split('_')[0]\\n spo_list.append({\\n \\\"predicate\\\": id2spo['predicate'][id_],\\n \\\"object_type\\\": object_type_dict,\\n \\\"subject_type\\\": id2spo['subject_type'][id_],\\n \\\"object\\\": object_dict,\\n \\\"subject\\\": subject_\\n })\\n\\n formatted_instance['text'] = example['text']\\n formatted_instance['spo_list'] = spo_list\\n formatted_outputs.append(formatted_instance)\\n return formatted_outputs\",\n \"def __init__(self, vals, model, data_visualize, latent_axes=None, sense_axes=None, latent_index=[0,1]):\\r\\n if vals == None:\\r\\n vals = model.X[0]\\r\\n\\r\\n matplotlib_show.__init__(self, vals, axes=latent_axes)\\r\\n\\r\\n if isinstance(latent_axes,mpl.axes.Axes):\\r\\n self.cid = latent_axes.figure.canvas.mpl_connect('button_press_event', self.on_click)\\r\\n self.cid = latent_axes.figure.canvas.mpl_connect('motion_notify_event', self.on_move)\\r\\n self.cid = latent_axes.figure.canvas.mpl_connect('axes_leave_event', self.on_leave)\\r\\n self.cid = latent_axes.figure.canvas.mpl_connect('axes_enter_event', self.on_enter)\\r\\n else:\\r\\n self.cid = latent_axes[0].figure.canvas.mpl_connect('button_press_event', self.on_click)\\r\\n self.cid = latent_axes[0].figure.canvas.mpl_connect('motion_notify_event', self.on_move)\\r\\n self.cid = latent_axes[0].figure.canvas.mpl_connect('axes_leave_event', self.on_leave)\\r\\n self.cid = latent_axes[0].figure.canvas.mpl_connect('axes_enter_event', self.on_enter)\\r\\n\\r\\n self.data_visualize = data_visualize\\r\\n self.model = model\\r\\n self.latent_axes = latent_axes\\r\\n self.sense_axes = sense_axes\\r\\n self.called = False\\r\\n self.move_on = False\\r\\n self.latent_index = latent_index\\r\\n self.latent_dim = model.input_dim\\r\\n\\r\\n # The red cross which shows current latent point.\\r\\n self.latent_values = vals\\r\\n self.latent_handle = self.latent_axes.plot([0],[0],'rx',mew=2)[0]\\r\\n self.modify(vals)\\r\\n self.show_sensitivities()\",\n \"def show_predictions(request):\\n route_tag = request.GET['RT']\\n direction_tag = request.GET['DT']\\n stop_tag = request.GET['ST']\\n\\n pred = get_predictions('sf-muni', route_tag, direction_tag, stop_tag)\\n\\n return HttpResponse(json.dumps(pred), content_type='application/json')\",\n \"def test_lpp():\\n \\n tce_filename = \\\"tce0001234567_dvt.fits\\\"\\n \\n #Populate the tce class by reading in a file\\n #At this point a phases array, \\n #and (int) transit_number would get populated.\\n \\n tce = vet.create_tce(file = tce_filename, ext = 1)\\n \\n #This populates the LPP metric fields in this class\\n #It also populates where the plotting data is stored\\n #This function relies on inputs from a precomputed model stored\\n #in something called mapInfo. In theory if someone trains up another \\n #model we could input it here.\\n tce.run_lpp(mapInfo = None)\\n \\n norm_TLpp = tce.lpp.norm\\n raw_TLpp = tce.lpp.raw\\n binned_lpp_transit = tce.lpp.binned_transit\\n \\n plot_out = tce.lpp.plot(filename=\\\"lpp_plot.png\\\")\\n \\n assert norm_TLpp > 0\\n assert norm_TLpp < 10\\n assert len(binned_lpp_transit) > 50\",\n \"def linedata():\\n get_values = request.args\\n pc = get_values.get('pc') is not None # Per Capita\\n gr = get_values.get('gr') is not None # Growth Rate\\n place_args, _ = get_place_args(get_values)\\n plot_data, _ = datachart_handler.get_plot_data(place_args, pc, gr)\\n return json.dumps(plot_data)\",\n \"def plot_interaction_map(model, name, matrix, output_name, first_variable, second_variable, x_coord, y_coord, output_path): \\n import matplotlib\\n import matplotlib.cm as cm\\n import matplotlib.pyplot as plt\\n\\n font = {'size' : 14}\\n\\n matplotlib.rc('font', **font)\\n fig = plt.figure(figsize=(5,5))\\n ax = plt.subplot()\\n\\n maxValue = np.max(np.abs(matrix))\\n img = ax.imshow((matrix), cmap = cm.bwr, origin='lower', vmin = -min(maxValue, 6), vmax = min(maxValue, 6), interpolation='spline16')\\n\\n first_variable = '{}'.format(first_variable)\\n second_variable = '{}'.format(second_variable)\\n ax.set_ylabel(r'$x_i$ = ' + first_variable)\\n ax.set_xlabel(r'$y_i$ = ' + second_variable)\\n ax.axes.set_xticks([0, 50, 99])\\n ax.axes.set_yticks([0, 50, 99])\\n xticks = np.linspace(np.array(model.feature_limits[first_variable]).min(), np.array(model.feature_limits[first_variable]).max(), 3)\\n yticks = np.linspace(np.array(model.feature_limits[second_variable]).min(), np.array(model.feature_limits[second_variable]).max(), 3)\\n ax.scatter([x_coord], [y_coord], marker='o', color='white', s = 250, edgecolors='black', linewidth=3)\\n\\n ax.set_yticklabels([xticks[tind] for tind in range(3)])\\n ax.set_xticklabels([yticks[tind] for tind in range(3)])\\n ax.axis([0, (100) - 1, 0, (100) - 1])\\n\\n # ax.scatter([x_coord_linear], [y_coord_linear], marker='o', color='blue', s = 250, edgecolors='black', linewidth=3)\\n t = ax.set_title(r'$\\\\mathregular{\\\\frac{\\\\delta ^2 F(\\\\bar{x})}{\\\\delta x_i \\\\delta x_j}}$')\\n # t = ax.set_title('{} and {} - '.format(first_variable, second_variable) + r'$\\\\mathregular{\\\\frac{\\\\delta ^2 F(\\\\bar{x})}{\\\\delta x_i \\\\delta x_j}}$')\\n t.set_position([.5, 1.025])\\n from mpl_toolkits.axes_grid1 import make_axes_locatable\\n divider = make_axes_locatable(ax)\\n cax = divider.append_axes(\\\"right\\\", size=\\\"5%\\\", pad=0.05)\\n cb = plt.colorbar(img, cax=cax)\\n cb.set_label(\\\"Nomralized mixed derivative\\\", rotation=90)\\n plt.savefig('{}/{}_{}_{}_{}_nonlinear_map.pdf'.format(output_path, name, output_name, first_variable, second_variable), transparent=True, bbox_inches='tight', format='pdf', dpi=600)\\n # plt.close('all')\",\n \"def generate_egoview_overlaid_lidar(\\n data_root: Path,\\n output_dir: Path,\\n log_id: str,\\n render_ground_pts_only: bool,\\n dump_single_frames: bool,\\n) -> None:\\n loader = AV2SensorDataLoader(data_dir=data_root, labels_dir=data_root)\\n\\n log_map_dirpath = data_root / log_id / \\\"map\\\"\\n avm = ArgoverseStaticMap.from_map_dir(log_map_dirpath, build_raster=True)\\n\\n # repeat red to green colormap every 50 m.\\n colors_arr_rgb = color_utils.create_colormap(\\n color_list=[RED_HEX, GREEN_HEX], n_colors=NUM_RANGE_BINS\\n )\\n colors_arr_rgb = (colors_arr_rgb * 255).astype(np.uint8)\\n colors_arr_bgr: NDArrayByte = np.fliplr(colors_arr_rgb)\\n\\n for _, cam_name in enumerate(list(RingCameras)):\\n cam_im_fpaths = loader.get_ordered_log_cam_fpaths(log_id, cam_name)\\n num_cam_imgs = len(cam_im_fpaths)\\n\\n video_list = []\\n for i, im_fpath in enumerate(cam_im_fpaths):\\n if i % 50 == 0:\\n logging.info(\\n f\\\"\\\\tOn file {i}/{num_cam_imgs} of camera {cam_name} of {log_id}\\\"\\n )\\n\\n cam_timestamp_ns = int(im_fpath.stem)\\n city_SE3_ego = loader.get_city_SE3_ego(log_id, cam_timestamp_ns)\\n if city_SE3_ego is None:\\n logger.exception(\\\"missing LiDAR pose\\\")\\n continue\\n\\n # load feather file path, e.g. '315978406032859416.feather\\\"\\n lidar_fpath = loader.get_closest_lidar_fpath(log_id, cam_timestamp_ns)\\n if lidar_fpath is None:\\n logger.info(\\n \\\"No LiDAR sweep found within the synchronization interval for %s, so skipping...\\\",\\n cam_name,\\n )\\n continue\\n\\n img_bgr = io_utils.read_img(im_fpath, channel_order=\\\"BGR\\\")\\n\\n lidar_points_ego = io_utils.read_lidar_sweep(lidar_fpath, attrib_spec=\\\"xyz\\\")\\n lidar_timestamp_ns = int(lidar_fpath.stem)\\n\\n # put into city coords, then prune away ground and non-RoI points\\n lidar_points_city = city_SE3_ego.transform_point_cloud(lidar_points_ego)\\n lidar_points_city = avm.remove_non_drivable_area_points(lidar_points_city)\\n is_ground_logicals = avm.get_ground_points_boolean(lidar_points_city)\\n lidar_points_city = lidar_points_city[\\n is_ground_logicals if render_ground_pts_only else ~is_ground_logicals\\n ]\\n lidar_points_ego = city_SE3_ego.inverse().transform_point_cloud(\\n lidar_points_city\\n )\\n\\n # motion compensate always\\n (\\n uv,\\n points_cam,\\n is_valid_points,\\n ) = loader.project_ego_to_img_motion_compensated(\\n points_lidar_time=lidar_points_ego,\\n cam_name=cam_name,\\n cam_timestamp_ns=cam_timestamp_ns,\\n lidar_timestamp_ns=lidar_timestamp_ns,\\n log_id=log_id,\\n )\\n\\n if is_valid_points is None or uv is None or points_cam is None:\\n continue\\n\\n if is_valid_points.sum() == 0:\\n continue\\n\\n uv_int: NDArrayInt = np.round(uv[is_valid_points]).astype(np.int32)\\n points_cam = points_cam[is_valid_points]\\n pt_ranges: NDArrayFloat = np.linalg.norm(points_cam[:, :3], axis=1)\\n color_bins: NDArrayInt = np.round(pt_ranges).astype(np.int32)\\n # account for moving past 100 meters, loop around again\\n color_bins = color_bins % NUM_RANGE_BINS\\n uv_colors_bgr = colors_arr_bgr[color_bins]\\n\\n img_empty = np.full_like(img_bgr, fill_value=255)\\n img_empty = raster_rendering_utils.draw_points_xy_in_img(\\n img_empty, uv_int, uv_colors_bgr, diameter=10\\n )\\n blended_bgr = raster_utils.blend_images(img_bgr, img_empty)\\n frame_rgb = blended_bgr[:, :, ::-1]\\n\\n if dump_single_frames:\\n save_dir = output_dir / log_id / cam_name\\n os.makedirs(save_dir, exist_ok=True)\\n cv2.imwrite(\\n str(save_dir / f\\\"{cam_name}_{lidar_timestamp_ns}.jpg\\\"), blended_bgr\\n )\\n\\n video_list.append(frame_rgb)\\n\\n if len(video_list) == 0:\\n raise RuntimeError(\\n \\\"No video frames were found; log data was not found on disk.\\\"\\n )\\n\\n video: NDArrayByte = np.stack(video_list).astype(np.uint8)\\n video_output_dir = output_dir / \\\"videos\\\"\\n video_utils.write_video(\\n video=video,\\n dst=video_output_dir / f\\\"{log_id}_{cam_name}.mp4\\\",\\n fps=RING_CAMERA_FPS,\\n )\",\n \"def dataModel():\\n srcmap001 = fits.open('dataFiles/6gev_srcmap_001.fits')\\n srcmap03 = fits.open('dataFiles/6gev_srcmap_03.fits')\\n\\n image_data = fits.getdata('6gev_image.fits')\\n filename = get_pkg_data_filename('6gev_image.fits')\\n hdu = fits.open(filename)[0]\\n wcs = WCS(hdu.header)\\n\\n #Given the results of the fit, calculate the model\\n modelData001 = np.zeros(srcmap001[0].shape)\\n modelData03 = np.zeros(srcmap03[0].shape)\\n\\n file = open('plotsData/fitResults001.pk1','rb')\\n fit001 = pickle.load(file)\\n file.close()\\n\\n file = open('plotsData/fitResults03.pk1','rb')\\n fit03 = pickle.load(file)\\n file.close()\\n\\n\\n for source in fit001:\\n the_index = srcmap001.index_of(source)\\n\\n modelData001 += fit001[source][:, None, None]*srcmap001[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap001[the_index].data, axis=2), axis=1)[:-1, None, None]\\n for source in fit03:\\n the_index = srcmap03.index_of(source)\\n modelData03 += fit03[source][:, None, None]*srcmap03[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap03[the_index].data, axis=2), axis=1)[:-1, None, None]\\n\\n fig = plt.figure(figsize=[12, 4.5])\\n\\n vmin = 0\\n vmax = 70.0\\n cbStep = 10.0\\n ax = fig.add_subplot(121, projection=wcs)\\n ax=plt.gca()\\n ax.tick_params(direction='in')\\n c = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax.get_transform('galactic'))\\n ax.add_patch(c)\\n mappable=plt.imshow((image_data),cmap='inferno',origin='lower',norm=colors.PowerNorm(gamma=0.6),vmin=vmin, vmax=vmax, interpolation='gaussian')#\\n plt.xlabel('Galactic Longitude')\\n plt.ylabel('Galactic Latitude')\\n plt.title('Data ($>6$ GeV)')\\n cb = plt.colorbar(mappable, label='Counts per pixel', pad=0.01,ticks=np.arange(vmin, vmax+cbStep, cbStep))\\n cb.ax.tick_params(width=0)\\n\\n\\n ax2=fig.add_subplot(122, projection=wcs)\\n ax2 = plt.gca()\\n\\n sources = []\\n sources.append({\\n 'Name':'3FGL J1745.3-2903c',\\n 'RA':266.3434922,\\n 'DEC':-29.06274323,\\n 'color':'xkcd:bright light blue'})\\n\\n sources.append({\\n 'Name':'1FIG J1748.2-2816',\\n 'RA':267.1000722,\\n 'DEC':-28.27707114,\\n 'color':'xkcd:fire engine red'\\n })\\n\\n sources.append({\\n 'Name':'1FIG J1746.4-2843',\\n 'RA':266.5942898,\\n 'DEC':-28.86244442,\\n 'color':'xkcd:fluorescent green'\\n })\\n\\n sources.append({\\n 'Name':'Galactic Center',\\n 'RA':266.417,\\n 'DEC':-29.0079,\\n 'color':'black'\\n })\\n\\n #Add source names:\\n for source in sources:\\n l, b = ra_dec_to_l_b(source['RA'], source['DEC'])\\n ax2.scatter(l, b, color=source['color'],marker='x',s=45.0, transform=ax2.get_transform('galactic'), label=source['Name'])\\n\\n c2 = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax2.get_transform('galactic'))\\n ax2.add_patch(c2)\\n mappable2 = plt.imshow((np.sum(modelData03,axis=0)), cmap='inferno',norm=colors.PowerNorm(gamma=0.6),origin='lower',vmin=vmin, vmax=vmax, interpolation='gaussian')\\n plt.xlabel('Galactic Longitude')\\n plt.ylabel('Galactic Latitude')\\n plt.title('Model ($>6$ GeV)')\\n cb2 = plt.colorbar(mappable2, label='Counts per pixel', pad=0.01, ticks=np.arange(vmin, vmax+cbStep, cbStep))\\n cb2.ax.tick_params(width=0)\\n leg = plt.legend(loc=1,frameon=True)\\n leg.get_frame().set_alpha(0.5)\\n leg.get_frame().set_edgecolor('white')\\n text1 = leg.get_texts()\\n for text in text1:\\n text.set_color('black')\\n\\n fig.tight_layout()\\n plt.subplots_adjust(wspace = 0.13, left=0.04, bottom=0.13, top=0.92)\\n plt.show()\\n #plt.savefig('plots/dataModelComparison.pdf',bbox_inches='tight')\",\n \"def plot_dollo_ml_tree(tree, nodes):\\n leaf_order = []\\n for leaf in tree.leaves:\\n leaf.plot_id = leaf.name\\n leaf_order.append(leaf.name)\\n\\n origin_counts = nodes.groupby('node')['ml_origin'].sum()\\n\\n for node in tree.nodes:\\n node.origin_count = origin_counts[node.label]\\n\\n loss_counts = nodes.groupby('node')['ml_loss'].sum()\\n\\n width = 1 + 0.5 * float(len(list(tree.leaves)))\\n fig = plt.figure(figsize=(width/1.5, 6))\\n\\n ax = fig.add_subplot(111)\\n\\n def func(x, pos):\\n s = '{:0,d}'.format(int(x))\\n return s\\n ax.yaxis.set_major_formatter(matplotlib.ticker.FuncFormatter(func))\\n\\n wgs_analysis.plots.trees.plot_tree(ax, tree, landscape=False, flip=True, branch_length_attr='origin_count', leaf_name_attr='plot_id')\\n\\n ax.set_ylabel('SNV count')\\n\\n plt.tight_layout()\",\n \"def analyze(data):\\n # perform fit\\n regr_results = sm.OLS.from_formula('mosquitos ~ temperature + rainfall', data).fit()\\n print(regr_results.tvalues)\\n \\n fig = plt.figure(figsize=(6, 9))\\n\\n # plot predicted vs. measured mosquito populations from fitted model \\n ax0 = fig.add_subplot(3, 1, 1)\\n\\n parameters = regr_results.params\\n predicted = (parameters['Intercept'] + \\n parameters['temperature'] * data['temperature'] + \\n parameters['rainfall'] * data['rainfall'])\\n\\n ax0.plot(predicted, data['mosquitos'], 'gd')\\n\\n ax0.set_xlabel('predicted mosquito population')\\n ax0.set_ylabel('measured mosquito population')\\n \\n # plot mosquitos vs. temperature\\n ax1 = fig.add_subplot(3, 1, 2)\\n\\n ax1.plot(data['temperature'], data['mosquitos'], 'ro')\\n ax1.set_xlabel('temperature')\\n ax1.set_ylabel('mosquitos')\\n\\n # plot mosquitos vs. rainfall\\n ax2 = fig.add_subplot(3, 1, 3)\\n\\n ax2.plot(data['rainfall'], data['mosquitos'], 'bs')\\n ax2.set_xlabel('rainfall')\\n ax2.set_ylabel('mosquitos')\\n \\n # adjust layout of axes according to label placement\\n plt.tight_layout()\\n \\n return fig\",\n \"def example():\\n # --- input data filename ---\\n infile = os.path.join(os.path.dirname(__file__),\\n '../../ExampleDataFiles/MarsTopo719.shape')\\n coeffs, lmax = pysh.shio.shread(infile)\\n\\n # --- plot grid ---\\n grid = pysh.expand.MakeGridDH(coeffs, csphase=-1)\\n fig_map = plt.figure()\\n plt.imshow(grid)\\n\\n # ---- compute spectrum ----\\n ls = np.arange(lmax + 1)\\n pspectrum = pysh.spectralanalysis.spectrum(coeffs, unit='per_l')\\n pdensity = pysh.spectralanalysis.spectrum(coeffs, unit='per_lm')\\n\\n # ---- plot spectrum ----\\n fig_spectrum, ax = plt.subplots(1, 1)\\n ax.set_xscale('log')\\n ax.set_yscale('log')\\n ax.set_xlabel('degree l')\\n ax.grid(True, which='both')\\n\\n ax.plot(ls[1:], pspectrum[1:], label='power per degree l')\\n ax.plot(ls[1:], pdensity[1:], label='power per degree l and order m')\\n\\n ax.legend()\\n\\n fig_map.savefig('SHRtopography_mars.png')\\n fig_spectrum.savefig('SHRspectrum_mars.png')\\n print('mars topography and spectrum saved')\\n\\n # plt.show()\",\n \"def __init__(self):\\n super(vanderpol_output,self).__init__()\\n\\n # add figure object for further use\\n fig = plt.figure()\\n self.ax = fig.add_subplot(111)\\n self.ax.set_xlim([-2.5,2.5])\\n self.ax.set_ylim([-10.5,10.5])\\n plt.ion()\\n self.sframe = None\",\n \"def __init__(self):\\r\\n self.label = \\\"OVL to Feature\\\"\\r\\n self.description = \\\"OVL to Feature converts an OVL file from CPOF, C2PC, GCCS or similar system and converts it to a series of Feature Class for Point, Line, and Polygons.\\\"\\r\\n self.canRunInBackground = False\",\n \"def main():\\n strikes, dips, normals, slip = generate_normal_ss_data(330, 60, n=500, porp=1)\\n #strikes, dips, normals, slip = generate_normal_data(330, 60, n=500, porp=10)\\n sigma = invert_plane_stress(normals, slip)\\n plot(sigma, strikes, dips)\\n plt.show()\",\n \"def plot_ls(self, ax):\\n t = self.t\\n x_true = self.x_true\\n x_ls = self.x_ls\\n\\n ax.plot(t, x_true, 'k-', label='true', lw=1.5)\\n ax.plot(t, x_ls, 'r-', label=r'$\\\\vec{x}_{LS}$', lw=1.5)\\n ax.set_title(r'Noisy $A\\\\vec{x} = \\\\vec{b}$')\\n ax.set_xlabel(r'$t$')\\n ax.set_ylabel(r'$x$')\\n leg = ax.legend(loc='upper left')\\n leg.get_frame().set_alpha(0.5)\\n ax.grid()\",\n \"def make_map(data,LatLonBox):\\n\\n proj = ccrs.LambertConformal(central_longitude=data.StationLongitude,\\n central_latitude=data.StationLatitude)\\n\\n fig = plt.figure(figsize=(17,11))\\n ax = plt.subplot(111,projection=proj)\\n \\n ax.coastlines('50m', 'black', linewidth=2, zorder=2)\\n\\n reader = shpreader.Reader('/Users/chowdahead/Documents/shapefiles/countyl010g_shp_nt00964/countyl010g.shp')\\n counties = list(reader.geometries())\\n COUNTIES = cfeature.ShapelyFeature(counties,ccrs.PlateCarree())\\n ax.add_feature(COUNTIES, facecolor='none',edgecolor='w')\\n # Grab state borders\\n state_borders = cfeature.NaturalEarthFeature(\\n category='cultural', name='admin_1_states_provinces_lines',\\n scale='50m', facecolor='none')\\n ax.add_feature(state_borders, edgecolor='w', linewidth=1, zorder=3)\\n \\n ocean = cfeature.NaturalEarthFeature('physical', 'ocean', scale='50m',\\n edgecolor='face',\\n facecolor=cfeature.COLORS['water'])\\n land = cfeature.NaturalEarthFeature('physical', 'land', scale='50m',\\n edgecolor='face',\\n facecolor=\\\"k\\\")\\n\\n ax.add_feature(ocean, zorder=-1)\\n ax.add_feature(land, zorder=-1)\\n ax.set_facecolor('black')\\n \\n ax.set_extent(LatLonBox,ccrs.PlateCarree())\\n \\n return fig,ax,proj\",\n \"def learnSVR(metricArray, n, overlap, imageSize, fit): \\n # fit = svrAlg() \\n # metricArray = [[1,1],[2,3],[4,5], [3,7],[70,20],[5,20],[9,18], [87,34],[43,127], [1,10],[5,3],[4,8], [3,90],[76,20],[500,20],[29,34], [38,34],[43,17]]\\n # n= 50 #Change your metrics here!!!!!!!!!\\n # overlap = 0.3 \\n #imageSize = [100,400]\\n \\n densMap(fit, metricArray, n, overlap, imageSize )\\n overlayMap('SmallTile.jpg', 'ContourPlot.jpg') \\n # Final map is saved as OverlayMap.jpg\",\n \"def try4():\\n path = '/Users/mayankkejriwal/git-projects/bioExperiments/tsne_python/'\\n mnist = path+'mnist2500_X.txt'\\n X = numpy.loadtxt(mnist)\\n labels = numpy.loadtxt(path+\\\"mnist2500_labels.txt\\\")\\n Y = tsne.tsne(X, 2, 50, 20.0)\\n pylab.scatter(Y[:,0], Y[:,1], 20, labels)\\n pylab.show()\",\n \"def P_AI_Rocky2(in_dict):\\n # START\\n fs = 16\\n plt.rc('font', size=fs)\\n fig = plt.figure(figsize=(8,12))\\n ds = nc.Dataset(in_dict['fn'])\\n\\n # PLOT CODE\\n aa = [-122.8, -122.54, 47.92, 48.22]\\n # import cmocean\\n # cmap = cmocean.cm.speed\\n # cmap = 'RdYlBu_r'\\n cmap = 'Spectral_r'\\n\\n from warnings import filterwarnings\\n filterwarnings('ignore') # skip some warning messages\\n \\n # plot Code\\n \\n # calculate speed\\n uu = ds['u'][0, -1, :, :]\\n vv = ds['v'][0, -1, :, :]\\n u = zfun.fillit(uu)\\n v = zfun.fillit(vv)\\n u[np.isnan(u)] = 0\\n v[np.isnan(v)] = 0\\n # interpolate to the clipped rho grid\\n ur = (u[1:-1,1:] + u[1:-1,:-1])/2\\n vr = (v[1:,1:-1] + v[:-1,1:-1])/2\\n spd = np.sqrt(ur**2 + vr**2)\\n spd[spd==0] = np.nan\\n \\n G = zrfun.get_basic_info(in_dict['fn'], only_G=True)\\n \\n # panel 1\\n ax = fig.add_subplot(111)\\n cs = plt.pcolormesh(G['lon_psi'], G['lat_psi'], spd, cmap=cmap,\\n vmin=0, vmax=1.5)\\n tstr = (r'Admiralty Inlet Surface Speed ($m\\\\ s^{-1}$)')\\n #pfun.add_bathy_contours(ax, ds, txt=True)\\n pfun.add_coast(ax)\\n ax.axis(aa)\\n pfun.dar(ax)\\n ax.set_xlabel('Longitude')\\n ax.set_ylabel('Latitude')\\n ax.set_title(tstr)\\n pfun.add_info(ax, in_dict['fn'])\\n ax.set_xticks([-122.8, -122.7, -122.6])\\n ax.set_yticks([48, 48.1, 48.2])\\n \\n # Inset colorbar\\n from mpl_toolkits.axes_grid1.inset_locator import inset_axes\\n cbaxes = inset_axes(ax, width=\\\"4%\\\", height=\\\"30%\\\", loc='upper right', borderpad=3)\\n fig.colorbar(cs, cax=cbaxes, orientation='vertical')\\n \\n #pfun.add_bathy_contours(ax, ds)\\n pfun.add_coast(ax)\\n ax.axis(aa)\\n pfun.dar(ax)\\n ax.set_xlabel('Longitude')\\n ax.set_title(tstr)\\n \\n pfun.add_velocity_vectors(ax, ds, in_dict['fn'], v_scl=100, v_leglen=1,\\n nngrid=80, zlev='top', center=(.1,.05))\\n \\n fig.tight_layout()\\n # FINISH\\n ds.close()\\n if len(in_dict['fn_out']) > 0:\\n plt.savefig(in_dict['fn_out'])\\n plt.close()\\n else:\\n plt.show()\\n plt.rcdefaults()\",\n \"def plot_results(models,\\n data,\\n batch_size=128,\\n model_name=\\\"vae_mnist\\\"):\\n\\n encoder, decoder = models\\n x_test, y_test = data\\n os.makedirs(model_name, exist_ok=True)\\n\\n filename = os.path.join(model_name, \\\"vae_mean.png\\\")\\n # display a 2D plot of the digit classes in the latent space\\n z_mean, _, _ = encoder.predict(x_test,\\n batch_size=batch_size)\\n plt.figure(figsize=(12, 10))\\n plt.scatter(z_mean[:, 0], z_mean[:, 1], c=y_test)\\n plt.colorbar()\\n plt.xlabel(\\\"z[0]\\\")\\n plt.ylabel(\\\"z[1]\\\")\\n plt.savefig(filename)\\n plt.show()\\n\\n filename = os.path.join(model_name, \\\"digits_over_latent.png\\\")\\n # display a 30x30 2D manifold of digits\\n n = 30\\n digit_size = 28\\n figure = np.zeros((digit_size * n, digit_size * n))\\n # linearly spaced coordinates corresponding to the 2D plot\\n # of digit classes in the latent space\\n grid_x = np.linspace(-4, 4, n)\\n grid_y = np.linspace(-4, 4, n)[::-1]\\n\\n for i, yi in enumerate(grid_y):\\n for j, xi in enumerate(grid_x):\\n z_sample = np.array([[xi, yi]])\\n x_decoded = decoder.predict(z_sample)\\n digit = x_decoded[0].reshape(digit_size, digit_size)\\n figure[i * digit_size: (i + 1) * digit_size,\\n j * digit_size: (j + 1) * digit_size] = digit\\n\\n plt.figure(figsize=(10, 10))\\n start_range = digit_size // 2\\n end_range = n * digit_size + start_range + 1\\n pixel_range = np.arange(start_range, end_range, digit_size)\\n sample_range_x = np.round(grid_x, 1)\\n sample_range_y = np.round(grid_y, 1)\\n plt.xticks(pixel_range, sample_range_x)\\n plt.yticks(pixel_range, sample_range_y)\\n plt.xlabel(\\\"z[0]\\\")\\n plt.ylabel(\\\"z[1]\\\")\\n plt.imshow(figure, cmap='Greys_r')\\n plt.savefig(filename)\\n plt.show()\",\n \"def plotSnr2Density_TT_lines(self):\\n # ell values for phi\\n #L = np.logspace(np.log10(10.), np.log10(1.e4), 5, 10.)\\n #L = np.array([10., 1.e2, 5.e2])\\n L = [100.]\\n \\n # ell values for T\\n L1 = np.logspace(np.log10(10.), np.log10(6.e4), 501, 10.)\\n\\n fig=plt.figure(0)\\n ax=fig.add_subplot(111)\\n #\\n for iL in range(len(L)):\\n f = lambda l1: self.snr2DensitySymLowL_TT(L[iL], l1)\\n snr2Density = np.array(map(f, L1))\\n # expected value if only counting number of modes\\n dNLkappadlnl_theory = L1**2 / (np.pi)# * L[iL]**4\\n\\n # save the values for future use\\n data = np.zeros((len(L1), 3))\\n data[:,0] = L1.copy()\\n data[:,1] = snr2Density\\n data[:,2] = dNLkappadlnl_theory\\n path = \\\"./output/cmblensrec/\\\"+self.CMB.name+\\\"/dsnr2_dlnl_L\\\"+intExpForm(L[iL])+\\\".txt\\\"\\n print \\\"saving to \\\"+path\\n np.savetxt(path, data)\\n \\n # normalize both, for plot\\n dNLkappadlnl_theory /= np.max(snr2Density)\\n snr2Density /= np.max(snr2Density)#[np.where(L1 <= 5.e3)]) # just to rescale in plot\\n #ax.plot(L1, snr2Density, lw=2, c=plt.cm.jet(1.*iL/len(L)), label=r'$L_\\\\phi=$'+str(int(L[iL])))\\n ax.plot(L1, snr2Density, lw=2, c='r', label=r'$L_\\\\phi=$'+str(int(L[iL])))\\n ax.plot(L1, dNLkappadlnl_theory, 'r', ls='--', lw=1)\\n #\\n ax.legend(loc=1)\\n ax.set_xscale('log', nonposx='clip')\\n ax.set_xlabel(r'$\\\\ell_T$')\\n ax.set_ylabel(r'$d\\\\text{SNR}(\\\\phi_L)^2/d\\\\text{ln}\\\\ell_T$')\\n #ax.set_xlim((1., 5.e3))\\n ax.set_ylim((0., 1.1))\\n #\\n path = \\\"./figures/cmblensrec/dsnr2_dl_test.pdf\\\"\\n fig.savefig(path, bbox_inches='tight')\\n \\n plt.show()\\n\\n return L1, snr2Density\",\n \"def read_SimCenter_DL_input(input_path, verbose=False):\\n \\n with open(input_path, 'r') as f:\\n jd = json.load(f)\\n\\n # get the data required for DL\\n data = dict([(label, dict()) for label in [\\n 'general', 'units', 'components', 'collapse_modes',\\n 'decision_variables', 'dependencies'\\n ]])\\n\\n LM = jd['LossModel']\\n\\n # decision variables of interest\\n # We assume that these are always specified in the file.\\n DV = LM['DecisionVariables']\\n for target_att, source_att in [\\n ['injuries', 'Injuries'],\\n ['rec_cost', 'ReconstructionCost'],\\n ['rec_time', 'ReconstructionTime'],\\n ['red_tag', 'RedTag'],\\n ]:\\n data['decision_variables'].update({target_att: bool(DV[source_att])})\\n DV = data['decision_variables']\\n\\n # general information\\n if 'GeneralInformation' in jd:\\n GI = jd['GeneralInformation']\\n else:\\n GI = None\\n\\n # units\\n if (GI is not None) and ('units' in GI.keys()):\\n for key, value in GI['units'].items():\\n if value == 'in':\\n value = 'inch'\\n if value in globals().keys():\\n data['units'].update({key: globals()[value]})\\n else:\\n warnings.warn(UserWarning(\\n \\\"Unknown {} unit: {}\\\".format(key, value)\\n ))\\n if 'length' in data['units'].keys():\\n data['units'].update({\\n 'area': data['units']['length']**2.,\\n 'volume': data['units']['length']**3. \\n })\\n if 'acceleration' not in data['units'].keys():\\n data['units'].update({\\n 'acceleration': \\n data['units']['length'] / data['units']['time'] ** 2.})\\n else:\\n warnings.warn(UserWarning(\\n \\\"No units were specified in the input file. Standard units are \\\"\\n \\\"assumed.\\\"))\\n data['units'].update({\\n 'force': 1.,\\n 'length': 1.,\\n 'area': 1.,\\n 'volume': 1.,\\n 'acceleration': 1.,\\n })\\n\\n # other attributes\\n for target_att, source_att, f_conv, unit_kind, dv_req in [\\n ['plan_area', 'planArea', float, 'area', 'injuries'],\\n # The following lines are commented out for now, because we do not use\\n # these pieces of data anyway.\\n #['stories', 'stories', int, ''],\\n #['building_type', 'type', str, ''],\\n #['height', 'height', float, 'length'],\\n #['year_built', 'year', int, ''],\\n ]:\\n if (GI is not None) and (source_att in GI.keys()):\\n #if unit_kind is not '':\\n # f_unit = data['units'][unit_kind]\\n #else:\\n # f_unit = 1\\n f_unit = data['units'][unit_kind]\\n att_value = f_conv(GI[source_att]) * f_unit\\n data['general'].update({target_att: att_value})\\n else:\\n if DV[dv_req]:\\n warnings.warn(UserWarning(\\n \\\"{} is not in the DL input file.\\\".format(source_att)))\\n \\n # components\\n # Having components defined is not necessary, but if a component is defined\\n # then all of its attributes need to be specified.\\n if 'Components' in LM.keys():\\n for comp in LM['Components']:\\n comp_data = {\\n 'quantities' : \\n np.array([float(qnt) for qnt in comp['quantity'].split(',')]),\\n 'csg_weights' : \\n [float(wgt) for wgt in comp['weights'].split(',')],\\n 'dirs' : \\n [int(dir_) for dir_ in comp['directions'].split(',')],\\n 'kind' : 'structural' if comp['structural'] else 'non-structural',\\n 'distribution': comp['distribution'],\\n 'cov' : float(comp['cov']),\\n 'unit' : [float(comp['unit_size']), comp['unit_type']],\\n }\\n # get the location(s) of components based on non-zero quantities\\n comp_data.update({\\n 'locations':(np.where(comp_data['quantities'] > 0.)[0]+1).tolist()\\n })\\n # remove the zeros from the quantities\\n nonzero = comp_data['quantities'] > 0.\\n comp_data['quantities'] = comp_data['quantities'][nonzero].tolist()\\n \\n # scale the quantities according to the specified unit\\n unit_kind = comp_data['unit'][1]\\n if unit_kind not in globals().keys():\\n raise ValueError(\\n \\\"Unknown unit for component {}: {}\\\".format(\\n comp['ID'], unit_kind))\\n \\n # store the component data\\n data['components'].update({comp['ID']: comp_data})\\n else:\\n warnings.warn(UserWarning(\\n \\\"No components were defined in the input file.\\\"))\\n\\n # collapse modes\\n # Having collapse modes defined is not necessary, but if a collapse mode is\\n # defined, then all of its attributes need to be specified.\\n if 'CollapseModes' in LM.keys():\\n for coll_mode in LM['CollapseModes']:\\n cm_data = {\\n 'w' : float(coll_mode['w']),\\n 'injuries' : [float(inj) for inj in\\n coll_mode['injuries'].split(',')],\\n 'affected_area': [float(cfar) for cfar in\\n coll_mode['affected_area'].split(',')],\\n }\\n data['collapse_modes'].update({coll_mode['name']: cm_data})\\n else:\\n warnings.warn(UserWarning(\\n \\\"No collapse modes were defined in the input file.\\\"))\\n\\n # the number of realizations has to be specified in the file \\n if (('UncertaintyQuantification' in LM) and \\n ('Realizations' in LM['UncertaintyQuantification'])):\\n data['general'].update({\\n 'realizations': int(LM['UncertaintyQuantification'][\\n 'Realizations'])})\\n else:\\n raise ValueError(\\n \\\"Number of realizations is not specified in the input file.\\\")\\n\\n # this is a convenience function for converting strings to float or None\\n def float_or_None(text):\\n return float(text) if text != '' else None\\n \\n EDP_units = dict(\\n # PID is not here because it is unitless\\n PFA = 'acceleration'\\n )\\n\\n # other general info\\n if 'BuildingDamage' in LM.keys():\\n if 'CollapseLimits' in LM['BuildingDamage'].keys():\\n data['general'].update({\\n 'collapse_limits':\\n dict([(key, float_or_None(value)) for key, value in\\n LM['BuildingDamage']['CollapseLimits'].items()])})\\n # scale the limits by the units\\n DGCL = data['general']['collapse_limits']\\n for EDP_kind, value in DGCL.items():\\n if (EDP_kind in EDP_units.keys()) and (value is not None):\\n f_EDP = data['units'][EDP_units[EDP_kind]]\\n DGCL[EDP_kind] = DGCL[EDP_kind] * f_EDP\\n else:\\n warnings.warn(UserWarning(\\n \\\"Collapse EDP limits were not defined in the input file. \\\"\\n \\\"Infinite EDP limits are assumed.\\\"))\\n \\n if 'IrrepairableResidualDrift' in LM['BuildingDamage'].keys():\\n data['general'].update({\\n 'irrepairable_res_drift':\\n dict([(key, float_or_None(value)) for key, value in\\n LM['BuildingDamage'][\\n 'IrrepairableResidualDrift'].items()])})\\n elif DV['rec_cost'] or DV['rec_time']:\\n warnings.warn(UserWarning(\\n \\\"Residual drift limits corresponding to irrepairable \\\"\\n \\\"damage were not defined in the input file. We assume that \\\"\\n \\\"damage is repairable regardless of the residual drift.\\\"))\\n \\n if 'ReplacementCost' in LM['BuildingDamage'].keys():\\n data['general'].update({\\n 'replacement_cost': float_or_None(\\n LM['BuildingDamage']['ReplacementCost'])})\\n elif DV['rec_cost']:\\n warnings.warn(UserWarning(\\n \\\"Building replacement cost was not defined in the input file.\\\"))\\n \\n if 'ReplacementTime' in LM['BuildingDamage'].keys():\\n data['general'].update({\\n 'replacement_time': float_or_None(\\n LM['BuildingDamage']['ReplacementTime'])})\\n elif DV['rec_time']:\\n warnings.warn(UserWarning(\\n \\\"Building replacement time was not defined in the input file.\\\"))\\n else:\\n warnings.warn(UserWarning(\\n \\\"Building damage characteristics were not defined in the input \\\"\\n \\\"file\\\"))\\n \\n if 'BuildingResponse' in LM.keys():\\n if 'DetectionLimits' in LM['BuildingResponse'].keys():\\n data['general'].update({\\n 'detection_limits':\\n dict([(key, float_or_None(value)) for key, value in\\n LM['BuildingResponse']['DetectionLimits'].items()])})\\n # scale the limits by the units\\n DGDL = data['general']['detection_limits']\\n for EDP_kind, value in DGDL.items():\\n if (EDP_kind in EDP_units.keys()) and (value is not None):\\n f_EDP = data['units'][EDP_units[EDP_kind]]\\n DGDL[EDP_kind] = DGDL[EDP_kind] * f_EDP\\n else:\\n warnings.warn(UserWarning(\\n \\\"EDP detection limits were not defined in the input file.\\\"))\\n \\n if 'YieldDriftRatio' in LM['BuildingResponse'].keys():\\n data['general'].update({\\n 'yield_drift': float_or_None(\\n LM['BuildingResponse']['YieldDriftRatio'])})\\n elif DV['rec_cost'] or DV['rec_time']:\\n warnings.warn(UserWarning(\\n \\\"Yield drift ratio was not defined in the input file.\\\"))\\n \\n else:\\n warnings.warn(UserWarning(\\n \\\"Building response characteristics were not defined in the input \\\"\\n \\\"file.\\\"))\\n \\n if 'AdditionalUncertainty' in LM['UncertaintyQuantification'].keys():\\n data['general'].update({\\n 'added_uncertainty': {\\n 'beta_gm': float_or_None(\\n LM['UncertaintyQuantification']['AdditionalUncertainty'][\\n 'GroundMotion']),\\n 'beta_m' : float_or_None(\\n LM['UncertaintyQuantification']['AdditionalUncertainty'][\\n 'Modeling'])}})\\n else:\\n warnings.warn(UserWarning(\\n \\\"No additional uncertainties were defined in the input file.\\\"))\\n \\n if 'Inhabitants' in LM.keys():\\n if 'OccupancyType' in LM['Inhabitants'].keys():\\n data['general'].update({\\n 'occupancy_type': LM['Inhabitants']['OccupancyType']})\\n elif DV['injuries']:\\n warnings.warn(UserWarning(\\n \\\"Occupancy type was not defined in the input file.\\\"))\\n \\n if 'PeakPopulation' in LM['Inhabitants'].keys():\\n data['general'].update({\\n 'population': [float(pop) for pop in\\n LM['Inhabitants']['PeakPopulation'].split(',')]})\\n elif DV['injuries']:\\n warnings.warn(UserWarning(\\n \\\"Peak population was not defined in the input file.\\\"))\\n elif DV['injuries']:\\n warnings.warn(UserWarning(\\n \\\"Information about inhabitants was not defined in the input file.\\\"))\\n\\n # dependencies\\n # We assume 'Independent' for all unspecified fields except for the \\n # fragilities where 'per ATC recommendation' is the default setting.\\n dependency_to_acronym = {\\n 'btw. Fragility Groups' : 'FG',\\n 'btw. Performance Groups': 'PG',\\n 'btw. Floors' : 'LOC',\\n 'btw. Directions' : 'DIR',\\n 'btw. Damage States' : 'DS',\\n 'Independent' : 'IND',\\n 'per ATC recommendation' : 'ATC',\\n }\\n \\n if 'LossModelDependencies' in LM:\\n DEP = LM['LossModelDependencies']\\n else:\\n DEP = None\\n \\n for target_att, source_att, dv_req in [\\n ['quantities', 'Quantities', ''],\\n ['fragilities', 'Fragilities', ''],\\n ['injuries', 'Injuries', 'injuries'],\\n ['rec_costs', 'ReconstructionCosts', 'rec_cost'],\\n ['rec_times', 'ReconstructionTimes', 'rec_time'],\\n ['red_tags', 'RedTagProbabilities', 'red_tag'],\\n ]:\\n if (DEP is not None) and (source_att in DEP.keys()):\\n data['dependencies'].update({\\n target_att:dependency_to_acronym[DEP[source_att]]})\\n elif dv_req == '' or DV[dv_req]:\\n if target_att is not 'fragilities':\\n data['dependencies'].update({target_att: 'IND'})\\n else:\\n data['dependencies'].update({target_att: 'ATC'})\\n \\n warnings.warn(UserWarning(\\n \\\"Correlation between {} was not \\\".format(source_att)+\\n \\\"defined in the input file. Using default values.\\\"))\\n \\n if (DEP is not None) and ('CostAndTime' in DEP.keys()):\\n data['dependencies'].update({'cost_and_time': bool(DEP['CostAndTime'])})\\n elif DV['rec_cost'] or DV['rec_time']:\\n data['dependencies'].update({'cost_and_time': False})\\n warnings.warn(UserWarning(\\n \\\"Correlation between reconstruction cost and time was not defined \\\"\\n \\\"in the input file. Using default values.\\\"))\\n\\n if (DEP is not None) and ('InjurySeverities' in DEP.keys()):\\n data['dependencies'].update({'injury_lvls': \\n bool(DEP['InjurySeverities'])})\\n elif DV['injuries']:\\n data['dependencies'].update({'injury_lvls': False})\\n warnings.warn(UserWarning(\\n \\\"Correlation between injury levels was not defined in the input \\\"\\n \\\"file. Using default values.\\\"))\\n\\n if verbose: pp.pprint(data)\\n \\n return data\",\n \"def load_gnss_logs(prefix):\\n\\n sat_data = loadmat(prefix + 'satposecef.mat')\\n all_sat_pos = sat_data[\\\"svPoss\\\"][1:,:,:3] # ECEF coordinates (meters)\\n ion_correction = sat_data[\\\"svPoss\\\"][1:,:,3] # meters\\n sat_clock_bias = sat_data[\\\"svPoss\\\"][1:,:,4] # seconds\\n\\n # Load data and correct for ionosphere and satellite clock bias\\n pr_data = loadmat(prefix + 'ranges.mat')\\n if pr_data[\\\"pseudoranges\\\"].ndim == 2:\\n all_pr = pr_data[\\\"pseudoranges\\\"][1:,:] + ion_correction + C*sat_clock_bias\\n sats = pr_data[\\\"pseudoranges\\\"][0,:] # satellite SVID\\n pos_only = True\\n print('Assuming data at 1 Hz with t0 = 0')\\n times = range(all_pr.shape[0])\\n\\n elif pr_data[\\\"pseudoranges\\\"].ndim == 3:\\n all_pr = pr_data[\\\"pseudoranges\\\"][1:,:,0] + ion_correction + C*sat_clock_bias\\n all_pr_rate = pr_data[\\\"pseudoranges\\\"][1:,:,1]\\n all_sat_vel = pr_data[\\\"pseudoranges\\\"][1:,:,2:5]\\n if pr_data[\\\"pseudoranges\\\"].shape[2] == 6:\\n times = np.max(pr_data[\\\"pseudoranges\\\"][1:,:,5], axis=1)\\n else:\\n print('Assuming data at 1 Hz with t0 = 0')\\n times = range(all_pr.shape[0])\\n sats = pr_data[\\\"pseudoranges\\\"][0,:,0] # satellite SVID\\n pos_only = False\\n\\n # Parse the data by time step and remove all invalid data (NaN)\\n T, N = all_pr.shape\\n sat_pos = []\\n sat_vel = []\\n pr = []\\n pr_rate = []\\n for t in range(T):\\n # Only take measurements that are not NaN\\n sat_pos_t = np.array([]).reshape(0,3)\\n sat_vel_t = np.array([]).reshape(0,3)\\n pr_t = np.array([])\\n pr_rate_t = np.array([])\\n for i in range(N):\\n if not np.all(all_sat_pos[t,i,:] == 0.0) and not np.isnan(all_pr[t,i]):\\n if pos_only:\\n sat_pos_t = np.vstack((sat_pos_t, all_sat_pos[t,i,:].reshape((1,3))))\\n pr_t = np.hstack((pr_t, all_pr[t,i]))\\n else:\\n sat_pos_t = np.vstack((sat_pos_t, all_sat_pos[t,i,:].reshape((1,3))))\\n sat_vel_t = np.vstack((sat_vel_t, all_sat_vel[t,i,:].reshape((1,3))))\\n pr_t = np.hstack((pr_t, all_pr[t,i]))\\n pr_rate_t = np.hstack((pr_rate_t, all_pr_rate[t,i]))\\n\\n # Append data from time t to list\\n sat_pos.append(sat_pos_t)\\n sat_vel.append(sat_vel_t)\\n pr.append(pr_t)\\n pr_rate.append(pr_rate_t)\\n\\n # Store data in dictionary\\n data = {\\\"t\\\":times, \\\"sats\\\":sats, \\\"sat_pos\\\":sat_pos, \\\"pr\\\":pr}\\n if not pos_only:\\n data[\\\"sat_vel\\\"] = sat_vel\\n data[\\\"pr_rate\\\"] = pr_rate\\n\\n return data\",\n \"def _fix_slovenian_lpis(self, eopatch):\\n eopatch.vector_timeless[self.feature].rename(index=str, columns={\\\"SIFRA_KMRS\\\": \\\"crop_geopedia_idx\\\"},\\n inplace=True)\\n eopatch.vector_timeless[self.feature] = pd.merge(eopatch.vector_timeless[self.feature],\\n self.mapping,\\n on='crop_geopedia_idx')\\n eopatch.vector_timeless[self.feature].loc[eopatch.vector_timeless[self.feature]['SIFKMRS'] == '204_a',\\n 'SIFKMRS'] = '1204'\\n eopatch.vector_timeless[self.feature]['SIFKMRS'] = pd.to_numeric(eopatch.vector_timeless[self.feature]['SIFKMRS'])\",\n \"def add_line_sSFR_obs(line,L_line,ax,**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n # --- Observations compiled in Observations.ipynb ---\\n\\n L_obs = np.array([])\\n sSFR_obs = np.array([])\\n\\n if p.plot: print('\\\\nObserved galaxies with %s:' % line)\\n\\n # Cormier et al. 2015 and Madden et al. 2013\\n df = pd.read_pickle('data/observations/DGS_Cormier_2015') \\n try:\\n df = pd.read_pickle('data/observations/DGS_Cormier_2015')\\n if p.plot: \\n ax.errorbar(10.**df.sSFR,df['L_'+line],yerr=df['e_'+line], elinewidth=1,marker='s',ms=5,mew=0,\\\\\\n color='grey',alpha=0.8,lw=0)\\n # ax.plot(10.**df.sSFR,df['L_'+line],'s',ms=5,mew=0,color='grey',alpha=0.8,label='Cormier+15 (dwarfs)')\\n L_ul = df['L_'+line][df['L_'+line] < 0]\\n if len(L_ul) > 0:\\n ax.plot(10.**df.sSFR[df['L_'+line] < 0],L_ul,'s',ms=5,mew=0,color='grey',alpha=0.8)\\n ax.errorbar(10.**df.sSFR[df['L_'+line] < 0],L_ul, elinewidth=1,\\\\\\n uplims=np.ones(len(L_ul)),yerr=0.3,color='grey',alpha=0.8,lw=0)\\n #-1.*L_ul - 10.**(np.log10(-1.*L_ul)-0.3)\\n L_obs = np.append(L_obs,df['L_'+line].values)\\n # print(df['L_'+line].values)\\n sSFR_obs = np.append(sSFR_obs,df.sSFR.values)\\n if p.plot: print('%i galaxies from Cormier+15 with positiv flux' % (len(df['L_'+line].values[df['L_'+line].values > 0])))\\n # print('min SFR: ',np.min(df.SFR.values[df.sizes < 47]))\\n except:\\n pass\",\n \"def reconstruct(self, lam = 0.0001, display=False):\\n \\n self.history = {}\\n \\n x = utils.initImage(self.data, self.fov, self.scales[0], self.pulse_ft)\\n \\n if display:\\n plt.ion()\\n plt.show()\\n self.__fig, self.__axs = plt.subplots(1, 2)\\n plt.subplots_adjust(wspace=-0.1)\\n self.__display(x, np.zeros_like(x), 'Initialization')\\n \\n self.history['init'] = x\\n \\n for scale in self.scales:\\n\\n x = utils.upscaleImage(x, self.fov, scale, self.pulse)\\n \\n gammas = (utils.ftVectors(self.data['bi_uvcoord1'], self.fov, \\n scale, self.pulse_ft),\\n utils.ftVectors(self.data['bi_uvcoord2'], self.fov, \\n scale, self.pulse_ft),\\n utils.ftVectors(self.data['bi_uvcoord3'], self.fov, \\n scale, self.pulse_ft))\\n \\n for beta in self.betas:\\n \\n # (a) solve for Z while keeping x constant\\n Z = utils.mostLikelyPatches(x, beta, self.data, \\n self.patch_size, self.gmm)\\n \\n # (b) solve for x while keeping Z constant\\n x = utils.taylorExpansion(x, Z, beta, self.data, gammas,\\n self.patch_size, lam=lam)\\n \\n if display:\\n self.__axs[0].clear()\\n self.__axs[1].clear()\\n self.__display(x, Z, 'Scale: ' + str(scale) + '\\\\n' +\\\\\\n r'$\\\\beta$: ' + str(beta))\\n self.history[scale] = x\\n \\n if display:\\n plt.ioff()\\n \\n self.res = np.rot90(utils.upscaleImage(x, self.fov, \\n self.naxis, self.pulse),2)\\n return self.res\",\n \"def show_map(pdb,show_sticks_all=False, show_sticks_metalbinding=True, show_probes=True, show_pdb_metals=True):\\n view=py3Dmol.view(width=1000, height=800)\\n\\n view.addModel(open(pdb+'.pdb', 'r').read(),'pdb')\\n if show_probes:\\n view.addModel(open(pdb+'_PredictedSites.xyz', 'r').read(),'xyz')\\n probes = open(pdb+'_PredictedSites.xyz', 'r').readlines()\\n if(int(probes[0])!=0):\\n probabilities = [p.replace('#','').split()[-1] for p in probes[2:]] # read p from comment in xyz file\\n colors = {}\\n # use different colors for the probabilities\\n for i,x in enumerate(probabilities):\\n colors[i] = '#%02x%02x%02x' % (0, 128, int(float(x)/float(probabilities[0])*255))\\n else: #no predicted site\\n colors = [] \\n view.addLabel(\\\"No probe predicted\\\", {'position': {'x':0, 'y':0, 'z':0}, 'backgroundColor': '#0080FF', 'fontColor': 'white'});\\n \\n view.zoomTo()\\n view.setBackgroundColor('white')\\n view.setStyle({},{'cartoon': {'color':'gray'}})\\n if show_sticks_all:\\n view.setStyle({}, {'stick':{},'cartoon': {'color':'gray'}})\\n if show_pdb_metals:\\n view.getModel(0).setStyle({'resn':\\\"ZN\\\"},{'sphere': {'opacity':.75}})\\n view.getModel(0).setStyle({'resn':\\\"CA\\\"},{'sphere': {'opacity':.75}})\\n view.getModel(0).setStyle({'resn':\\\"CU\\\"},{'sphere': {'opacity':.75}})\\n view.getModel(0).setStyle({'resn':\\\"HG\\\"},{'sphere': {'opacity':.75}})\\n view.getModel(0).setStyle({'resn':\\\"MG\\\"},{'sphere': {'opacity':.75}})\\n view.getModel(0).setStyle({'resn':\\\"FE\\\"},{'sphere': {'opacity':.75}})\\n view.getModel(0).setStyle({'resn':\\\"MN\\\"},{'sphere': {'opacity':.75}})\\n view.getModel(0).setStyle({'resn':\\\"NI\\\"},{'sphere': {'opacity':.75}})\\n view.getModel(0).setStyle({'resn':\\\"MB\\\"},{'sphere': {'opacity':.75}})\\n \\n if show_probes:\\n view.getModel(1).setStyle({},{'sphere': {'colorscheme':{'prop':'index', 'map':colors}}})\\n \\n # add hoverable labels for the residues and the predicted metals\\n # two callbacks are needed, one for the residues and one for the metals\\n # the metal one displays the probability\\n view.getModel(0).setHoverable({},True,'''function(atom,viewer,event,container) {\\n if(!atom.label) {\\n atom.label = viewer.addLabel(atom.resn+atom.resi+\\\":\\\"+atom.atom,{position: atom, backgroundColor: 'mintcream', fontColor:'black'});\\n }}''',\\n '''function(atom,viewer) { \\n if(atom.label) {\\n viewer.removeLabel(atom.label);\\n delete atom.label;\\n }\\n }''')\\n view.getModel(1).setHoverable({},True,'''function(atom,viewer,event,container) {\\n if(!atom.label) {\\n atom.label = viewer.addLabel(atom.atom+\\\" [\\\"+atom.serial+\\\"]\\\",{position: atom, backgroundColor: 'mintcream', fontColor:'black'});\\n }}''',\\n '''function(atom,viewer) { \\n if(atom.label) {\\n viewer.removeLabel(atom.label);\\n delete atom.label;\\n }\\n }''')\\n if show_sticks_metalbinding:\\n view.setStyle({'resn':\\\"HIS\\\"},{'stick': {}, 'cartoon': {'color':'gray'}})\\n view.setStyle({'resn':\\\"ASP\\\"},{'stick': {}, 'cartoon': {'color':'gray'}})\\n view.setStyle({'resn':\\\"GLU\\\"},{'stick': {}, 'cartoon': {'color':'gray'}})\\n view.setStyle({'resn':\\\"CYS\\\"},{'stick': {}, 'cartoon': {'color':'gray'}})\\n\\n return view.show()\",\n \"def plotTI():\\n min_dl = dlam[dlam != 0].min()\\n S = int(0.4/min_dl)\\n fig = pl.figure(figsize = (8,6))\\n ax = fig.add_subplot(1,1,1)\\n ax.spines['bottom'].set_position('zero')\\n ax.spines['top'].set_color('none')\\n ax.spines['right'].set_color('none')\\n ax.xaxis.set_ticks_position('bottom')\\n ax.yaxis.set_ticks_position('left')\\n\\n for k, spine in ax.spines.items():\\n spine.set_zorder(12.2)\\n\\n xs, ndx, dx = [0], 0, 0.001\\n colors = ['r', 'g', '#7F38EC', '#9F000F', 'b', 'y']\\n min_y, max_y = 0, 0\\n\\n lines = tuple()\\n ## lv_names2 = [r'$Coulomb$', r'$vdWaals$'] ## for the paper\\n lv_names2 = []\\n for j in range(n_components):\\n y = ave_dhdl[:,j]\\n if not (y == 0).all():\\n lv_names2.append(r'$%s$' % P.lv_names[j].capitalize())\\n\\n for j in range(n_components):\\n\\n y = ave_dhdl[:,j]\\n if not (y == 0).all():\\n\\n # Get the coordinates.\\n lj = lchange[:,j]\\n x = lv[:,j][lj]\\n y = y[lj]/P.beta_report\\n\\n if 'TI' in P.methods:\\n # Plot the TI integration area.\\n ss = 'TI'\\n for i in range(len(x)-1):\\n min_y = min(y.min(), min_y)\\n max_y = max(y.max(), max_y)\\n #pl.plot(x,y)\\n if i%2==0:\\n pl.fill_between(x[i:i+2]+ndx, 0, y[i:i+2], color=colors[ndx], alpha=1.0)\\n else:\\n pl.fill_between(x[i:i+2]+ndx, 0, y[i:i+2], color=colors[ndx], alpha=0.5)\\n xlegend = [-100*wnum for wnum in range(len(lv_names2))]\\n pl.plot(xlegend, [0*wnum for wnum in xlegend], ls='-', color=colors[ndx], label=lv_names2[ndx]) ## for the paper\\n\\n if 'TI-CUBIC' in P.methods and not cubspl[j]==0:\\n # Plot the TI-CUBIC interpolation curve.\\n ss += ' and TI-CUBIC'\\n xnew = numpy.arange(0, 1+dx, dx)\\n ynew = cubspl[j].interpolate(y, xnew)\\n min_y = min(ynew.min(), min_y)\\n max_y = max(ynew.max(), max_y)\\n pl.plot(xnew+ndx, ynew, color='#B6B6B4', ls ='-', solid_capstyle='round', lw=3.0)\\n\\n else:\\n # Plot the TI-CUBIC integration area.\\n ss = 'TI-CUBIC'\\n for i in range(len(x)-1):\\n xnew = numpy.arange(x[i], x[i+1]+dx, dx)\\n ynew = cubspl[j].interpolate(y, xnew)\\n ynew[0], ynew[-1] = y[i], y[i+1]\\n min_y = min(ynew.min(), min_y)\\n max_y = max(ynew.max(), max_y)\\n if i%2==0:\\n pl.fill_between(xnew+ndx, 0, ynew, color=colors[ndx], alpha=1.0)\\n else:\\n pl.fill_between(xnew+ndx, 0, ynew, color=colors[ndx], alpha=0.5)\\n\\n # Store the abscissa values and update the subplot index.\\n xs += (x+ndx).tolist()[1:]\\n ndx += 1\\n\\n # Make sure the tick labels are not overcrowded.\\n xs = numpy.array(xs)\\n dl_mat = numpy.array([xs-i for i in xs])\\n ri = range(len(xs))\\n\\n def getInd(r=ri, z=[0]):\\n primo = r[0]\\n min_dl=ndx*0.02*2**(primo>10)\\n if dl_mat[primo].max()<min_dl:\\n return z\\n for i in r:\\n for j in range(len(xs)):\\n if dl_mat[i,j]>min_dl:\\n z.append(j)\\n return getInd(ri[j:], z)\\n\\n xt = [i if (i in getInd()) else '' for i in range(K)]\\n pl.xticks(xs[1:], xt[1:], fontsize=10)\\n pl.yticks(fontsize=10)\\n #ax = pl.gca()\\n #for label in ax.get_xticklabels():\\n # label.set_bbox(dict(fc='w', ec='None', alpha=0.5))\\n\\n # Remove the abscissa ticks and set up the axes limits.\\n for tick in ax.get_xticklines():\\n tick.set_visible(False)\\n pl.xlim(0, ndx)\\n min_y *= 1.01\\n max_y *= 1.01\\n pl.ylim(min_y, max_y)\\n\\n for i,j in zip(xs[1:], xt[1:]):\\n pl.annotate(('%.2f' % (i-1.0 if i>1.0 else i) if not j=='' else ''), xy=(i, 0), xytext=(i, 0.01), size=10, rotation=90, textcoords=('data', 'axes fraction'), va='bottom', ha='center', color='#151B54')\\n if ndx>1:\\n lenticks = len(ax.get_ymajorticklabels()) - 1\\n if min_y<0: lenticks -= 1\\n if lenticks < 5:\\n from matplotlib.ticker import AutoMinorLocator as AML\\n ax.yaxis.set_minor_locator(AML())\\n pl.grid(which='both', color='w', lw=0.25, axis='y', zorder=12)\\n pl.ylabel(r'$\\\\mathrm{\\\\langle{\\\\frac{ \\\\partial U } { \\\\partial \\\\lambda }}\\\\rangle_{\\\\lambda}\\\\/%s}$' % P.units, fontsize=20, color='#151B54')\\n pl.annotate('$\\\\mathit{\\\\lambda}$', xy=(0, 0), xytext=(0.5, -0.05), size=18, textcoords='axes fraction', va='top', ha='center', color='#151B54')\\n if not P.software.title()=='Sire':\\n lege = ax.legend(prop=FP(size=14), frameon=False, loc=1)\\n for l in lege.legendHandles:\\n l.set_linewidth(10)\\n pl.savefig(os.path.join(P.output_directory, 'dhdl_TI.pdf'))\\n pl.close(fig)\\n return\",\n \"def _build_plotels(self, model):\\n nplotels = len(model.plotels)\\n if nplotels:\\n # sorting these don't matter, but why not?\\n #lines = [element.node_ids for unused_eid, element in sorted(model.plotels.items())]\\n lines = []\\n for unused_eid, element in sorted(model.plotels.items()):\\n node_ids = element.node_ids\\n lines.append(node_ids)\\n lines = np.array(lines, dtype='int32')\\n\\n self.gui.create_alternate_vtk_grid(\\n 'plotel', color=RED_FLOAT, line_width=2, opacity=0.8,\\n point_size=5, representation='wire', is_visible=True)\\n self._add_nastran_lines_to_grid('plotel', lines, model)\",\n \"def __init__(self, votable, url=None):\\n super(SLAResults, self).__init__(votable, url, \\\"sla\\\", \\\"1.0\\\")\\n self._slacols = {\\n\\n\\n \\\"ssldm:Line.title\\\": self.fieldname_with_utype(\\\"ssldm:Line.title\\\"),\\n \\\"ssldm:Line.wavelength.value\\\": self.fieldname_with_utype(\\\"ssldm:Line.wavelength.value\\\"),\\n \\\"ssldm:Line.initialLevel.energy.value\\\": self.fieldname_with_utype(\\\"ssldm:Line.initialLevel.energy.value\\\"),\\n \\\"ssldm:Line.finalLevel.energy.value\\\": self.fieldname_with_utype(\\\"ssldm:Line.finalLevel.energy.value\\\"),\\n \\\"ssldm:Line.environment.temperature.value\\\": self.fieldname_with_utype(\\\"ssldm:Line.environment.temperature.value\\\"),\\n \\\"ssldm:Line.einsteinA.value\\\": self.fieldname_with_utype(\\\"ssldm:Line.einsteinA.value\\\"),\\n \\\"ssldm:Process.type\\\": self.fieldname_with_utype(\\\"ssldm:Process.type\\\"),\\n \\\"ssldm:Process.name\\\": self.fieldname_with_utype(\\\"ssldm:Process.name\\\"),\\n \\\"ssldm:Line.identificationStatus\\\": self.fieldname_with_utype(\\\"ssldm:Line.identificationStatus\\\"),\\n \\\"ssldm:Line.species.name\\\": self.fieldname_with_utype(\\\"ssldm:Line.species.name\\\"),\\n \\\"ssldm:Line.initialLevel.name\\\": self.fieldname_with_utype(\\\"ssldm:Line.initialLevel.name\\\"),\\n \\\"ssldm:Line.finalLevel.name\\\": self.fieldname_with_utype(\\\"ssldm:Line.finalLevel.name\\\"),\\n \\\"ssldm:Line.observedWavelength.value\\\": self.fieldname_with_utype(\\\"ssldm:Line.observedWavelength.value\\\"),\\n \\\"slap:Query.Score\\\": self.fieldname_with_utype(\\\"slap:Query.Score\\\"),\\n \\\"ssldm:Line.initialLevel.configuration\\\": self.fieldname_with_utype(\\\"ssldm:Line.initialLevel.configuration\\\"),\\n \\\"ssldm:Line.finalLevel.configuration\\\": self.fieldname_with_utype(\\\"ssldm:Line.finalLevel.configuration\\\"),\\n \\\"ssldm:Line.initialLevel.quantumState\\\": self.fieldname_with_utype(\\\"ssldm:Line.initialLevel.quantumState\\\"),\\n \\\"ssldm:Line.finalLevel.quantumState\\\": self.fieldname_with_utype(\\\"ssldm:Line.finalLevel.quantumState\\\"),\\n \\\"Target.Name\\\": self.fieldname_with_utype(\\\"Target.Name\\\"),\\n \\\"char:SpatialAxis.Coverage.Location.Value\\\": self.fieldname_with_utype(\\\"char:SpatialAxis.Coverage.Location.Value\\\"),\\n \\\"char:TimeAxis.Coverage.Bounds.Start\\\": self.fieldname_with_utype(\\\"char:TimeAxis.Coverage.Bounds.Start\\\"),\\n \\\"char:TimeAxis.Coverage.Bounds.Stop\\\": self.fieldname_with_utype(\\\"char:TimeAxis.Coverage.Bounds.Stop\\\")\\n }\\n self._recnames = { \\n \\\"title\\\": self._slacols[\\\"ssldm:Line.title\\\"],\\n \\\"wavelength\\\": self._slacols[\\\"ssldm:Line.wavelength.value\\\"],\\n \\\"status\\\": self._slacols[\\\"ssldm:Line.identificationStatus\\\"],\\n \\\"species_name\\\": self._slacols[\\\"ssldm:Line.species.name\\\"],\\n \\\"initial_level\\\": self._slacols[\\\"ssldm:Line.initialLevel.name\\\"],\\n \\\"final_level\\\": self._slacols[\\\"ssldm:Line.finalLevel.name\\\"]\\n }\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.57275915","0.5662032","0.55496144","0.5544452","0.55086404","0.54077375","0.5395589","0.5380696","0.5337075","0.53228354","0.53110796","0.52550274","0.52178866","0.51859766","0.51779294","0.5175796","0.51676625","0.51582605","0.514516","0.51354164","0.5121987","0.5121472","0.5105393","0.5091072","0.5040507","0.50354785","0.5023343","0.50154614","0.50135225","0.49995044","0.499856","0.49789524","0.49743235","0.49682528","0.49523276","0.49223217","0.4918402","0.49096808","0.49033636","0.488578","0.4884679","0.4873033","0.48688465","0.4857919","0.48536795","0.48389283","0.48366952","0.483635","0.48252103","0.4821574","0.48142132","0.48135465","0.4809478","0.4802599","0.48016343","0.4796794","0.47942945","0.47938794","0.4790098","0.47878298","0.47827262","0.47765025","0.4774262","0.47679222","0.4764977","0.47646126","0.4760744","0.47594124","0.47430933","0.4743067","0.47389784","0.47342548","0.4728903","0.4723835","0.47231334","0.47182465","0.47167036","0.47164088","0.47162524","0.4711242","0.47102606","0.47059032","0.4705081","0.4702673","0.47009882","0.46998966","0.46930104","0.46900198","0.4689534","0.46870056","0.46849492","0.4684372","0.46839875","0.4681704","0.46707395","0.46693838","0.4666915","0.4666741","0.4664627","0.46633196","0.46601865"],"string":"[\n \"0.57275915\",\n \"0.5662032\",\n \"0.55496144\",\n \"0.5544452\",\n \"0.55086404\",\n \"0.54077375\",\n \"0.5395589\",\n \"0.5380696\",\n \"0.5337075\",\n \"0.53228354\",\n \"0.53110796\",\n \"0.52550274\",\n \"0.52178866\",\n \"0.51859766\",\n \"0.51779294\",\n \"0.5175796\",\n \"0.51676625\",\n \"0.51582605\",\n \"0.514516\",\n \"0.51354164\",\n \"0.5121987\",\n \"0.5121472\",\n \"0.5105393\",\n \"0.5091072\",\n \"0.5040507\",\n \"0.50354785\",\n \"0.5023343\",\n \"0.50154614\",\n \"0.50135225\",\n \"0.49995044\",\n \"0.499856\",\n \"0.49789524\",\n \"0.49743235\",\n \"0.49682528\",\n \"0.49523276\",\n \"0.49223217\",\n \"0.4918402\",\n \"0.49096808\",\n \"0.49033636\",\n \"0.488578\",\n \"0.4884679\",\n \"0.4873033\",\n \"0.48688465\",\n \"0.4857919\",\n \"0.48536795\",\n \"0.48389283\",\n \"0.48366952\",\n \"0.483635\",\n \"0.48252103\",\n \"0.4821574\",\n \"0.48142132\",\n \"0.48135465\",\n \"0.4809478\",\n \"0.4802599\",\n \"0.48016343\",\n \"0.4796794\",\n \"0.47942945\",\n \"0.47938794\",\n \"0.4790098\",\n \"0.47878298\",\n \"0.47827262\",\n \"0.47765025\",\n \"0.4774262\",\n \"0.47679222\",\n \"0.4764977\",\n \"0.47646126\",\n \"0.4760744\",\n \"0.47594124\",\n \"0.47430933\",\n \"0.4743067\",\n \"0.47389784\",\n \"0.47342548\",\n \"0.4728903\",\n \"0.4723835\",\n \"0.47231334\",\n \"0.47182465\",\n \"0.47167036\",\n \"0.47164088\",\n \"0.47162524\",\n \"0.4711242\",\n \"0.47102606\",\n \"0.47059032\",\n \"0.4705081\",\n \"0.4702673\",\n \"0.47009882\",\n \"0.46998966\",\n \"0.46930104\",\n \"0.46900198\",\n \"0.4689534\",\n \"0.46870056\",\n \"0.46849492\",\n \"0.4684372\",\n \"0.46839875\",\n \"0.4681704\",\n \"0.46707395\",\n \"0.46693838\",\n \"0.4666915\",\n \"0.4666741\",\n \"0.4664627\",\n \"0.46633196\",\n \"0.46601865\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":21286,"cells":{"query":{"kind":"string","value":"Defaults setup for pressurization history"},"document":{"kind":"string","value":"def plot_timeDB(timeDB, xunits='yr', yunits='MPa', skip=8, P0=33.0):\n time, pressure = np.loadtxt(timeDB, skiprows=skip, unpack=True)\n pressure = pressure * P0\n\n #if xunits == 'yr':\n # time = time / 31536000.0\n #elif xunits == 'day':\n # time = time / 86400.0\n\n plt.figure()\n plt.plot(time,pressure,'b.-',lw=3,label='pressure')\n plt.xlabel('Time [{}]'.format(xunits))\n plt.ylabel('Pressure [{}]'.format(yunits))\n plt.title('Time History')\n plt.show()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def history():","def initialize(self):\n PostProcessorInterfaceBase.initialize(self)\n self.inputFormat = 'HistorySet'\n self.outputFormat = 'HistorySet'","def Modifier_History(self):\n\t\tpass","def __init__(self, history=None):\n\n self.__history = history if history else []","def onRegisterHistory(self):\n pass","def set_defaults():\n\tglobal defaults\n\n\tdefaults = {}\n\tdefaults[\"aliase\"] = {}\n\n\tdefaults[\"nigiri\"] = {}\n\tdefaults[\"nigiri\"][\"wrap_input\"] = \"True\"\n\tdefaults[\"nigiri\"][\"command_char\"] = \"/\"\n\tdefaults[\"nigiri\"][\"shortcut_pattern\"] = \"meta [0-9]\"\n\tdefaults[\"nigiri\"][\"server_shortcuts\"] = \"true\"\n\tdefaults[\"nigiri\"][\"show_debug\"] = \"True\"\n\tdefaults[\"nigiri\"][\"logfile\"] = os.path.join(xdg_cache_home, \"sushi\", \"nigiri.txt\")\n\tdefaults[\"nigiri\"][\"locale_dir\"] = get_path(\"..\", \"locale\")\n\tdefaults[\"nigiri\"][\"plugin_dirs\"] = escape_join(\",\", (\n\t\t\tos.path.join(xdg_data_home, \"nigiri\", \"plugins\"),\n\t\t\tos.path.join(xdg_data_home, \"chirashi\"),\n\t\t\tget_path(\"plugins\"),\n\t\t\tget_path(\"..\", \"chirashi\")\n\t\t))\n\n\tdefaults[\"chatting\"] = {}\n\tdefaults[\"chatting\"][\"quit_message\"] = \"Quit.\"\n\tdefaults[\"chatting\"][\"part_message\"] = \"Part.\"\n\tdefaults[\"chatting\"][\"last_log_lines\"] = \"15\"\n\tdefaults[\"chatting\"][\"nick_separator\"] = \": \"\n\n\tdefaults[\"colors\"] = {}\n\tdefaults[\"colors\"][\"messages\"] = \"gray\"\n\tdefaults[\"colors\"][\"messages_own\"] = \"white\"\n\tdefaults[\"colors\"][\"messages_highlight\"] = \"red\"\n\tdefaults[\"colors\"][\"actions\"] = \"gray\"\n\tdefaults[\"colors\"][\"actions_own\"] = \"white\"\n\tdefaults[\"colors\"][\"informative\"] = \"blue\"\n\n\tdefaults[\"templates\"] = {}\n\t# misc\n\tdefaults[\"templates\"][\"datestring\"] = \"%H:%M\"\n\t# messages\n\tdefaults[\"templates\"][\"action\"] = \"%(time)s %(nick)s %(message)s\"\n\tdefaults[\"templates\"][\"action_own\"] = \"%(time)s %(nick)s %(message)s\"\n\tdefaults[\"templates\"][\"message\"] = \"%(time)s <%(prefix)s%(nick)s> %(message)s\"\n\tdefaults[\"templates\"][\"message_own\"] = \"%(time)s <%(prefix)s%(nick)s> %(message)s\"\n\tdefaults[\"templates\"][\"ctcp\"] = \"%(time)s -%(nick)s/%(target)s- %(message)s\"\n\tdefaults[\"templates\"][\"ctcp_own\"] = \"%(time)s -%(nick)s/%(target)s- %(message)s\"\n\tdefaults[\"templates\"][\"notice\"] = \"%(time)s *%(nick)s/%(target)s* %(message)s\"\n\tdefaults[\"templates\"][\"notice_own\"] = \"%(time)s *%(nick)s/%(target)s* %(message)s\"\n\n\t# actions\n\tdefaults[\"templates\"][\"invite\"] = \"%(time)s * %(nick)s invites %(who)s to %(channel)s\"\n\tdefaults[\"templates\"][\"invite_own\"] = \"%(time)s * You were invited by %(nick)s to %(channel)s.\"\n\tdefaults[\"templates\"][\"join\"] = \"%(time)s * %(nick)s (%(host)s) has joined %(channel)s.\"\n\tdefaults[\"templates\"][\"join_own\"] = \"%(time)s * You have joined %(channel)s.\"\n\tdefaults[\"templates\"][\"kick\"] = \"%(time)s * %(who)s got kicked from %(channel)s by %(nick)s (%(reason)s)\"\n\tdefaults[\"templates\"][\"kick_own\"] = \"%(time)s * You got kicked from %(channel)s by %(nick)s (%(reason)s)\"\n\tdefaults[\"templates\"][\"nick\"] = \"%(time)s * %(nick)s is now known as %(new_nick)s.\"\n\tdefaults[\"templates\"][\"nick_own\"] = \"%(time)s * You are now known as %(new_nick)s.\"\n\tdefaults[\"templates\"][\"mode_list\"] = \"%(time)s * Modes for %(target)s: %(modes)s.\"\n\tdefaults[\"templates\"][\"mode_list_own\"] = \"%(time)s * Modes set on you: %(modes)s.\"\n\tdefaults[\"templates\"][\"mode\"] = \"%(time)s %(nick)s set %(mode)s%(param)s on %(target)s.\"\n\tdefaults[\"templates\"][\"mode_own\"] = \"%(time)s You set %(mode)s%(param)s on %(target)s.\"\n\tdefaults[\"templates\"][\"oper\"] = \"%(time)s * %(nick)s is now an OPER.\"\n\tdefaults[\"templates\"][\"oper_own\"] = \"%(time)s * You are now an OPER.\"\n\tdefaults[\"templates\"][\"part\"] = \"%(time)s * %(nick)s has left %(channel)s (%(reason)s).\"\n\tdefaults[\"templates\"][\"part_own\"] = \"%(time)s * You have left %(channel)s (%(reason)s).\"\n\tdefaults[\"templates\"][\"quit\"] = \"%(time)s * %(nick)s has quit (%(reason)s).\"\n\tdefaults[\"templates\"][\"quit_own\"] = \"%(time)s * You have quit (%(reason)s).\"\n\tdefaults[\"templates\"][\"topic\"] = \"%(time)s * %(nick)s has set the topic on %(channel)s to \\\"%(topic)s\\\".\"\n\tdefaults[\"templates\"][\"topic_own\"] = \"%(time)s * You have set the topic on %(channel)s to \\\"%(topic)s\\\".\"\n\tdefaults[\"templates\"][\"topic_anonymous\"] = \"* Topic of %(channel)s: %(topic)s\"\n\n\t# informative\n\tdefaults[\"templates\"][\"banlist_begin\"] = \"%(time)s Begin of banlist on channel %(channel)s.\"\n\tdefaults[\"templates\"][\"banlist_item\"] = \">> %(who)s %(mask)s %(when)s\"\n\tdefaults[\"templates\"][\"banlist_end\"] = \"%(time)s End of banlist. (%(channel)s)\"\n\tdefaults[\"templates\"][\"cannot_join\"] = \"%(time)s Can't join channel %(channel)s: %(reason)s\"\n\tdefaults[\"templates\"][\"list_begin\"] = \"%(time)s Begin of list.\"\n\tdefaults[\"templates\"][\"list_item\"] = \">> %(channel)s %(user)s %(topic)s\"\n\tdefaults[\"templates\"][\"list_end\"] = \"%(time)s End of list.\"\n\tdefaults[\"templates\"][\"names_begin\"] = \"%(time)s Begin of names (%(channel)s).\"\n\tdefaults[\"templates\"][\"names_item\"] = \"[ %(row)s ]\"\n\tdefaults[\"templates\"][\"names_end\"] = \"%(time)s End of names.\"\n\tdefaults[\"templates\"][\"no_such\"] = \"%(time)s No such %(type)s: %(target)s.\"\n\tdefaults[\"templates\"][\"whois_begin\"] = \"%(time)s Begin of whois (%(target)s).\"\n\tdefaults[\"templates\"][\"whois_item\"] = \">> %(nick)s: %(message)s\"\n\tdefaults[\"templates\"][\"whois_end\"] = \"%(time)s End of whois.\"\n\tdefaults[\"templates\"][\"dcc_new_incoming\"] = \"%(time)s Incoming file transfer (ID:%(id)d) from %(sender)s: \\\"%(filename)s\\\" (%(size)d).\"\n\tdefaults[\"templates\"][\"dcc_file_auto_accept\"] = \"%(time)s Auto accepted file transfer from %(sender)s: \\\"%(filename)s\\\" (%(size)d).\"\n\n\t# Add default sections to config parser\n\t# so setting is easier\n\tfor section in defaults.keys():\n\t\ttry:\n\t\t\tconfig_parser.add_section(section)\n\t\texcept ConfigParser.DuplicateSectionError:\n\t\t\tcontinue\n\n\t# sections defined below are not added to the configParser and\n\t# can't be set by the set method (will raise NoSectionError)\n\tpass","def setup_hooks(self):\n pass","def defaults():\n return {}","def historical():\n\n return {\n 'page': 'historical',\n }","def tweaks(self) -> None:\n pass","def set_app_defaults(self):\n self.curve_render = 0\n self.image_render = 0\n self.image_height = 200\n self.image_data = []\n self.auto_scale = True\n\n self.create_actions()\n self.setup_signals()\n self.reset_graph()\n\n self.fps = utils.SimpleFPS()\n\n # Click the live button\n self.ui.actionContinue_Live_Updates.trigger()","def defaults() -> dict:\n pass","def history():\n return apology(\"TODO\")","def history():\n return apology(\"TODO\")","def history():\n return apology(\"TODO\")","def autodefaults (self):\r\n\r\n self.defaults_from_notes(identifying_key=EMPTYCHAR,\r\n mark=EQUAL,\r\n obj=self.default_dict['commands'],\r\n entrytext=COMMANDMACROSCRIPT)","def default_config():\n config = Config()\n config.TerminalInteractiveShell.colors = 'NoColor'\n config.TerminalTerminalInteractiveShell.term_title = False,\n config.TerminalInteractiveShell.autocall = 0\n f = tempfile.NamedTemporaryFile(suffix=u'test_hist.sqlite', delete=False)\n config.HistoryManager.hist_file = Path(f.name)\n f.close()\n config.HistoryManager.db_cache_size = 10000\n return config","def __init__( settings={} ):","def initialise(self):","def __init__(self, environment):\n super(HistoricalExtension, self).__init__(environment)\n environment.filters['titlecase'] = titlecase","def initDefaults(self):\n return _libsbml.Event_initDefaults(self)","def add_earlydefault_settings(self):\n self.add_default_settings_config()\n self.add_default_settings_aliases()","def default_forage_args():\n\n forage_args = {\n 'prop_legume': 0.0,\n 'steepness': 1.,\n 'DOY': 1,\n 'start_year': 2016,\n 'start_month': 1,\n 'num_months': 24,\n 'mgmt_threshold': 0.01,\n 'century_dir': 'C:/Users/ginge/Dropbox/NatCap_backup/Forage_model/CENTURY4.6/Century46_PC_Jan-2014',\n 'template_level': 'GH',\n 'fix_file': 'drygfix.100',\n 'user_define_protein': 1,\n 'user_define_digestibility': 0,\n 'herbivore_csv': r\"C:/Users/ginge/Dropbox/NatCap_backup/Mongolia/model_inputs/cashmere_goats.csv\",\n 'grass_csv': r\"C:/Users/ginge/Dropbox/NatCap_backup/Mongolia/model_inputs/grass.csv\",\n 'restart_monthly': 0,\n }\n return forage_args","def post_init(self):\n\t\tpass","def _post_hooks(self):","def presets (self):\n assert False, \"To be implemented by child\"","def setup_default_terms(self):\n # Setting config with pattern -\n # default_dict[\"json config key\"] = (\"Default Value\", \"Ask User\", \"Value Type\")\n\n self.default_terms[Keys.first_run] = (Values.first_run, False, None)\n self.default_terms[Keys.nas_mount] = (Values.nas_mount_path, True, str)\n self.default_terms[Keys.secs_between_checks] = (Values.check_time, True, int)\n self.default_terms[Keys.redmine_api_key] = ('none', False, str)","def set_default_parameters(self):\n super().set_default_parameters()","def _post_init(self):\n pass","def _set_defaults(self):\n self.api_protocol = 'https'\n self.api_host = 'nhl-score-api.herokuapp.com'\n self.current_score = 0\n self.sleep_seconds = 30 # Time to sleep after calling the API\n self.desired_game_state = 'LIVE' # Desired game state is LIVE","def defaults(self):\n self.lib.iperf_defaults(self._test)","def init_tab(self):","def without_defaults(self):\n ...","def initialize_default(self):\n self.initialize_navigation()\n self.initialize_viewport()","def initialize(self, src_sentence):\n self.history = ['<s>'] if self.history_len > 0 else []","def __init__(self):\n self.analytics = Analytics()\n self.menu_options = {\n \"1\": self.add_habit,\n \"2\": self.check_off,\n \"3\": self.delete_habit,\n \"4\": self.see_habit,\n \"5\": self.show_all_habits,\n \"6\": self.habits_same_periodicity,\n \"7\": self.habit_longest_streak,\n \"0\": self.exit,\n\n }","def initDefaults(self):\n return _libsbml.Reaction_initDefaults(self)","def initialize_options(self):","def defaults(self):\n\n return None","def defaults(self):\n\n return None","def _initialize_defaults(self):\n for key, value in defaults.items():\n if key not in self.source_params:\n self.source_params[key] = value","def _initialize_defaults(self):\n for key, value in defaults.items():\n if key not in self.source_params:\n self.source_params[key] = value","def make_initial_state(self):\n pass","def add_settings_early(self):\n pass","def initialize(self):","def initialize(self):","def initialize(self):","def initialize(self):","def set_defaults(self):\n self.plastic = False\n self.unset_output()\n self.reward = False\n self.patmod = config.impact_modulation_default","def __init__(self):\n self.last_reward_pos = 0\n super().__init__()\n self.TERRAIN_VARIANCE = 0.0\n self.stump_spacing = 4.0\n self.stump_height = 1.0\n self.my_init({'leg_length': 35, 'walker_type': 'default'})","def _restore_default(self):\n raise NotImplementedError(\"Should have implemented this.\")","def reset(self):\n # This also resets the history.\n self.__init__(**self.init_kwargs)","def _post_init(self) -> None:\n return","def quick_set_manual_settings(self):\n self.logger.debug(\"Manual conversion settings\")\n self.quick_setting = 'manual'\n self.front_matter_format = 'none'\n self.metadata_schema = []\n if self.conversion_input == 'nsx':\n self.metadata_schema = ['title', 'ctime', 'mtime', 'tag']\n self.spaces_in_tags = False\n self.split_tags = False\n self.first_row_as_header = False\n self.first_column_as_header = False\n self.chart_image = True\n self.chart_csv = True\n self.chart_data_table = True","def _hook(self):","def navigation_hook(self):\r\n pass","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def user_init(self):\n pass","def init_game_setting(self):\r\n pass","def history(self, history):\n self._history = history","def general(self):\n self.dir = 'Stories'\n if not os.path.isdir(self.dir):\n os.mkdir(self.dir)\n\n self.langLock = Semaphore(0)\n self.setLanguage('en-US')\n self.setEyeColour('greenyellow')\n\n self.langLock.acquire()\n\n # pass Google Dialogflow parameters\n self.setDialogflowKey('nao.json')\n self.setDialogflowAgent('nao-wksstn')\n\n self.speechLock = Semaphore(0)","def __init__(self):\n self.__load_settings()\n self.__load_history()\n self.__clear_context()\n\n if self.DELETE_ALL_ON_STARTUP:\n sublime.set_timeout_async(lambda: self.delete_all_history(), 0)\n elif self.CLEANUP_ON_STARTUP:\n sublime.set_timeout_async(lambda: self.clean_history(False), 0)","def _problem_set_up(self):\n self.curr_best_reward = -np.inf\n self.curr_reward = -np.inf\n # Set up history\n self.history.curr_best_reward = []\n self.history.curr_reward = []","def test_hist_init():\n FNAME = 'xonsh-SESSIONID.json'\n FNAME += '.init'\n History(filename=FNAME, here='yup', **HIST_TEST_KWARGS)\n with LazyJSON(FNAME) as lj:\n obs = lj['here']\n assert_equal('yup', obs)\n os.remove(FNAME)","def init():","def __init__(self):\n super(APTHistoryLogTextPlugin, self).__init__()\n self._event_data = None","def loadDefaults(self):\n # (025) Merged into settings.RawSettings.\n pass","def create_default_hooks(self):\n\n self.create_hooks(\"commands\")\n self.create_hooks(\"commands_out\")\n self.create_hooks(\"hooks\")","def save_defaults(self):\n\n pass","def default_start(self, data):\n return {}","def default_start(self, data):\n return {}","def __set_defaults_to_runtime_variables(self) -> None:\n self.current_time_in_eighths = N_EIGHTHS_PER_MEASURE\n self.current_measure_durations = []\n self.past_movements = []\n self.current_motion_start_element = self.counterpoint[0]\n self.is_last_element_consonant = True","def init(self):","def init(self):","def _setup(self):","def _setup(self):","def startup():\n menuhook.register(\n \"quickpreview\",\n \"howtos\",\n quickpreview,\n menu=[\"&Scripting\", \"Python3 Development\", \"How To\"],\n text=\"Create a quick preview\",\n tooltip=\"Create a quick preview\")","def initialise(self):\r\n return","def initialise(self):\r\n return","def notes_setup(self):\n pass","def init(lang):\n pass","def __init__(self, config):\n self.config = config.config\n self.staff = []\n self.history = {}\n self.pub_auth_all = {}\n self.pub_auth_top = {}\n self.pub_inst_all = {}\n self.pub_inst_top = {}","def post_setup(self, context):\n pass"],"string":"[\n \"def history():\",\n \"def initialize(self):\\n PostProcessorInterfaceBase.initialize(self)\\n self.inputFormat = 'HistorySet'\\n self.outputFormat = 'HistorySet'\",\n \"def Modifier_History(self):\\n\\t\\tpass\",\n \"def __init__(self, history=None):\\n\\n self.__history = history if history else []\",\n \"def onRegisterHistory(self):\\n pass\",\n \"def set_defaults():\\n\\tglobal defaults\\n\\n\\tdefaults = {}\\n\\tdefaults[\\\"aliase\\\"] = {}\\n\\n\\tdefaults[\\\"nigiri\\\"] = {}\\n\\tdefaults[\\\"nigiri\\\"][\\\"wrap_input\\\"] = \\\"True\\\"\\n\\tdefaults[\\\"nigiri\\\"][\\\"command_char\\\"] = \\\"/\\\"\\n\\tdefaults[\\\"nigiri\\\"][\\\"shortcut_pattern\\\"] = \\\"meta [0-9]\\\"\\n\\tdefaults[\\\"nigiri\\\"][\\\"server_shortcuts\\\"] = \\\"true\\\"\\n\\tdefaults[\\\"nigiri\\\"][\\\"show_debug\\\"] = \\\"True\\\"\\n\\tdefaults[\\\"nigiri\\\"][\\\"logfile\\\"] = os.path.join(xdg_cache_home, \\\"sushi\\\", \\\"nigiri.txt\\\")\\n\\tdefaults[\\\"nigiri\\\"][\\\"locale_dir\\\"] = get_path(\\\"..\\\", \\\"locale\\\")\\n\\tdefaults[\\\"nigiri\\\"][\\\"plugin_dirs\\\"] = escape_join(\\\",\\\", (\\n\\t\\t\\tos.path.join(xdg_data_home, \\\"nigiri\\\", \\\"plugins\\\"),\\n\\t\\t\\tos.path.join(xdg_data_home, \\\"chirashi\\\"),\\n\\t\\t\\tget_path(\\\"plugins\\\"),\\n\\t\\t\\tget_path(\\\"..\\\", \\\"chirashi\\\")\\n\\t\\t))\\n\\n\\tdefaults[\\\"chatting\\\"] = {}\\n\\tdefaults[\\\"chatting\\\"][\\\"quit_message\\\"] = \\\"Quit.\\\"\\n\\tdefaults[\\\"chatting\\\"][\\\"part_message\\\"] = \\\"Part.\\\"\\n\\tdefaults[\\\"chatting\\\"][\\\"last_log_lines\\\"] = \\\"15\\\"\\n\\tdefaults[\\\"chatting\\\"][\\\"nick_separator\\\"] = \\\": \\\"\\n\\n\\tdefaults[\\\"colors\\\"] = {}\\n\\tdefaults[\\\"colors\\\"][\\\"messages\\\"] = \\\"gray\\\"\\n\\tdefaults[\\\"colors\\\"][\\\"messages_own\\\"] = \\\"white\\\"\\n\\tdefaults[\\\"colors\\\"][\\\"messages_highlight\\\"] = \\\"red\\\"\\n\\tdefaults[\\\"colors\\\"][\\\"actions\\\"] = \\\"gray\\\"\\n\\tdefaults[\\\"colors\\\"][\\\"actions_own\\\"] = \\\"white\\\"\\n\\tdefaults[\\\"colors\\\"][\\\"informative\\\"] = \\\"blue\\\"\\n\\n\\tdefaults[\\\"templates\\\"] = {}\\n\\t# misc\\n\\tdefaults[\\\"templates\\\"][\\\"datestring\\\"] = \\\"%H:%M\\\"\\n\\t# messages\\n\\tdefaults[\\\"templates\\\"][\\\"action\\\"] = \\\"%(time)s %(nick)s %(message)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"action_own\\\"] = \\\"%(time)s %(nick)s %(message)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"message\\\"] = \\\"%(time)s <%(prefix)s%(nick)s> %(message)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"message_own\\\"] = \\\"%(time)s <%(prefix)s%(nick)s> %(message)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"ctcp\\\"] = \\\"%(time)s -%(nick)s/%(target)s- %(message)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"ctcp_own\\\"] = \\\"%(time)s -%(nick)s/%(target)s- %(message)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"notice\\\"] = \\\"%(time)s *%(nick)s/%(target)s* %(message)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"notice_own\\\"] = \\\"%(time)s *%(nick)s/%(target)s* %(message)s\\\"\\n\\n\\t# actions\\n\\tdefaults[\\\"templates\\\"][\\\"invite\\\"] = \\\"%(time)s * %(nick)s invites %(who)s to %(channel)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"invite_own\\\"] = \\\"%(time)s * You were invited by %(nick)s to %(channel)s.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"join\\\"] = \\\"%(time)s * %(nick)s (%(host)s) has joined %(channel)s.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"join_own\\\"] = \\\"%(time)s * You have joined %(channel)s.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"kick\\\"] = \\\"%(time)s * %(who)s got kicked from %(channel)s by %(nick)s (%(reason)s)\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"kick_own\\\"] = \\\"%(time)s * You got kicked from %(channel)s by %(nick)s (%(reason)s)\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"nick\\\"] = \\\"%(time)s * %(nick)s is now known as %(new_nick)s.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"nick_own\\\"] = \\\"%(time)s * You are now known as %(new_nick)s.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"mode_list\\\"] = \\\"%(time)s * Modes for %(target)s: %(modes)s.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"mode_list_own\\\"] = \\\"%(time)s * Modes set on you: %(modes)s.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"mode\\\"] = \\\"%(time)s %(nick)s set %(mode)s%(param)s on %(target)s.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"mode_own\\\"] = \\\"%(time)s You set %(mode)s%(param)s on %(target)s.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"oper\\\"] = \\\"%(time)s * %(nick)s is now an OPER.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"oper_own\\\"] = \\\"%(time)s * You are now an OPER.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"part\\\"] = \\\"%(time)s * %(nick)s has left %(channel)s (%(reason)s).\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"part_own\\\"] = \\\"%(time)s * You have left %(channel)s (%(reason)s).\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"quit\\\"] = \\\"%(time)s * %(nick)s has quit (%(reason)s).\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"quit_own\\\"] = \\\"%(time)s * You have quit (%(reason)s).\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"topic\\\"] = \\\"%(time)s * %(nick)s has set the topic on %(channel)s to \\\\\\\"%(topic)s\\\\\\\".\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"topic_own\\\"] = \\\"%(time)s * You have set the topic on %(channel)s to \\\\\\\"%(topic)s\\\\\\\".\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"topic_anonymous\\\"] = \\\"* Topic of %(channel)s: %(topic)s\\\"\\n\\n\\t# informative\\n\\tdefaults[\\\"templates\\\"][\\\"banlist_begin\\\"] = \\\"%(time)s Begin of banlist on channel %(channel)s.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"banlist_item\\\"] = \\\">> %(who)s %(mask)s %(when)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"banlist_end\\\"] = \\\"%(time)s End of banlist. (%(channel)s)\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"cannot_join\\\"] = \\\"%(time)s Can't join channel %(channel)s: %(reason)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"list_begin\\\"] = \\\"%(time)s Begin of list.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"list_item\\\"] = \\\">> %(channel)s %(user)s %(topic)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"list_end\\\"] = \\\"%(time)s End of list.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"names_begin\\\"] = \\\"%(time)s Begin of names (%(channel)s).\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"names_item\\\"] = \\\"[ %(row)s ]\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"names_end\\\"] = \\\"%(time)s End of names.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"no_such\\\"] = \\\"%(time)s No such %(type)s: %(target)s.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"whois_begin\\\"] = \\\"%(time)s Begin of whois (%(target)s).\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"whois_item\\\"] = \\\">> %(nick)s: %(message)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"whois_end\\\"] = \\\"%(time)s End of whois.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"dcc_new_incoming\\\"] = \\\"%(time)s Incoming file transfer (ID:%(id)d) from %(sender)s: \\\\\\\"%(filename)s\\\\\\\" (%(size)d).\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"dcc_file_auto_accept\\\"] = \\\"%(time)s Auto accepted file transfer from %(sender)s: \\\\\\\"%(filename)s\\\\\\\" (%(size)d).\\\"\\n\\n\\t# Add default sections to config parser\\n\\t# so setting is easier\\n\\tfor section in defaults.keys():\\n\\t\\ttry:\\n\\t\\t\\tconfig_parser.add_section(section)\\n\\t\\texcept ConfigParser.DuplicateSectionError:\\n\\t\\t\\tcontinue\\n\\n\\t# sections defined below are not added to the configParser and\\n\\t# can't be set by the set method (will raise NoSectionError)\\n\\tpass\",\n \"def setup_hooks(self):\\n pass\",\n \"def defaults():\\n return {}\",\n \"def historical():\\n\\n return {\\n 'page': 'historical',\\n }\",\n \"def tweaks(self) -> None:\\n pass\",\n \"def set_app_defaults(self):\\n self.curve_render = 0\\n self.image_render = 0\\n self.image_height = 200\\n self.image_data = []\\n self.auto_scale = True\\n\\n self.create_actions()\\n self.setup_signals()\\n self.reset_graph()\\n\\n self.fps = utils.SimpleFPS()\\n\\n # Click the live button\\n self.ui.actionContinue_Live_Updates.trigger()\",\n \"def defaults() -> dict:\\n pass\",\n \"def history():\\n return apology(\\\"TODO\\\")\",\n \"def history():\\n return apology(\\\"TODO\\\")\",\n \"def history():\\n return apology(\\\"TODO\\\")\",\n \"def autodefaults (self):\\r\\n\\r\\n self.defaults_from_notes(identifying_key=EMPTYCHAR,\\r\\n mark=EQUAL,\\r\\n obj=self.default_dict['commands'],\\r\\n entrytext=COMMANDMACROSCRIPT)\",\n \"def default_config():\\n config = Config()\\n config.TerminalInteractiveShell.colors = 'NoColor'\\n config.TerminalTerminalInteractiveShell.term_title = False,\\n config.TerminalInteractiveShell.autocall = 0\\n f = tempfile.NamedTemporaryFile(suffix=u'test_hist.sqlite', delete=False)\\n config.HistoryManager.hist_file = Path(f.name)\\n f.close()\\n config.HistoryManager.db_cache_size = 10000\\n return config\",\n \"def __init__( settings={} ):\",\n \"def initialise(self):\",\n \"def __init__(self, environment):\\n super(HistoricalExtension, self).__init__(environment)\\n environment.filters['titlecase'] = titlecase\",\n \"def initDefaults(self):\\n return _libsbml.Event_initDefaults(self)\",\n \"def add_earlydefault_settings(self):\\n self.add_default_settings_config()\\n self.add_default_settings_aliases()\",\n \"def default_forage_args():\\n\\n forage_args = {\\n 'prop_legume': 0.0,\\n 'steepness': 1.,\\n 'DOY': 1,\\n 'start_year': 2016,\\n 'start_month': 1,\\n 'num_months': 24,\\n 'mgmt_threshold': 0.01,\\n 'century_dir': 'C:/Users/ginge/Dropbox/NatCap_backup/Forage_model/CENTURY4.6/Century46_PC_Jan-2014',\\n 'template_level': 'GH',\\n 'fix_file': 'drygfix.100',\\n 'user_define_protein': 1,\\n 'user_define_digestibility': 0,\\n 'herbivore_csv': r\\\"C:/Users/ginge/Dropbox/NatCap_backup/Mongolia/model_inputs/cashmere_goats.csv\\\",\\n 'grass_csv': r\\\"C:/Users/ginge/Dropbox/NatCap_backup/Mongolia/model_inputs/grass.csv\\\",\\n 'restart_monthly': 0,\\n }\\n return forage_args\",\n \"def post_init(self):\\n\\t\\tpass\",\n \"def _post_hooks(self):\",\n \"def presets (self):\\n assert False, \\\"To be implemented by child\\\"\",\n \"def setup_default_terms(self):\\n # Setting config with pattern -\\n # default_dict[\\\"json config key\\\"] = (\\\"Default Value\\\", \\\"Ask User\\\", \\\"Value Type\\\")\\n\\n self.default_terms[Keys.first_run] = (Values.first_run, False, None)\\n self.default_terms[Keys.nas_mount] = (Values.nas_mount_path, True, str)\\n self.default_terms[Keys.secs_between_checks] = (Values.check_time, True, int)\\n self.default_terms[Keys.redmine_api_key] = ('none', False, str)\",\n \"def set_default_parameters(self):\\n super().set_default_parameters()\",\n \"def _post_init(self):\\n pass\",\n \"def _set_defaults(self):\\n self.api_protocol = 'https'\\n self.api_host = 'nhl-score-api.herokuapp.com'\\n self.current_score = 0\\n self.sleep_seconds = 30 # Time to sleep after calling the API\\n self.desired_game_state = 'LIVE' # Desired game state is LIVE\",\n \"def defaults(self):\\n self.lib.iperf_defaults(self._test)\",\n \"def init_tab(self):\",\n \"def without_defaults(self):\\n ...\",\n \"def initialize_default(self):\\n self.initialize_navigation()\\n self.initialize_viewport()\",\n \"def initialize(self, src_sentence):\\n self.history = ['<s>'] if self.history_len > 0 else []\",\n \"def __init__(self):\\n self.analytics = Analytics()\\n self.menu_options = {\\n \\\"1\\\": self.add_habit,\\n \\\"2\\\": self.check_off,\\n \\\"3\\\": self.delete_habit,\\n \\\"4\\\": self.see_habit,\\n \\\"5\\\": self.show_all_habits,\\n \\\"6\\\": self.habits_same_periodicity,\\n \\\"7\\\": self.habit_longest_streak,\\n \\\"0\\\": self.exit,\\n\\n }\",\n \"def initDefaults(self):\\n return _libsbml.Reaction_initDefaults(self)\",\n \"def initialize_options(self):\",\n \"def defaults(self):\\n\\n return None\",\n \"def defaults(self):\\n\\n return None\",\n \"def _initialize_defaults(self):\\n for key, value in defaults.items():\\n if key not in self.source_params:\\n self.source_params[key] = value\",\n \"def _initialize_defaults(self):\\n for key, value in defaults.items():\\n if key not in self.source_params:\\n self.source_params[key] = value\",\n \"def make_initial_state(self):\\n pass\",\n \"def add_settings_early(self):\\n pass\",\n \"def initialize(self):\",\n \"def initialize(self):\",\n \"def initialize(self):\",\n \"def initialize(self):\",\n \"def set_defaults(self):\\n self.plastic = False\\n self.unset_output()\\n self.reward = False\\n self.patmod = config.impact_modulation_default\",\n \"def __init__(self):\\n self.last_reward_pos = 0\\n super().__init__()\\n self.TERRAIN_VARIANCE = 0.0\\n self.stump_spacing = 4.0\\n self.stump_height = 1.0\\n self.my_init({'leg_length': 35, 'walker_type': 'default'})\",\n \"def _restore_default(self):\\n raise NotImplementedError(\\\"Should have implemented this.\\\")\",\n \"def reset(self):\\n # This also resets the history.\\n self.__init__(**self.init_kwargs)\",\n \"def _post_init(self) -> None:\\n return\",\n \"def quick_set_manual_settings(self):\\n self.logger.debug(\\\"Manual conversion settings\\\")\\n self.quick_setting = 'manual'\\n self.front_matter_format = 'none'\\n self.metadata_schema = []\\n if self.conversion_input == 'nsx':\\n self.metadata_schema = ['title', 'ctime', 'mtime', 'tag']\\n self.spaces_in_tags = False\\n self.split_tags = False\\n self.first_row_as_header = False\\n self.first_column_as_header = False\\n self.chart_image = True\\n self.chart_csv = True\\n self.chart_data_table = True\",\n \"def _hook(self):\",\n \"def navigation_hook(self):\\r\\n pass\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def user_init(self):\\n pass\",\n \"def init_game_setting(self):\\r\\n pass\",\n \"def history(self, history):\\n self._history = history\",\n \"def general(self):\\n self.dir = 'Stories'\\n if not os.path.isdir(self.dir):\\n os.mkdir(self.dir)\\n\\n self.langLock = Semaphore(0)\\n self.setLanguage('en-US')\\n self.setEyeColour('greenyellow')\\n\\n self.langLock.acquire()\\n\\n # pass Google Dialogflow parameters\\n self.setDialogflowKey('nao.json')\\n self.setDialogflowAgent('nao-wksstn')\\n\\n self.speechLock = Semaphore(0)\",\n \"def __init__(self):\\n self.__load_settings()\\n self.__load_history()\\n self.__clear_context()\\n\\n if self.DELETE_ALL_ON_STARTUP:\\n sublime.set_timeout_async(lambda: self.delete_all_history(), 0)\\n elif self.CLEANUP_ON_STARTUP:\\n sublime.set_timeout_async(lambda: self.clean_history(False), 0)\",\n \"def _problem_set_up(self):\\n self.curr_best_reward = -np.inf\\n self.curr_reward = -np.inf\\n # Set up history\\n self.history.curr_best_reward = []\\n self.history.curr_reward = []\",\n \"def test_hist_init():\\n FNAME = 'xonsh-SESSIONID.json'\\n FNAME += '.init'\\n History(filename=FNAME, here='yup', **HIST_TEST_KWARGS)\\n with LazyJSON(FNAME) as lj:\\n obs = lj['here']\\n assert_equal('yup', obs)\\n os.remove(FNAME)\",\n \"def init():\",\n \"def __init__(self):\\n super(APTHistoryLogTextPlugin, self).__init__()\\n self._event_data = None\",\n \"def loadDefaults(self):\\n # (025) Merged into settings.RawSettings.\\n pass\",\n \"def create_default_hooks(self):\\n\\n self.create_hooks(\\\"commands\\\")\\n self.create_hooks(\\\"commands_out\\\")\\n self.create_hooks(\\\"hooks\\\")\",\n \"def save_defaults(self):\\n\\n pass\",\n \"def default_start(self, data):\\n return {}\",\n \"def default_start(self, data):\\n return {}\",\n \"def __set_defaults_to_runtime_variables(self) -> None:\\n self.current_time_in_eighths = N_EIGHTHS_PER_MEASURE\\n self.current_measure_durations = []\\n self.past_movements = []\\n self.current_motion_start_element = self.counterpoint[0]\\n self.is_last_element_consonant = True\",\n \"def init(self):\",\n \"def init(self):\",\n \"def _setup(self):\",\n \"def _setup(self):\",\n \"def startup():\\n menuhook.register(\\n \\\"quickpreview\\\",\\n \\\"howtos\\\",\\n quickpreview,\\n menu=[\\\"&Scripting\\\", \\\"Python3 Development\\\", \\\"How To\\\"],\\n text=\\\"Create a quick preview\\\",\\n tooltip=\\\"Create a quick preview\\\")\",\n \"def initialise(self):\\r\\n return\",\n \"def initialise(self):\\r\\n return\",\n \"def notes_setup(self):\\n pass\",\n \"def init(lang):\\n pass\",\n \"def __init__(self, config):\\n self.config = config.config\\n self.staff = []\\n self.history = {}\\n self.pub_auth_all = {}\\n self.pub_auth_top = {}\\n self.pub_inst_all = {}\\n self.pub_inst_top = {}\",\n \"def post_setup(self, context):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61749583","0.61044705","0.5923172","0.56847167","0.5676686","0.56484216","0.56409806","0.5607612","0.5604941","0.5588264","0.55781215","0.5554692","0.55457157","0.55457157","0.55457157","0.55185014","0.550989","0.5501374","0.5485809","0.5464516","0.5439006","0.54371053","0.5417329","0.54038584","0.54007804","0.53926885","0.5391507","0.5383697","0.5378607","0.53646284","0.5358165","0.5351959","0.5345799","0.5335719","0.5323103","0.5316181","0.5307506","0.52990794","0.5267731","0.5267731","0.5258845","0.5258845","0.5251816","0.5246731","0.5244931","0.5244931","0.5244931","0.5244931","0.5238551","0.5232229","0.5227036","0.52166486","0.5214728","0.5209886","0.5208528","0.51881576","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51837325","0.5175456","0.51645076","0.5164357","0.51631385","0.5158922","0.51557857","0.5155698","0.5151827","0.51510334","0.5146235","0.5145782","0.51390415","0.51390415","0.5126872","0.5122385","0.5122385","0.51187235","0.51187235","0.51178366","0.51118356","0.51118356","0.51105917","0.51081437","0.50912327","0.50905323"],"string":"[\n \"0.61749583\",\n \"0.61044705\",\n \"0.5923172\",\n \"0.56847167\",\n \"0.5676686\",\n \"0.56484216\",\n \"0.56409806\",\n \"0.5607612\",\n \"0.5604941\",\n \"0.5588264\",\n \"0.55781215\",\n \"0.5554692\",\n \"0.55457157\",\n \"0.55457157\",\n \"0.55457157\",\n \"0.55185014\",\n \"0.550989\",\n \"0.5501374\",\n \"0.5485809\",\n \"0.5464516\",\n \"0.5439006\",\n \"0.54371053\",\n \"0.5417329\",\n \"0.54038584\",\n \"0.54007804\",\n \"0.53926885\",\n \"0.5391507\",\n \"0.5383697\",\n \"0.5378607\",\n \"0.53646284\",\n \"0.5358165\",\n \"0.5351959\",\n \"0.5345799\",\n \"0.5335719\",\n \"0.5323103\",\n \"0.5316181\",\n \"0.5307506\",\n \"0.52990794\",\n \"0.5267731\",\n \"0.5267731\",\n \"0.5258845\",\n \"0.5258845\",\n \"0.5251816\",\n \"0.5246731\",\n \"0.5244931\",\n \"0.5244931\",\n \"0.5244931\",\n \"0.5244931\",\n \"0.5238551\",\n \"0.5232229\",\n \"0.5227036\",\n \"0.52166486\",\n \"0.5214728\",\n \"0.5209886\",\n \"0.5208528\",\n \"0.51881576\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51837325\",\n \"0.5175456\",\n \"0.51645076\",\n \"0.5164357\",\n \"0.51631385\",\n \"0.5158922\",\n \"0.51557857\",\n \"0.5155698\",\n \"0.5151827\",\n \"0.51510334\",\n \"0.5146235\",\n \"0.5145782\",\n \"0.51390415\",\n \"0.51390415\",\n \"0.5126872\",\n \"0.5122385\",\n \"0.5122385\",\n \"0.51187235\",\n \"0.51187235\",\n \"0.51178366\",\n \"0.51118356\",\n \"0.51118356\",\n \"0.51105917\",\n \"0.51081437\",\n \"0.50912327\",\n \"0.50905323\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":21287,"cells":{"query":{"kind":"string","value":"plot results for numerical experiment folder 1) surface profiles for each parameter 2) uz_max versus parameter values 3) residual versus parameter values"},"document":{"kind":"string","value":"def plot_directory_numex(path, vals, param='density', outname=None, show=True,\n xscale=1e-3,yscale=1e2):\n #vals = arange(2300.0, 2800.0, 50.0)\n outdirs = np.sort(os.listdir(path))\n plt.figure()\n\n # Plot surface profiles for each parameter\n for val,outdir in zip(vals,outdirs):\n pointsFile = os.path.join(path, outdir, 'points.h5')\n print(pointsFile)\n x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile, output=True, adjustRadial=True)\n x_fem = x_fem / xscale\n ur_fem = ur_fem / yscale\n uz_fem = uz_fem / yscale\n l, = plt.plot(x_fem,uz_fem,'.-',label=str(val))\n plt.plot(x_fem,ur_fem,'.-',color=l.get_color())\n\n # Annotate\n plt.axhline(color='k') #zero displacement line\n plt.title(param)\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n plt.legend()\n\n if outname: plt.savefig(outname)\n if show: plt.show()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def plot_directory_profiles(path, outname=None, show=True, xscale=1, yscale=1,\n xval='x', adjustRadial=True):\n outdirs = np.sort(os.listdir(path))\n plt.figure()\n\n #labels=['homogeneous','1D layering', '3D tomography'] #xscale=1e-3, yscale=1e2\n for i,outdir in enumerate(outdirs):\n pointsFile = os.path.join(path, outdir, 'points.h5')\n #print(pointsFile)\n #x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile, output='cyl',adjustRadial=adjustRadial)\n #x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile)\n #Load data\n\n x,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n #Y = uz / yscale\n if xval == 'x':\n X = x / xscale\n Y1 = ux / yscale\n elif xval == 'r':\n X = np.hypot(x,y) / xscale\n ur_fem = np.hypot(ux,uy)\n Y1 = ur_fem / yscale\n if adjustRadial: #fix sign from hypot square root\n ur_fem = pu.radial2negative(Y1)\n\n x_fem = X #/ xscale #double scaling!\n ur_fem = Y1 #/ yscale\n uz_fem = uz / yscale\n\n #print(pointsFile)\n print(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max())\n\n l, = plt.plot(x_fem,uz_fem,'.-',lw=3,label=outdir)\n #l, = plt.plot(x_fem,uz_fem,'.-',lw=2,label=labels[i]) #for 3d heterogeneity example\n plt.plot(x_fem,ur_fem,'.--',lw=3, mfc='w',color=l.get_color()) #mfc='none' transparent\n\n # Annotate\n plt.axhline(color='k',lw=0.5)\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n plt.legend()\n\n #NOTE: custom annotations for 3d heterogeneity\n #plt.title('Elastic Heterogeneity Effects')\n #plt.legend([l1,l2,l3],['homogeneous','1D layering', '3D tomography'])\n\n if outname: plt.savefig(outname)\n if show: plt.show()","def display_results(experiment, norms, nus, filename):\n # plot the results of the experiment\n fig, axes = plt.subplots(2,2, figsize=(15.0, 10.0))\n\n # plot large scale overview\n _create_line_plot(experiment['a'], nus, norms, axes[0][0], 'slope')\n _create_line_plot(experiment['b'], nus, norms, axes[0][1], 'intercept')\n\n # plot more detailed errors exluding OLS estimate\n _create_bar_plot(experiment['a'], nus[1::2], norms, axes[1][0])\n _create_bar_plot(experiment['b'], nus[1::2], norms, axes[1][1])\n\n # add title and save\n plt.savefig(filename, dpi=300)","def plot(model, results, filename):\n\n # c = model.compartments.get_one(id='c')\n #\n # rna_1 = model.species_types.get_one(id='rna_1').species.get_one(compartment=c)\n # rna_2 = model.species_types.get_one(id='rna_2').species.get_one(compartment=c)\n # rna_3 = model.species_types.get_one(id='rna_3').species.get_one(compartment=c)\n #\n pops = results.get('populations')\n time = pops.index\n pop_rna_1 = pops['rna_1[c]']\n pop_rna_2 = pops['rna_2[c]']\n pop_rna_3 = pops['rna_3[c]']\n\n pop_atp = pops['atp[c]']\n pop_gtp = pops['gtp[c]']\n pop_utp = pops['ctp[c]']\n pop_ctp = pops['utp[c]']\n\n pop_amp = pops['amp[c]']\n pop_gmp = pops['gmp[c]']\n pop_ump = pops['cmp[c]']\n pop_cmp = pops['ump[c]']\n\n print(pop_rna_1, pop_atp, pop_gtp, pop_utp, pop_ctp)\n\n fig1, axes1 = pyplot.subplots(nrows=3, ncols=1)\n\n axes1[0].plot(time / 3600, pop_rna_1)\n axes1[0].plot(time / 3600, pop_rna_2)\n axes1[0].plot(time / 3600, pop_rna_3)\n axes1[0].set_xlim((time[0] / 3600, time[-1] / 3600))\n axes1[0].set_ylim((0., 10.0))\n axes1[0].legend(loc='upper right')\n\n axes1[1].plot(time / 3600, pop_atp)\n axes1[1].plot(time / 3600, pop_gtp)\n axes1[1].plot(time / 3600, pop_utp)\n axes1[1].plot(time / 3600, pop_ctp)\n axes1[1].set_xlim((time[0] / 3600, time[-1] / 3600))\n # axes1[1].set_ylim((0., 10.0))\n axes1[1].legend(loc='upper right')\n\n axes1[2].plot(time / 3600, pop_amp)\n axes1[2].plot(time / 3600, pop_gmp)\n axes1[2].plot(time / 3600, pop_ump)\n axes1[2].plot(time / 3600, pop_cmp)\n axes1[2].set_xlim((time[0] / 3600, time[-1] / 3600))\n # axes1[2].set_ylim((0., 10.0))\n axes1[2].legend(loc='upper right')\n\n fig1.savefig(filename.format('species'))\n pyplot.close(fig1)","def plot_it(self, ui=None, res_dir=None):\r\n print_it(\"plotting results\")\r\n plt_profile(self.sun, PltOpts.DD.value, res_dir, SubDir.profiles.value)\r\n plt_profile(self.sun, PltOpts.DDD.value, res_dir, SubDir.profiles.value)\r\n plt_profile(self.planet, PltOpts.DD.value, res_dir,\r\n SubDir.profiles.value)\r\n plt_profile(self.planet, PltOpts.DDD.value, res_dir,\r\n SubDir.profiles.value)\r\n plt_profile_approx(res_dir, SubDir.profiles.value)\r\n plt_contact(self.sun, self.planet, PltOpts.DD.value, res_dir,\r\n SubDir.contacts.value)\r\n plt_contact(self.sun, self.planet, PltOpts.DDD.value, res_dir,\r\n SubDir.contacts.value)\r\n\r\n plt_3d(self.sun.x_axis, self.sun.y_axis, self.sun.press,\r\n self.sun.x_label, self.sun.y_label, 'pressure in MPa',\r\n 'contact_pressure_sun', res_dir, SubDir.pressures.value,\r\n 'contact_pressure_sun')\r\n plt_2d_scatt_line(self.sun.x_axis, self.pv, self.sun.x_axis, self.pv,\r\n self.sun.x_label,\r\n 'pv_rel in {}'.format(Unit.pvrel.value), 'pv_rel',\r\n res_dir, SubDir.energy.value, 'pv_rel')\r\n plt_2d_scatt_line(self.sun.x_axis, self.sun.e_akin, self.sun.x_axis,\r\n self.sun.e_akin, self.sun.x_label,\r\n 'e_akin in {}'.format(Unit.eakin.value), 'e_akin',\r\n res_dir, SubDir.energy.value, 'sun.e_akin')\r\n plt_2d_scatt_line(self.planet.x_axis, self.planet.e_akin,\r\n self.planet.x_axis, self.planet.e_akin,\r\n self.planet.x_label,\r\n 'e_akin in {}'.format(Unit.eakin.value), 'e_akin',\r\n res_dir,\r\n SubDir.energy.value, 'planet.e_akin')\r\n plt_energy_ring_on_ring(self, res_dir, SubDir.energy.value,\r\n 'e-akin-vs-pv-rel')","def xx_plot(epoch, model, features, filters, figname, fgal=0.5):\n # fetch Stripe 82 data\n X, Xcov = fetch_prepped_s82data(epoch, fgal, features, filters)\n Xcoadd, Xcoaddcov = fetch_prepped_s82data(epoch, fgal, features,\n filters, use_single=False)\n N = 20000\n X = X[:N]\n Xcov = Xcov[:N]\n Xcoadd = Xcoadd[:N]\n Xcoaddcov = Xcoaddcov[:N]\n\n # unpickle the XD model\n if type(model) == str: \n f = open(model, 'rb')\n model = cPickle.load(f)\n f.close()\n\n # Calculate the posteriors, draw samples\n a, m, v = model.posterior(X, Xcov)\n posts = np.zeros_like(X)\n for i in range(X.shape[0]):\n posts[i] = model.sample(a[i], m[i], v[i], size=1)\n\n lo = [0.01, 0.02, 0.06]\n hi = [0.99, 0.96, 0.98]\n idx = [0, 1, 4]\n bins = [100, 100, 300]\n label = ['psfmag $r$', 'modelmag $u-g$', 'modelmag $i-z$']\n N = len(idx)\n fs = 5\n lsize = 20\n f = pl.figure(figsize=(N * fs, 2 * fs))\n pl.subplots_adjust(wspace=0.3)\n for i in range(N):\n x = X[:, idx[i]]\n y = Xcoadd[:, idx[i]]\n p = posts[:, idx[i]]\n ind = (y > -999) & (Xcoaddcov[:, idx[i]][:, idx[i]] < 10.)\n x = x[ind]\n y = y[ind]\n p = p[ind]\n ax = pl.subplot(2, N, i + 1)\n v = np.sort(x)\n mn, mx = v[np.int(lo[i] * x.shape[0])], v[np.int(hi[i] * x.shape[0])]\n hist2d(x, y, ax=ax, bins=bins[i], plot_contours=True,\n plot_datapoints=True)\n pl.plot([mn, mx], [mn, mx], 'r', lw=2)\n pl.ylabel('Coadd ' + label[i], fontsize=lsize)\n pl.xlabel('Single Epoch ' + label[i], fontsize=lsize)\n pl.xlim(mn, mx)\n pl.ylim(mn, mx)\n ax = pl.subplot(2, N, i + 4)\n hist2d(p, y, ax=ax, bins=bins[i], plot_contours=True,\n plot_datapoints=True)\n pl.plot([mn, mx], [mn, mx], 'r', lw=2)\n pl.xlim(mn, mx)\n pl.ylim(mn, mx)\n pl.ylabel('Coadd ' + label[i], fontsize=lsize)\n pl.xlabel('XD Posterior ' + label[i], fontsize=lsize)\n f.savefig(figname, bbox_inches='tight')","def _plotModelResiduals(id='simulated800nmJoint1', folder='results/', out='Residual.pdf', individual=False):\n #data\n if individual:\n data = pf.getdata(folder+id+'small.fits')\n data[data < 1] = 1.\n data = np.log10(data)\n else:\n data = pf.getdata(folder+id+'datafit.fits')\n data[data < 1] = 1.\n data = np.log10(data)\n #model\n model = pf.getdata(folder+id+'model.fits ')\n model[model < 1] = 1.\n model = np.log10(model)\n #residual\n residual = pf.getdata(folder+id+'residual.fits')\n #squared residual\n residualSQ = pf.getdata(folder+id+'residualSQ.fits')\n\n max = np.max((data.max(), model.max()))\n\n #figure\n fig = plt.figure(figsize=(12, 12))\n ax1 = fig.add_subplot(221)\n ax2 = fig.add_subplot(222)\n ax3 = fig.add_subplot(223)\n ax4 = fig.add_subplot(224)\n ax = [ax1, ax2, ax3, ax4]\n fig.subplots_adjust(hspace=0.05, wspace=0.3, top=0.95, bottom=0.02, left=0.02, right=0.9)\n ax1.set_title('Data')\n ax2.set_title('Model')\n ax3.set_title('Residual')\n ax4.set_title('$L^{2}$ Residual')\n\n im1 = ax1.imshow(data, interpolation='none', vmax=max, origin='lower', vmin=0.1)\n im2 = ax2.imshow(model, interpolation='none', vmax=max, origin='lower', vmin=0.1)\n im3 = ax3.imshow(residual, interpolation='none', origin='lower', vmin=-100, vmax=100)\n im4 = ax4.imshow(residualSQ, interpolation='none', origin='lower', vmin=0., vmax=10)\n\n divider = make_axes_locatable(ax1)\n cax1 = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n divider = make_axes_locatable(ax2)\n cax2 = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n divider = make_axes_locatable(ax3)\n cax3 = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n divider = make_axes_locatable(ax4)\n cax4 = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n cbar1 = plt.colorbar(im1, cax=cax1)\n cbar1.set_label(r'$\\log_{10}(D_{i, j} \\quad [e^{-}]$)')\n cbar2 = plt.colorbar(im2, cax=cax2)\n cbar2.set_label(r'$\\log_{10}(M_{i, j} \\quad [e^{-}]$)')\n cbar3 = plt.colorbar(im3, cax=cax3)\n cbar3.set_label(r'$M_{i, j} - D_{i, j} \\quad [e^{-}]$')\n cbar4 = plt.colorbar(im4, cax=cax4)\n cbar4.set_label(r'$\\frac{(M_{i, j} - D_{i, j})^{2}}{\\sigma_{CCD}^{2}}$')\n\n for tmp in ax:\n plt.sca(tmp)\n plt.xticks(visible=False)\n plt.yticks(visible=False)\n\n plt.savefig(out)\n plt.close()","def plot_directory_surface_rmse(path, vals, param='Vp'):\n\n unw = '/home/scott/data/insar/cvz/t2282/geo/geo_stack282_8rlks.unw'\n incidence = '/home/scott/data/insar/cvz/t2282/aux_files/geo_incidence_8rlks.unw'\n dem = '/home/scott/data/dems/cgiar/uturuncu_1000_1000.tif'\n #surface = '/home/scott/research/models/pylith/3d/uturuncu_layered/output/step01/surface.h5'\n #geosurface = '/home/scott/research/models/pylith/scripts/geo_fem_Uz.tif'\n\n plt.figure()\n outdirs = np.sort(os.listdir(path))\n\n # Calculate rmse\n rmse = np.zeros_like(vals)\n for i,outdir in enumerate(outdirs):\n surface = os.path.join(path,outdir,'surface.h5')\n los,fem_los,residual = pu.los2pylith(surface, dem, unw, incidence)\n rmse[i] = rms_flat(residual[np.isfinite(residual)])\n\n plt.plot(vals,rmse,'b.-')\n\n # Annotate\n #plt.title(param)\n plt.xlabel('{} [km]'.format(param))\n plt.ylabel('RMSE [cm]')\n plt.legend()\n plt.show()","def plot_results_traj_3d(p_x, p_y, p_z, xmin, xmax, ymin, ymax, zmin, zmax):\n fig, ax = plt.subplots(2 , 2, figsize = (10, 10))\n \n for p in np.arange(0, p_x.shape[0], step = 1): \n for t in np.arange(0, p_x.shape[1], step = 1): \n ax[0,0].plot(t, p_x[p, t], 'rx') \n ax[0,1].plot(t, p_y[p, t], 'gx') \n ax[1,0].plot(t, p_z[p, t], 'bx') \n ax[1,1].plot(t, p_x[p, t], 'rx') \n ax[1,1].plot(t, p_y[p, t], 'gx') \n ax[1,1].plot(t, p_z[p, t], 'bx') \n for a in ax.flat: \n a.set(xlabel = 'Time steps', ylabel = 'Position')\n ax[0,0].set_title('X (pix)') \n ax[0,0].set_ylim([xmin, xmax]) \n ax[0,1].set_title('Y (pix)') \n ax[0,1].set_ylim([ymin, ymax]) \n ax[1,0].set_title('Z (pix)') \n ax[1,0].set_ylim([zmin, zmax])\n ax[1,1].set_title('Positions combined') \n ax[1,1].set_ylim([np.array([xmin, ymin, zmin]).min(), np.array([xmax, ymax, zmax]).max()])","def plot_results(model):\n\n # Is is a system of equation\n is_system = max(model.n_input, model.n_output) > 1\n\n # Choose the plotting function depending on the type of training data\n if model.dimension == 1 and not (is_system):\n plot_1d_results(model)\n\n elif model.dimension == 1 and is_system:\n plot_1d_systems(model)\n\n elif model.dimension > 1 and not (is_system):\n plot_2d_results(model)\n\n else:\n # Plot and save slices of the Green's matrix\n for i in range(1, 5):\n plot_2d_systems(model, Green_slice=i)","def plot(self, **kwargs):\n\n # get colors\n colors = kwargs.get(\"colors\", GW_OBSERVATORY_COLORS)\n\n # get Result samples\n self._samples = {\n label: value.posterior\n for label, value in self.results.items()\n if isinstance(value, Result)\n }\n\n # get Grid posteriors\n self._grids = {\n label: [value, value.ln_evidence] # store grid and log evidence\n for label, value in self.results.items()\n if isinstance(value, Grid)\n }\n\n # apply offsets for slightly nicer plots axes\n self.parameter_offsets = {parameter: 0.0 for parameter in self.parameters}\n if len(self._grids) == 0 and len(self._samples) == 1:\n for label in self._samples:\n for parameter in self.parameters:\n srange = [\n np.min(self._samples[label][parameter]),\n np.max(self._samples[label][parameter]),\n ]\n label_suffix = \"\"\n\n # offset values\n median = np.median(self._samples[label][parameter])\n relwidth = np.abs((srange[1] - srange[0]) / median)\n\n if relwidth < 1e-4:\n offsetstr = f\"{median:.4e}\"\n a, b = offsetstr.split(\"e\")\n\n if np.abs(int(b)) < 3:\n offsetstr = f\"{median:.4f}\"\n offset = float(offsetstr)\n else:\n offset = float(offsetstr)\n offsetstr = a + rf\"\\!\\times\\!10^{{{int(b)}}}\"\n\n self.parameter_offsets[parameter] = offset\n\n self._samples[label][parameter] -= offset\n label_suffix = rf\" [${{\\scriptstyle {offsetstr}}}$]\"\n\n self.latex_labels[parameter] += label_suffix\n\n colordicts = []\n for j, res in enumerate([self._samples, self._grids]):\n colordicts.append({})\n for i, key in enumerate(res):\n if key in colors:\n colordicts[-1][key] = colors[key]\n elif key.lower() == \"joint\":\n # if using \"Joint\" as the multi-detector analysis key, set the color to black\n colordicts[-1][key] = \"k\"\n else:\n # use PESummary color cycle\n colordicts[-1][key] = list(colorcycle)[\n (j * 2 + i) % len(colorcycle)\n ]\n\n # store original keywords arguments\n origkwargs = kwargs.copy()\n\n # plot samples\n fig = None\n if len(self._samples) > 0:\n kwargs[\"colors\"] = list(colordicts[0].values())\n if self._num_parameters == 1:\n fig = self._1d_plot_samples(**kwargs)\n elif self._num_parameters == 2 and self.plottype != \"corner\":\n fig = self._2d_plot_samples(**kwargs)\n else:\n fig = self._nd_plot_samples(**kwargs)\n\n # restore keywords\n kwargs = origkwargs\n\n if len(self._grids) > 0:\n kwargs[\"colors\"] = list(colordicts[1].values())\n if fig is not None and \"fig\" not in kwargs:\n kwargs[\"fig\"] = fig\n if self._num_parameters == 1:\n fig = self._1d_plot_grid(**kwargs)\n elif self._num_parameters == 2 and self.plottype != \"corner\":\n fig = self._2d_plot_grid(**kwargs)\n else:\n fig = self._nd_plot_grid(**kwargs)\n\n # add further figure information\n if self._num_parameters == 1:\n ax = fig.gca()\n\n # set figure bounds if outside defaults\n if self.parameters[0] in DEFAULT_BOUNDS:\n _set_axes_limits(ax, self.parameters[0], axis=\"x\")\n\n # add injection values\n if self.injection_parameters is not None:\n if self.injection_parameters[self.parameters[0]] is not None:\n ax.axvline(\n (\n self.injection_parameters[self.parameters[0]]\n - self.parameter_offsets[self.parameters[0]]\n ),\n color=kwargs.get(\"injection_color\", \"k\"),\n linewidth=1,\n )\n elif self._num_parameters == 2:\n if \"triangle\" in self.plottype:\n a1, a2, a3 = fig[1:]\n order = [\"x\", \"y\"] if self.plottype == \"triangle\" else [\"y\", \"x\"]\n params = (\n self.parameters[:2]\n if self.plottype == \"triangle\"\n else self.parameters[1::-1]\n )\n\n # set figure bounds if outside defaults\n for param, axes, axis in zip(params, [[a1, a2], [a2, a3]], order):\n for ax in axes:\n _set_axes_limits(ax, param, axis=axis)\n\n self.fig = fig\n return self.fig","def plot_potential_profile(rims_object):\r\n if not os.path.exists(rims_object.path_for_output):\r\n os.makedirs(rims_object.path_for_output)\r\n number_of_profiles = rims_object.potential_profile_mat.shape[0]\r\n x = [dx * pow(10, 4) for dx in rims_object.x_space_vec]\r\n fig, axs = plt.subplots(number_of_profiles)\r\n plt.suptitle('RIMS: Ratchet potential profiles', fontsize=14, fontweight='bold')\r\n\r\n for i_profile in range(number_of_profiles):\r\n y = [dy for dy in rims_object.potential_profile_mat[i_profile]]\r\n axs[i_profile].plot(x, y, color=YELLOW, label=\"V(x) potential profile\")\r\n axs[i_profile].tick_params(axis='y', labelcolor=YELLOW)\r\n ax2 = axs[i_profile].twinx()\r\n y = [dy * pow(10, -4) for dy in rims_object.electric_field_mat[i_profile]]\r\n ax2.plot(x, y, color=PURPLE, label=r\"E(x) electric field = -$\\nabla $V\")\r\n ax2.tick_params(axis='y', labelcolor=PURPLE)\r\n text_kwargs = dict(fontsize=10, color=YELLOW, fontweight='bold')\r\n fig.text(0.1, 0.91, 'V(x) potential profile [v]', text_kwargs)\r\n text_kwargs = dict(fontsize=10, color=PURPLE, fontweight='bold')\r\n fig.text(0.5, 0.91, r\"E(x) electric field = -$\\nabla $V [v/$\\mu $m]\", text_kwargs)\r\n axs[number_of_profiles-1].set_xlabel(r\"X [$\\mu $m]\")\r\n\r\n if number_of_profiles < 4:\r\n fig.tight_layout()\r\n plt.savefig(rims_object.path_for_output + 'Ratchet potential profiles.jpeg')\r\n plt.close()\r\n write_to_log(rims_object, \"potential profile plot saved\")\r\n return","def plot_optima(cfg, results, results_inftau):\n\n def subplot_args(experiment_idx, row):\n return 4, len(cfg['experiments']), \\\n row * len(cfg['experiments']) + experiment_idx + 1\n\n for e, experiment in enumerate(cfg['experiments']):\n def set_rowlabels(rowname):\n if e <= 0:\n plt.ylabel(rowname)\n else:\n plt.yticks([])\n\n plt.subplot(*subplot_args(e, 0))\n\n plt.title(experiment['name'])\n plt.xlabel(\"time / ms\")\n plt.ylim(0, 210)\n if e > 0:\n plt.yticks([])\n plot_stparams(\n [cfg['l1_length'], cfg['l2_lengths'][1], cfg['l3_length'],\n cfg['l4_lengths'][1]], experiment['rates_a'], 'm')\n plot_stparams(\n [cfg['l1_length'], cfg['l2_lengths'][1], cfg['l3_length'],\n cfg['l4_lengths'][1]], experiment['rates_b'], 'k')\n\n plt.subplot(*subplot_args(e, 1))\n set_rowlabels(r\"$\\langle I^* \\rangle$\")\n plt.xticks([])\n plt.xlim(\n 0,\n (len(cfg['l4_lengths']) + 0.5) * (len(cfg['l2_lengths']) + 2))\n plot_optimal_uncertainty_reduction(results[e], results_inftau[e])\n\n plt.subplot(*subplot_args(e, 2))\n plt.ylim([10 * cfg['time_scales'][0], 3 * cfg['time_scales'][-1]])\n plt.semilogy()\n set_rowlabels(r\"$\\langle \\tau^* \\rangle$\")\n plt.xticks([])\n plt.xlim(\n 0,\n (len(cfg['l4_lengths']) + 0.5) * (len(cfg['l2_lengths']) + 2))\n plot_optimal_tau(results[e], results_inftau[e])\n\n plt.subplot(*subplot_args(e, 3))\n plt.ylim([10 * cfg['time_scales'][0], 3 * cfg['time_scales'][-1]])\n plt.semilogy()\n set_rowlabels(r\"$\\tau^*_{\\langle I \\rangle}$\")\n plt.xlim(\n 0,\n (len(cfg['l4_lengths']) + 0.5) * (len(cfg['l2_lengths']) + 2))\n plot_optimal_tau_for_mean_uncertainty_reduction(\n results[e], results_inftau[e])\n\n plt.xticks(\n (sp.arange(len(cfg['l4_lengths'])) + 0.5) *\n (len(cfg['l2_lengths']) + 2),\n ['%s' % l for l in cfg['l4_lengths']])","def plot_results(models,\n data,\n batch_size=128,\n model_name=None):\n\n encoder, decoder = models\n x_test, y_test = data\n # display a 2D plot of the digit classes in the latent space\n z_mean = encoder(x_test)\n plt.figure(figsize=(12, 10))\n plt.scatter(z_mean[:, 0], z_mean[:, 1], c=y_test)\n plt.colorbar()\n plt.xlabel(\"z[0]\")\n plt.ylabel(\"z[1]\")\n \n plt.show()\n if not model_name is None:\n os.makedirs(model_name, exist_ok=True)\n filename = os.path.join(model_name, \"vae_mean.png\")\n plt.savefig(filename)\n filename = os.path.join(model_name, \"digits_over_latent.png\")\n # display a 30x30 2D manifold of digits\n n = 30\n digit_size = 28\n figure = np.zeros((digit_size * n, digit_size * n))\n # linearly spaced coordinates corresponding to the 2D plot\n # of digit classes in the latent space\n grid_x = np.linspace(-4, 4, n)\n grid_y = np.linspace(-4, 4, n)[::-1]\n\n for i, yi in enumerate(grid_y):\n for j, xi in enumerate(grid_x):\n z_sample = np.array([[xi, yi]])\n x_decoded = decoder(z_sample)\n digit = x_decoded[0].reshape(digit_size, digit_size)\n figure[i * digit_size: (i + 1) * digit_size,\n j * digit_size: (j + 1) * digit_size] = digit\n\n plt.figure(figsize=(10, 10))\n start_range = digit_size // 2\n end_range = n * digit_size + start_range + 1\n pixel_range = np.arange(start_range, end_range, digit_size)\n sample_range_x = np.round(grid_x, 1)\n sample_range_y = np.round(grid_y, 1)\n plt.xticks(pixel_range, sample_range_x)\n plt.yticks(pixel_range, sample_range_y)\n plt.xlabel(\"z[0]\")\n plt.ylabel(\"z[1]\")\n plt.imshow(figure, cmap='Greys_r')\n if not model_name is None:\n plt.savefig(filename)\n plt.show()","def find_best(results, show_plot=True):\n max_point = max(results)\n print(\"Maximum achieved at d={} and class prior={}. Accuracy of {}%.\".format(max_point[1],max_point[2],max_point[0]))\n if show_plot:\n import matplotlib.pyplot as plt\n from matplotlib import cm\n from mpl_toolkits.mplot3d import Axes3D\n z,x,y = zip(*results)\n fig = plt.figure()\n ax = fig.gca(projection='3d')\n ax.plot_trisurf(x, y, z, cmap=cm.jet, linewidth=0.2)\n ax.text(max_point[1],max_point[2],max_point[0]+2, \"MAX\")\n plt.title('Parameter Tuning Results')\n plt.xlabel('d value')\n plt.ylabel('class prior')\n ax.set_zlabel('Accuracy')\n plt.show()","def plot_results(param_names, param_options, results, params):\n\n\t# circuit/run_num where run_num is one before the existing one\n\tdirectory = params.circuit\n\tif not os.path.isdir(directory):\n\t\tos.mkdir(directory)\n\truns = immediate_subdir(directory)\n\tlatest_run = 0\n\tif runs:\n\t\tnatural_sort(runs)\n\t\tlatest_run = get_trailing_num(runs[-1])\n\tdirectory = os.path.join(directory, \"run\" + str(latest_run+1))\n\n\tprint(directory)\n\tif not os.path.isdir(directory):\n\t\tos.mkdir(directory)\n\n\twith Chdir(directory):\n\n\t\texport_results_to_csv(param_names, results, params)\n\n\t\tx = results.keys()\n\t\ty = []\n\t\tnext_figure = True\n\n\t\tp = 0\n\t\tplt.figure()\n\t\twhile p < len(param_names):\n\t\t\tprint(param_names[p])\n\n\t\t\tif param_options[p]:\n\t\t\t\tnf = True\n\t\t\t\tfor option in param_options[p].split():\n\t\t\t\t\t# stopping has veto power (must all be True to pass)\n\t\t\t\t\tnf = nf and plot_options(option)\n\t\t\t\tnext_figure = nf\n\n\t\t\tif not next_figure:\n\t\t\t\t# y becomes list of lists (for use with stackable plots)\n\t\t\t\ty.append([result[p] for result in results.values()])\n\t\t\t\tp += 1\n\t\t\t\tcontinue\n\t\t\telif not y:\n\t\t\t\ty = [result[p] for result in results.values()]\n\n\t\t\tlx = x[-1]\n\t\t\tly = y[-1]\n\t\t\tplot_method(x,y)\n\t\t\tplt.xlabel('iteration')\n\t\t\tplt.xlim(xmin=0)\n\t\t\t\n\t\t\tplt.ylabel(param_names[p])\n\n\t\t\t# annotate the last value\n\t\t\tannotate_last(lx,ly)\n\n\t\t\tif next_figure:\n\t\t\t\tplt.savefig(param_names[p])\n\t\t\t\tplt.figure()\n\n\t\t\tp += 1\n\t\t# in case the last figure hasn't been shuffled onto file yet\n\t\tif not next_figure:\n\t\t\tplot_method(x,y)\n\t\t\tplt.savefig(param_names[-1])","def plot_a_run(run, ax):\n npz = np.load(run['npz_fname'])\n ckg = npz['nums']\n y_var = run['y_variable']\n full_y = ckg[y_var]\n x_var = run['x_variable']\n full_x = ckg[x_var]\n ### each run is a plot, but it could have multiple lines.\n # this requires some magic, in seperating our data by the second var.\n ## I ASSUME, and this is important, that only two variables change\n x_to_plot = full_x\n x_to_calc = full_x\n y_to_plot = full_y\n ckg_fc = ckg\n if 'second_var' in run: \n ckg_fc = ckg[:,0]\n x_to_calc = full_x[:,0]\n elif ('average_over' in run):#### always do log average\n #y_to_plot = np.average(full_y, axis=1)\n y_to_plot = np.exp(np.average(np.log(full_y), axis=1))\n \n ckg_fc = ckg[:,0]\n x_to_plot = x_to_calc = full_x[:,0]\n #pdb.set_trace()\n ax.plot(x_to_plot, y_to_plot,\".\")\n plot_localization_length(ax, ckg_fc['c'],ckg_fc['k'], ckg_fc['dis_param'], ckg_fc['number_of_points'] , x_to_calc)\n ax.set_xlabel(x_var)\n ax.set_ylabel(y_var)","def plot_mode(params, filename_x=None, filename_z=None, z_range=None):\r\n kz_list = params['kz_list']\r\n layer_bottom_list = params['layer_bottom_list']\r\n N = len(kz_list)\r\n # Choose a range of z to plot:\r\n if z_range is not None:\r\n z_min = z_range[0]\r\n z_max = z_range[1]\r\n else:\r\n if N == 2:\r\n # For 2 layers, put the boundary in the middle, and show the wave\r\n # decaying on both sides\r\n z_max = min(4 / abs(kz.imag) for kz in kz_list)\r\n z_min = -z_max\r\n else:\r\n # For >= 3 layers, the layers should take up central half of plot\r\n z_max = 1.5 * layer_bottom_list[-1]\r\n z_min = -0.5 * layer_bottom_list[-1]\r\n # Calculate the data\r\n zs = np.linspace(z_min, z_max, num=200)\r\n Exs = np.array([Ex(z, params) for z in zs])\r\n Ezs = np.array([Ez(z, params) for z in zs])\r\n # Normalize the E-fields to max 1\r\n max_E = max(abs(Exs).max(), abs(Ezs).max())\r\n Exs = Exs / max_E\r\n Ezs = Ezs / max_E\r\n \r\n plt.figure()\r\n plt.plot(zs / nu.nm, Exs.real, zs / nu.nm, Exs.imag)\r\n for i in range(1,N):\r\n plt.axvline(x=layer_bottom_list[i] / nu.nm, color='k')\r\n plt.title('Ex profile at time 0 and 1/4 cycle later')\r\n plt.xlabel('z position (nm)')\r\n plt.ylabel('E-field (arbitrary units)')\r\n if filename_x is not None:\r\n plt.savefig(filename_x)\r\n \r\n plt.figure()\r\n plt.plot(zs / nu.nm, Ezs.real, zs / nu.nm, Ezs.imag)\r\n for i in range(1,N):\r\n plt.axvline(x=layer_bottom_list[i] / nu.nm, color='k')\r\n plt.title('Ez profile at time 0 and 1/4 cycle later')\r\n plt.xlabel('z position (nm)')\r\n plt.ylabel('E-field (arbitrary units)')\r\n if filename_z is not None:\r\n plt.savefig(filename_z)","def residual_plots(test_data, mods, station=None, squared=False):\r\n import config\r\n learning_var = config.learning_var\r\n data = test_data.get_miniOD()\r\n mods.models[0].mod.load()\r\n pred = mods.models[0].mod.predict(test_data)\r\n test_data.miniOD = None\r\n if squared:\r\n data[test_data.get_stations_col(2015)] = (data[test_data.get_stations_col(2015)] - pred) ** 2 # /pred\r\n else:\r\n data[test_data.get_stations_col(2015)] = data[test_data.get_stations_col(2015)] - pred\r\n ind = data[data['Annee'] == 0].index\r\n data.drop(ind, inplace=True)\r\n print(data.columns.values)\r\n i = 0\r\n if station is None:\r\n ch_an = test_data.get_stations_col(2015)\r\n else:\r\n ch_an = 'End date ' + str(station)\r\n for ch in learning_var:\r\n if not (ch[0] == 'h') and not (ch in ['LV', 'MMJ', 'SD', 'poudrerie', 'verglas']):\r\n # data.boxplot(ch_an, by=ch)\r\n # if ch != 'Heure':\r\n plt.figure(i // 9)\r\n # plt.title('squared error / expectation')\r\n fig = plt.subplot(3, 3, (i % 9) + 1)\r\n i += 1\r\n # fig = plt.figure().add_subplot(111)\r\n fig.set_xlabel(ch)\r\n if squared:\r\n fig.set_ylabel('error²')\r\n else:\r\n fig.set_ylabel('error')\r\n l = []\r\n xaxis = np.unique(data[ch])\r\n print(ch, xaxis.shape)\r\n if xaxis.shape[0] < 20 or ch == 'Heure':\r\n for u in xaxis:\r\n l.append(data[ch_an][data[ch] == u])\r\n else:\r\n m = np.min(data[ch])\r\n M = np.max(data[ch])\r\n step = (M - m) / 20\r\n xaxis = np.arange(m, M, step)\r\n for u in xaxis:\r\n l.append(data[ch_an][(data[ch] >= u) * (data[ch] < u + step)])\r\n xaxis = xaxis.astype(int)\r\n # fig = plt.boxplot(ch_an, by=ch)\r\n # g = data.groupby(ch).mean()[ch_an]\r\n # v = data.groupby(ch).std()[ch_an]\r\n plt.boxplot(l, labels=xaxis)\r\n if squared:\r\n plt.ylim((0, 12))\r\n else:\r\n plt.ylim((-5, 5))\r\n # plt.plot(g, '-r')\r\n # plt.plot(g + v, ':r')\r\n # plt.plot(g - v, ':r')\r\n plt.show()","def results_plot_fuel_reactor(self):\n \n import matplotlib.pyplot as plt \n\n # Total pressure profile\n P = []\n for z in self.MB_fuel.z:\n P.append(value(self.MB_fuel.P[z]))\n fig_P = plt.figure(1)\n plt.plot(self.MB_fuel.z, P)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Total Pressure [bar]\") \n\n # Temperature profile\n Tg = []\n Ts = []\n# Tw = []\n for z in self.MB_fuel.z:\n Tg.append(value(self.MB_fuel.Tg[z] - 273.15))\n Ts.append(value(self.MB_fuel.Ts[z] - 273.15))\n# Tw.append(value(self.MB_fuel.Tw[z]))\n fig_T = plt.figure(2)\n plt.plot(self.MB_fuel.z, Tg, label='Tg')\n plt.plot(self.MB_fuel.z, Ts, label='Ts')\n# plt.plot(self.MB_fuel.z, Tw, label='Tw')\n plt.legend(loc=0,ncol=2)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Temperature [C]\") \n \n # Superficial gas velocity and minimum fluidization velocity\n vg = []\n umf = []\n for z in self.MB_fuel.z:\n vg.append(value(self.MB_fuel.vg[z]))\n umf.append(value(self.MB_fuel.umf[z]))\n fig_vg = plt.figure(3)\n plt.plot(self.MB_fuel.z, vg, label='vg')\n plt.plot(self.MB_fuel.z, umf, label='umf')\n plt.legend(loc=0,ncol=2)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Superficial gas velocity [m/s]\")\n \n # Gas components molar flow rate\n for j in self.MB_fuel.GasList:\n F = []\n for z in self.MB_fuel.z:\n F.append(value(self.MB_fuel.F[z,j]))\n fig_F = plt.figure(4)\n plt.plot(self.MB_fuel.z, F, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Gas component molar flow rate, F [mol/s]\") \n \n # Bulk gas phase total molar flow rate\n Ftotal = []\n for z in self.MB_fuel.z:\n Ftotal.append(value(self.MB_fuel.Ftotal[z]))\n fig_Ftotal = plt.figure(5)\n plt.plot(self.MB_fuel.z, Ftotal)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Total molar gas flow rate [mol/s]\") \n\n # Solid components mass flow rate\n for j in self.MB_fuel.SolidList:\n M = []\n for z in self.MB_fuel.z:\n M.append(value(self.MB_fuel.Solid_M[z,j]))\n fig_M = plt.figure(6)\n plt.plot(self.MB_fuel.z, M, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Solid components mass flow rate [kg/s]\")\n \n # Bulk solid phase total molar flow rate\n Mtotal = []\n for z in self.MB_fuel.z:\n Mtotal.append(value(self.MB_fuel.Solid_M_total[z]))\n fig_Mtotal = plt.figure(7)\n plt.plot(self.MB_fuel.z, Mtotal)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Solid total mass flow rate [kg/s]\") \n \n # Gas phase concentrations\n for j in self.MB_fuel.GasList:\n Cg = []\n for z in self.MB_fuel.z:\n Cg.append(value(self.MB_fuel.Cg[z,j]))\n fig_Cg = plt.figure(8)\n plt.plot(self.MB_fuel.z, Cg, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Concentration [mol/m3]\") \n \n # Gas phase mole fractions\n for j in self.MB_fuel.GasList:\n y = []\n for z in self.MB_fuel.z:\n y.append(value(self.MB_fuel.y[z,j]))\n fig_y = plt.figure(9)\n plt.plot(self.MB_fuel.z, y, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"y [-]\") \n \n # Solid phase mass fractions\n for j in self.MB_fuel.SolidList:\n x = []\n for z in self.MB_fuel.z:\n x.append(value(self.MB_fuel.x[z,j]))\n fig_x = plt.figure(10)\n plt.plot(self.MB_fuel.z, x, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"x [-]\") \n\n # Total mass fraction\n xtot = []\n for z in self.MB_fuel.z:\n xtot.append(value(self.MB_fuel.xtot[z]))\n fig_xtot = plt.figure(11)\n plt.plot(self.MB_fuel.z, xtot)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Total mass fraction [-]\") \n \n # # Gas mix density\n # rhog = []\n # for z in self.MB_fuel.z:\n # rhog.append(value(self.MB_fuel.rho_vap[z]))\n # fig_rhog = plt.figure(23)\n # plt.plot(self.MB_fuel.z, rhog)\n # plt.grid()\n # plt.xlabel(\"Bed height [-]\")\n # plt.ylabel(\"Gas mix density [kg/m3]\") \n \n # Fe conversion\n X_Fe = []\n for z in self.MB_fuel.z:\n X_Fe.append(value(self.MB_fuel.X[z])*100)\n fig_X_Fe = plt.figure(13)\n plt.plot(self.MB_fuel.z, X_Fe)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Fraction of metal oxide converted [%]\")","def plot_visualization(path_results, x_data, y_data, variant_mode, nb_classes, signal_test, args):\n\n\t#path_tsne = path_results + \"/Visualization/train/\" + str(args.step) + \"_2d.csv\"\n\t#data_frame = pd.read_csv(path_tsne)\n\t\n\tpath_maping = path_results + \"/Maping/\" + str(args.subject).split(\".txt\")[0] + \"/\"\n\tfilename = path_maping + \"maping_\" + str(args.step) + \"_\" + str(args.subject).split(\".txt\")[0] + \"_stick\" + str(args.stick) + \".png\"\n\n\tprint(\"path_save maping\", path_maping)\n\n\tif not os.path.exists(path_maping):\n\t\tos.makedirs(path_maping)\n\n\t#print(\"path_tsne\", path_tsne)\n\n\tlabel_maping = np.array([10])\n\n\tx_data = np.concatenate((x_data,signal_test),axis=0)\n\ty_data = np.concatenate((y_data,label_maping),axis=0)\n\n\tprint(\"x_data concatenate\",x_data.shape)\n\tprint(\"y_data concatenate\",y_data.shape)\n\n\tdata_frame = tsne_2d(x_data, y_data)\n\n\t\n\t\n\tgroups = data_frame.groupby('label')\n\n\tcluster_names, cluster_colors = get_target_names_dr(nb_classes, args.mode, args, variant_mode)\n\n\tfig = plt.figure(figsize=(20, 10))\n\tax = fig.add_subplot(111)\n\tax.margins(0.05) # Optional, just adds 5% padding to the autoscaling\n\tfor name, group in groups:\n\t\t\n\t\tif cluster_names[name] == str(args.subject):\n\t\t\tax.scatter(group.x, group.y, marker='D', s=150, edgecolors = 'face',label=cluster_names[name], color=cluster_colors[name])\n\t\telse:\n\t\t\tax.scatter(group.x, group.y, marker='o', label=cluster_names[name], color=cluster_colors[name])\n\n\tax.legend(numpoints=1) #show legend with only 1 point\n\tplt.savefig(filename) #save the plot","def comp2profile(output):\n\n # Load components\n data = '/home/scott/data/insar/cvz/los2xyz/components.txt_backup'\n lon,lat,x,ur,uz = np.loadtxt(data,unpack=True)\n\n # Load FEM output\n points = '/home/scott/research/models/pylith/3d/fialko2012/model3_agu/output_points.txt'\n pointsh5 = '/home/scott/research/models/pylith/3d/fialko2012/model3_agu/output/elastic/apmb/points.h5'\n x_fem, ur_fem, uz_fem = pu.extract_points(pointsh5)\n #NOTE: in this case need radial distance b/c not on x-axis\n #x = np.sqrt(2)*1e3*np.loadtxt(points,usecols=[0])\n # NOTE: cludge fix for negative radial displacements in dipole model\n ur_fem[x_fem >= 40000] = -ur_fem[x_fem >= 40000]\n #ur_fem = np.abs(ur_fem)\n\n #Convert to cm units for plotting\n x_fem = x_fem/1000\n ur_fem = ur_fem * 100.0\n uz_fem = uz_fem * 100.0\n\n #NOTE: must interpolate either insar data or FEM to compare at values at same radial distance\n fig = plt.figure()\n ax = fig.add_subplot(111)\n plt.plot(x, uz, 'b.-', lw=2, label='data')\n plt.plot(x, ur, 'g.-', lw=2)\n plt.plot(x_fem, uz_fem, marker='o', ls='None', lw=2, mec='b', mfc='None',label='FEM')\n plt.plot(x_fem, ur_fem, marker='o', ls='None', lw=2, mec='g', mfc='None')\n plt.axhline(color='k')\n plt.title('FEM vs. Data')\n plt.xlabel('Radial distance [km]')\n plt.ylabel('Displacement [cm]')\n plt.grid(True)\n plt.xlim(0,150) #only show out to 150km\n plt.legend()","def plot_data(data, par, par_names, par_fixed, output_dir='./'):\n\n datasets = dict()\n\n for data_point in data:\n experiment_name = data_point.par['experiment_name']\n datasets.setdefault(experiment_name, list()).append(data_point)\n\n for experiment_name, dataset in datasets.items():\n\n # ##### Matplotlib ######\n\n name_pdf = ''.join([experiment_name, '.pdf'])\n name_pdf = os.path.join(output_dir, name_pdf)\n\n name_txt = ''.join([experiment_name, '.fit'])\n name_txt = os.path.join(output_dir, name_txt)\n\n print(\" * {} [.fit]\".format(name_pdf))\n\n # #######################\n\n data_grouped = group_data(dataset)\n profiles, r2_min, r2_max = compute_profiles(data_grouped)\n ymin, ymax = set_lim([r2_min, r2_max], 0.10)\n\n with PdfPages(name_pdf) as file_pdf, open(name_txt, 'w') as file_txt:\n\n for (_index, id_), profile in sorted(profiles.items()):\n write_profile(id_, profile, file_txt)\n\n ###### Matplotlib ######\n\n fig = plt.figure(1, frameon=True)\n ax = fig.add_subplot(111)\n\n ax.axhline(0, color='black', alpha=0.87)\n\n ########################\n\n frq, r2_cal, r2_exp, r2_erd, r2_eru = profile[0]\n\n ax.plot(\n frq,\n r2_cal,\n linestyle='-',\n color=red200,\n zorder=2,\n )\n\n ax.errorbar(\n frq,\n r2_exp,\n yerr=[r2_erd, r2_eru],\n fmt='o',\n color=red500,\n zorder=3,\n )\n\n xmin, xmax = set_lim(frq, 0.10)\n\n ax.set_xlim(xmin, xmax)\n ax.set_ylim(ymin, ymax)\n\n ax.xaxis.set_major_locator(MaxNLocator(6))\n ax.yaxis.set_major_locator(MaxNLocator(6))\n\n ax.set_xlabel(r'$\\mathregular{\\nu_{CPMG} \\ (Hz)}$')\n ax.set_ylabel(\n r'$\\mathregular{R_{2,eff} \\ (s^{-1})}$')\n\n ax.set_title('{:s}'.format(id_.upper()))\n\n fig.tight_layout()\n\n ########################\n\n file_pdf.savefig()\n plt.close()\n\n ########################\n\n return","def parameter_plots(result_file, fitted_params, resultType, planet,\n plotPublished = False, publishedDataFile = None,\n saveplot=True, foldext='', eclipse = False):\n\n inputData = np.genfromtxt(result_file, dtype=None, delimiter=', ', comments='#', encoding = None)\n\n # Find out the indices of the type of average and the error\n if 't0' in str(inputData[0]):\n values = [s for i, s in enumerate(inputData[0]) if 't0' in s]\n indices = [i for i, s in enumerate(inputData[0]) if 't0' in s]\n Nvalues = len(indices)\n Nbefore = indices[0]\n\n if resultType == 'Mean':\n k = values.index('t0_mu') + Nbefore\n e = values.index('t0_std') + Nbefore\n\n elif resultType == 'Median':\n k = values.index('t0_med') + Nbefore\n e = values.index('t0_poserr') + Nbefore\n\n elif resultType == 'LSQ':\n k = values.index('t0_lqs') + Nbefore\n e = values.index('t0_std') + Nbefore\n\n else:\n raise ValueError(\"Result type not recognised, please chose Mean, Median or LSQ.\")\n\n elif 't_secondary' in str(inputData[0]):\n values = [s for i, s in enumerate(inputData[0]) if 't_secondary' in s]\n indices = [i for i, s in enumerate(inputData[0]) if 't_secondary' in s]\n Nvalues = len(indices)\n Nbefore = indices[0]\n\n if resultType == 'Mean':\n k = values.index('t_secondary_mu') + Nbefore\n e = values.index('t_secondary_std') + Nbefore\n\n elif resultType == 'Median':\n k = values.index('t_secondary_med') + Nbefore\n e = values.index('t_secondary_poserr') + Nbefore\n\n elif resultType == 'LSQ':\n k = values.index('t_secondary_lqs') + Nbefore\n e = values.index('t_secondary_std') + Nbefore\n\n else:\n raise ValueError(\"Result type not recognised, please chose Mean, Median or LSQ.\")\n\n elif 'rp' in str(inputData[0]):\n values = [s for i, s in enumerate(inputData[0]) if 'rp' in s]\n indices = [i for i, s in enumerate(inputData[0]) if 'rp' in s]\n Nvalues = len(indices)\n Nbefore = indices[0]\n\n if resultType == 'Mean':\n k = values.index('rp_mu') + Nbefore\n e = values.index('rp_std') + Nbefore\n\n elif resultType == 'Median':\n k = values.index('rp_med') + Nbefore\n e = values.index('rp_poserr') + Nbefore\n\n elif resultType == 'LSQ':\n k = values.index('rp_lqs') + Nbefore\n e = values.index('rp_std') + Nbefore\n\n else:\n raise ValueError(\"Result type not recognised, please chose Mean, Median or LSQ.\")\n else:\n raise ValueError(\"Not implemented indices selection if we have not fit for t0 or t_secondary or rp\")\n\n # If we have some published values, create a table of the Nsigma difference\n if plotPublished:\n print \"\\nOpening file for writing nsigma from published...\"\n f = open(\"{2}/PhD/SpitzerTransits/{0}{1}/{0}_NsigmaFromPublished.txt\".format(planet, foldext, os.getenv('HOME')), 'w')\n print >> f, (\"Param\\tAOR\\tChannel\\tMethod\\tPub_val\\tPub_err\\tMy_val\\tMy_err\\tSigma\\tNsigdiff\")\n print >> f, (\"==============================================================================================\")\n\n f2 = open(\"{2}/PhD/SpitzerTransits/{0}{1}/{0}_NsigmaBetweenChannels.txt\".format(planet, foldext, os.getenv('HOME')), 'w')\n print >> f2, (\"Param\\tMethod\\tch1_val\\tch1_err\\tch2_val\\tch2_err\\tSigma\\tNsigdiff\")\n print >> f2, (\"==============================================================================================\")\n\n for p in range(len(fitted_params)):\n\n # Figure out which parameter we are looking at\n param = fitted_params[p]\n\n # Get the AOR labels for poly and PLD and check that they are the same for channel 1\n ch1polyAORs = [line[0] for line in inputData if 'ch1' in line and 'poly' in line]\n ch1PLDAORs = [line[0] for line in inputData if 'ch1' in line and 'PLD' in line]\n\n if ch1polyAORs != ch1PLDAORs:\n warnings.warn(\"The PLD and poly AORs for channel 1 are not the same, plotted labels might be wrong!\")\n\n # Get the Mean and stddev of poly and PLD for the parameter that we are looking at for channel 1\n ch1polyMean = [float(line[k+p*Nvalues]) for line in inputData if 'ch1' in line and 'poly' in line]\n ch1PLDMean = [float(line[k+p*Nvalues]) for line in inputData if 'ch1' in line and 'PLD' in line]\n if resultType == 'Mean' or resultType == 'LSQ':\n ch1polyStds = np.array([float(line[e+p*Nvalues]) for line in inputData if 'ch1' in line and 'poly' in line])\n ch1PLDStds = np.array([float(line[e+p*Nvalues]) for line in inputData if 'ch1' in line and 'PLD' in line])\n elif resultType == 'Median':\n # asymetric errors\n ch1polyStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData if 'ch1' in line and 'poly' in line]).T\n ch1PLDStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData if 'ch1' in line and 'PLD' in line]).T\n\n # Get the AOR labels for poly and PLD and check that they are the same for channel 2\n ch2polyAORs = [line[0] for line in inputData if 'ch2' in line and 'poly' in line]\n ch2PLDAORs = [line[0] for line in inputData if 'ch2' in line and 'PLD' in line]\n\n if ch2polyAORs != ch2PLDAORs:\n warnings.warn(\"The PLD and poly AORs for channel 2 are not the same, plotted labels might be wrong!\")\n\n # Get the Mean and stddev of poly and PLD for the parameter that we are looking at for channel 2\n ch2polyMean = [float(line[k+p*Nvalues]) for line in inputData if 'ch2' in line and 'poly' in line]\n ch2PLDMean = [float(line[k+p*Nvalues]) for line in inputData if 'ch2' in line and 'PLD' in line]\n if resultType == 'Mean' or resultType == 'LSQ':\n ch2polyStds = np.array([float(line[e+p*Nvalues]) for line in inputData if 'ch2' in line and 'poly' in line])\n ch2PLDStds = np.array([float(line[e+p*Nvalues]) for line in inputData if 'ch2' in line and 'PLD' in line])\n elif resultType == 'Median':\n # asymmetric errors\n ch2polyStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData if 'ch2' in line and 'poly' in line]).T\n ch2PLDStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData if 'ch2' in line and 'PLD' in line]).T\n\n # Calculate the weighted means...\n if len(ch1polyMean) > 1. and param != 't0':\n WMch1poly, TSch1poly = weightedMean(np.array(ch1polyMean), np.array(ch1polyStds))\n WMch1PLD, TSch1PLD = weightedMean(np.array(ch1PLDMean).flatten(), np.array(ch1PLDStds))\n WMch2poly, TSch2poly = weightedMean(np.array(ch2polyMean), np.array(ch2polyStds))\n WMch2PLD, TSch2PLD = weightedMean(np.array(ch2PLDMean), np.array(ch2PLDStds))\n\n # Initialise plotting the parameters\n fig = plt.figure(figsize=(8,5))\n ax1 = fig.add_axes([0.1, 0.1, 0.4, 0.8])\n ax2 = fig.add_axes([0.5, 0.1, 0.4, 0.8])\n ax1.set_title(r'Ch1 ($3.6\\mu m$)')\n ax2.set_title(r'Ch2 ($4.5\\mu m$)')\n ax1.set_ylabel(param)\n\n # Channel 1\n # polynomial\n ax1.errorbar(np.array(range(len(ch1polyMean)))-0.05, ch1polyMean, yerr = ch1polyStds, marker = 'o', linestyle='', color ='b', label = 'Poly')\n # PLD\n ax1.errorbar(np.array(range(len(ch1PLDMean)))+0.05, ch1PLDMean, yerr = ch1PLDStds, marker = 'o', linestyle='', color = 'r', label = 'PLD')\n # labels\n ax1.set_xticks(range(len(ch1PLDMean)))\n ax1.set_xticklabels(ch1polyAORs, rotation='vertical')\n\n\n # Channel2\n # polynomial\n ax2.errorbar(np.array(range(len(ch2polyMean )))-0.05, ch2polyMean, yerr = ch2polyStds, marker = 'o', linestyle='', color ='b')\n # PLD\n ax2.errorbar(np.array(range(len(ch2PLDMean )))+0.05, ch2PLDMean, yerr = ch2PLDStds, marker = 'o', linestyle='', color = 'r')\n # labels\n ax2.set_xticks(range(len(ch2PLDMean)))\n ax2.set_xticklabels(ch2polyAORs, rotation='vertical')\n\n # Plot the weighted means\n if len(ch1polyMean) > 1. and param != 't0':\n ax1.axhline(WMch1poly, color = 'b')\n ax1.axhspan(WMch1poly - TSch1poly,\n WMch1poly + TSch1poly,\n alpha = 0.3, color='b', label='Weighted Mean')\n ax1.axhline(WMch1PLD, color = 'r')\n ax1.axhspan(WMch1PLD - TSch1PLD,\n WMch1PLD + TSch1PLD,\n alpha = 0.3, color='r',label='Weighted Mean')\n\n ax2.axhline(WMch2poly, color = 'b')\n ax2.axhspan(WMch2poly - TSch2poly,\n WMch2poly + TSch2poly,\n alpha = 0.3, color='b')\n ax2.axhline(WMch2PLD, color = 'r')\n ax2.axhspan(WMch2PLD - TSch2PLD,\n WMch2PLD + TSch2PLD,\n alpha = 0.3, color='r')\n\n if plotPublished:\n # Plot the published values if they they are given\n # and calculate Nsigma from published and save to a file\n data = np.genfromtxt(publishedDataFile, dtype=None, delimiter=', ', encoding = None)\n\n if param in data.T[0].tolist():\n\n pIdx = data.T[0].tolist().index(param)\n ax1.axhline(float(data[pIdx][1]), color = 'k', linestyle = 'dashed')\n ax1.axhspan(float(data[pIdx][1]) - float(data[pIdx][2]),\n float(data[pIdx][1]) + float(data[pIdx][2]),\n alpha = 0.3, color='k',label='Literature')\n\n ax2.axhline(float(data[pIdx][3]),color = 'k', linestyle = 'dashed')\n ax2.axhspan(float(data[pIdx][3]) - float(data[pIdx][4]),\n float(data[pIdx][3]) + float(data[pIdx][4]),\n alpha = 0.3, color='k',label='Literature')\n\n # Save the number of sigma to a file\n # Deal with polynomial first\n for i in range(len(ch1polyAORs)):\n print >> f, ('{0:}\\t{1:}\\t{2:}\\t{3:}\\t{4:.4f}\\t{5:.4f}\\t{6:.4f}\\t{7:.4f}\\t{8:.4f}\\t{9:.4f}'.format(\n param, ch1polyAORs[i], 'ch1', 'poly',\n float(data[pIdx][1]), float(data[pIdx][2]), #channel 1\n float(ch1polyMean[i]), float(ch1polyStds.T[i].max()), # choose the biggest error\n *nsigma(float(data[pIdx][1]), float(data[pIdx][2]),float(ch1polyMean[i]), float(ch1polyStds.T[i].max()))))\n\n for i in range(len(ch2polyAORs)):\n print >> f, ('{0:}\\t{1:}\\t{2:}\\t{3:}\\t{4:.4f}\\t{5:.4f}\\t{6:.4f}\\t{7:.4f}\\t{8:.4f}\\t{9:.4f}'.format(\n param, ch2polyAORs[i], 'ch2', 'poly',\n float(data[pIdx][3]), float(data[pIdx][4]), #channel 2\n float(ch2polyMean[i]), float(ch2polyStds.T[i].max()), # choose the biggest error\n *nsigma(float(data[pIdx][3]), float(data[pIdx][4]),float(ch2polyMean[i]), float(ch2polyStds.T[i].max()))))\n\n # PLD\n for i in range(len(ch1PLDAORs)):\n print >> f, ('{0:}\\t{1:}\\t{2:}\\t{3:}\\t{4:.4f}\\t{5:.4f}\\t{6:.4f}\\t{7:.4f}\\t{8:.4f}\\t{9:.4f}'.format(\n param, ch1PLDAORs[i], 'ch1', 'PLD',\n float(data[pIdx][1]), float(data[pIdx][2]), #channel 1\n float(ch1PLDMean[i]), float(ch1PLDStds.T[i].max()), # choose the biggest error\n *nsigma(float(data[pIdx][1]), float(data[pIdx][2]),float(ch1PLDMean[i]), float(ch1PLDStds.T[i].max()))))\n\n for i in range(len(ch2PLDAORs)):\n print >> f, ('{0:}\\t{1:}\\t{2:}\\t{3:}\\t{4:.4f}\\t{5:.4f}\\t{6:.4f}\\t{7:.4f}\\t{8:.4f}\\t{9:.4f}'.format(\n param, ch2PLDAORs[i], 'ch2', 'PLD',\n float(data[pIdx][3]), float(data[pIdx][4]), #channel 2\n float(ch2PLDMean[i]), float(ch2PLDStds.T[i].max()), # choose the biggest error\n *nsigma(float(data[pIdx][3]), float(data[pIdx][4]),float(ch2PLDMean[i]), float(ch2PLDStds.T[i].max()))))\n else:\n pass\n\n # Write the difference between the two channels to a text file\n if param != 't0' and param != 'rp':\n if len(ch1polyMean) > 1.:\n # polynomial\n for i in range(len(ch1polyAORs)):\n print >> f2, ('{0:}\\t{1:}\\t{2:.4f}\\t{3:.4f}\\t{4:.4f}\\t{5:.4f}\\t{6:.4f}\\t{7:.4f}'.format(\n param, 'poly',\n float(WMch1poly[i]), float(TSch1poly.T[i].max()), #channel 1\n float(WMch2poly[i]), float(TSch2poly.T[i].max()), # choose the biggest error\n *nsigma(float(WMch1poly[i]), float(TSch1poly.T[i].max()),\n float(WMch2poly[i]), float(TSch2poly.T[i].max()))))\n\n # PLD\n for i in range(len(ch1polyAORs)):\n print >> f2, ('{0:}\\t{1:}\\t{2:.4f}\\t{3:.4f}\\t{4:.4f}\\t{5:.4f}\\t{6:.4f}\\t{7:.4f}'.format(\n param, 'PLD',\n float(WMch1PLD[i]), float(TSch1PLD.T[i].max()), #channel 1\n float(WMch2PLD[i]), float(TSch2PLD.T[i].max()), # choose the biggest error\n *nsigma(float(WMch1PLD[i]), float(TSch1PLD.T[i].max()),\n float(WMch2PLD[i]), float(TSch2PLD.T[i].max()))))\n else:\n # polynomial\n for i in range(len(ch1polyAORs)):\n print >> f2, ('{0:}\\t{1:}\\t{2:.4f}\\t{3:.4f}\\t{4:.4f}\\t{5:.4f}\\t{6:.4f}\\t{7:.4f}'.format(\n param, 'poly',\n float(ch1polyMean[i]), float(ch1polyStds.T[i].max()), #channel 1\n float(ch2polyMean[i]), float(ch2polyStds.T[i].max()), # choose the biggest error\n *nsigma(float(ch1polyMean[i]), float(ch1polyStds.T[i].max()),\n float(ch2polyMean[i]), float(ch2polyStds.T[i].max()))))\n\n # PLD\n for i in range(len(ch1polyAORs)):\n print >> f2, ('{0:}\\t{1:}\\t{2:.4f}\\t{3:.4f}\\t{4:.4f}\\t{5:.4f}\\t{6:.4f}\\t{7:.4f}'.format(\n param, 'PLD',\n float(ch1PLDMean[i]), float(ch1PLDStds.T[i].max()), #channel 1\n float(ch2PLDMean[i]), float(ch2PLDStds.T[i].max()), # choose the biggest error\n *nsigma(float(ch1PLDMean[i]), float(ch1PLDStds.T[i].max()),\n float(ch2PLDMean[i]), float(ch2PLDStds.T[i].max()))))\n else:\n pass\n\n\n # Set the y limits of both plots to be the same sacle and to include both ch1 and ch2 points\n axis1ylim = ax1.get_ylim()\n axis2ylim = ax2.get_ylim()\n if ax1.get_ylim()[0] < ax2.get_ylim()[0]:\n ymin = ax1.get_ylim()[0]\n else:\n ymin = ax2.get_ylim()[0]\n if ax1.get_ylim()[1] < ax2.get_ylim()[1]:\n ymax = ax2.get_ylim()[1]\n else:\n ymax = ax1.get_ylim()[1]\n ax1.set_ylim(ymin,ymax)\n ax2.set_ylim(ax1.get_ylim())\n ax2.get_yaxis().set_visible(False)\n\n ax1.legend(loc = 'best')\n\n\n # Save if required\n if saveplot:\n plt.savefig(\"{3}/PhD/SpitzerTransits/{0}{1}/{0}_{2}.png\".format(planet,foldext,param,os.getenv('HOME')),bbox_inches='tight')\n plt.close()\n if plotPublished:\n f.close()\n else:\n pass\n f2.close()","def plot_recovery_results(\n recovery_results, variable_parameter, limits=None, ticks=None\n):\n\n fig, axs = plt.subplots(3, 3, figsize=cm2inch(9, 9), sharex=True, sharey=True)\n\n parameter_names = [\"alpha_pos\", \"alpha_neg\", \"beta\"]\n parameter_labels = {\n \"alpha_pos\": r\"$\\alpha^{+}$\",\n \"alpha_neg\": r\"$\\alpha^{-}$\",\n \"beta\": r\"$\\beta$\",\n }\n\n others = [p for p in parameter_names if p != variable_parameter]\n\n df = recovery_results.loc[recovery_results[\"variable\"] == variable_parameter]\n\n for i, other0_val in enumerate([\"low\", \"medium\", \"high\"]):\n for j, other1_val in enumerate([\"low\", \"medium\", \"high\"]):\n label = (\n parameter_labels[others[0]]\n + f\": {other0_val}\"\n + \"\\n\"\n + parameter_labels[others[1]]\n + f\": {other1_val}\"\n )\n\n ax = axs[i, j]\n ax.set_title(label)\n\n df_ij = df.loc[\n (df[f\"{others[0]}_level\"] == other0_val)\n & (df[f\"{others[1]}_level\"] == other1_val)\n ]\n\n # Scatter plot of generating and recovered parameters\n ax.plot(\n df_ij[f\"{variable_parameter}\"],\n df_ij[f\"{variable_parameter}_hat\"],\n \"o\",\n markeredgewidth=0.25,\n )\n\n # Set ticks and boundaries\n if ticks is not None:\n ax.set_xticks(ticks)\n ax.set_yticks(ticks)\n\n if limits is None:\n limits = [\n df_ij[\n [variable_parameter, f\"{variable_parameter}_hat\"]\n ].values.min(),\n df_ij[\n [variable_parameter, f\"{variable_parameter}_hat\"]\n ].values.max(),\n ]\n ax.set_xlim(limits)\n ax.set_ylim(limits)\n\n # Run robust linear regression and Spearman correlation\n gen = df_ij[variable_parameter].values\n rec = df_ij[f\"{variable_parameter}_hat\"].values\n r, p = spearmanr(gen, rec)\n endog = rec\n exog = sm.add_constant(gen)\n model = sm.RLM(endog=endog, exog=exog)\n results = model.fit()\n\n # Plot regression line\n intercept, beta = results.params\n x = np.linspace(*ax.get_xlim(), 100)\n ax.plot(x, intercept + beta * x, color=\"C0\", alpha=0.7, zorder=0)\n\n # Annotate regression statistics\n pstring = make_pstring(p)\n annotation = (\n f\"r = {r:.2f}, \"\n + pstring\n + f\"\\nIntercept = {intercept:.2f}\\nSlope = {beta:.2f}\"\n )\n ax.annotate(\n annotation,\n (0.95, 0.05),\n xycoords=\"axes fraction\",\n ha=\"right\",\n va=\"bottom\",\n fontsize=3,\n )\n\n # Plot diagonal line\n ax.plot(\n ax.get_xlim(),\n ax.get_ylim(),\n \"-\",\n linewidth=0.5,\n color=\"lightgray\",\n zorder=-1,\n )\n\n for ij in range(3):\n axs[-1, ij].set_xlabel(\"Gen.\")\n axs[ij, 0].set_ylabel(\"Rec.\")\n\n fig.tight_layout()\n fig.suptitle(\n r\"$\\bf{\" + parameter_labels[variable_parameter][1:-1] + \"}$\",\n y=1.05,\n fontweight=\"bold\",\n )\n\n return fig, axs","def P_AI_Rocky(in_dict):\n # START\n fs = 16\n plt.rc('font', size=fs)\n fig = plt.figure(figsize=(14,12))\n ds = nc.Dataset(in_dict['fn'])\n\n # PLOT CODE\n aa = [-122.8, -122.54, 47.92, 48.22]\n import cmocean\n cmap = cmocean.cm.balance\n # cmap = 'RdYlBu_r'\n\n from warnings import filterwarnings\n filterwarnings('ignore') # skip some warning messages\n \n # plot Code\n \n # calculate divergence and vorticity\n uu = ds['u'][0, -1, :, :]\n vv = ds['v'][0, -1, :, :]\n u = zfun.fillit(uu)\n v = zfun.fillit(vv)\n u[np.isnan(u)] = 0\n v[np.isnan(v)] = 0\n \n G = zrfun.get_basic_info(in_dict['fn'], only_G=True)\n \n dive = ((np.diff(u, axis=1)/G['DX'][:, 1:-1])[1:-1, :]\n + (np.diff(v, axis = 0)/G['DY'][1:-1, :])[:, 1:-1])\n #dive[G['mask_rho'][1:-1,1:-1]==False] = np.nan\n \n vort = np.diff(v, axis=1)/G['DX'][1:,1:] - np.diff(u, axis=0)/G['DY'][1:,1:]\n #vort[G['mask_rho'][1:,1:]==False] = np.nan\n \n scl = 2e-3\n \n # panel 1\n ax = fig.add_subplot(121)\n # cs = plt.pcolormesh(G['lon_psi'], G['lat_psi'], dive/scl, cmap=cmap,\n # vmin=-1, vmax=1)\n cs = plt.pcolormesh(G['lon_rho'][1:-1,1:-1], G['lat_rho'][1:-1,1:-1], dive/scl, cmap=cmap,\n vmin=-1, vmax=1, shading='gouraud')\n tstr = (r'Surface Divergence (%0.1e $s^{-1}$)' % (scl))\n #pfun.add_bathy_contours(ax, ds, txt=True)\n pfun.add_coast(ax)\n ax.axis(aa)\n pfun.dar(ax)\n ax.set_xlabel('Longitude')\n ax.set_ylabel('Latitude')\n ax.set_title(tstr)\n pfun.add_info(ax, in_dict['fn'])\n ax.set_xticks([-122.8, -122.7, -122.6])\n ax.set_yticks([48, 48.1, 48.2])\n #\n # panel 2\n ax = fig.add_subplot(122)\n # cs = plt.pcolormesh(G['lon_rho'], G['lat_rho'], vort/scl, cmap=cmap,\n # vmin=-1, vmax=1)\n cs = plt.pcolormesh(G['lon_psi'], G['lat_psi'], vort/scl, cmap=cmap,\n vmin=-1, vmax=1, shading='gouraud')\n tstr = (r'Surface Vorticity (%0.1e $s^{-1}$)' % (scl))\n ax.set_xticks([-122.8, -122.7, -122.6])\n ax.set_yticks([])\n #fig.colorbar(cs)\n \n # Inset colorbar\n from mpl_toolkits.axes_grid1.inset_locator import inset_axes\n cbaxes = inset_axes(ax, width=\"4%\", height=\"40%\", loc='lower left')\n fig.colorbar(cs, cax=cbaxes, orientation='vertical')\n \n #pfun.add_bathy_contours(ax, ds)\n pfun.add_coast(ax)\n ax.axis(aa)\n pfun.dar(ax)\n ax.set_xlabel('Longitude')\n ax.set_title(tstr) \n \n #fig.tight_layout()\n # FINISH\n ds.close()\n if len(in_dict['fn_out']) > 0:\n plt.savefig(in_dict['fn_out'])\n plt.close()\n else:\n plt.show()\n plt.rcdefaults()","def plot_profile(outdir, xval='x', xscale=1, yscale=1, comp2los=False, adjustRadial=False,\n fig=True):\n #Load data\n path = os.path.join(outdir,'points.h5')\n x,y,z,ux,uy,uz = pu.extract_points(path)\n\n Y = uz / yscale\n if xval == 'x':\n X = x / xscale\n Y1 = ux / yscale\n elif xval == 'r':\n X = np.hypot(x,y) / xscale\n ur = np.hypot(ux,uy)\n Y1 = ur / yscale\n if adjustRadial: #fix sign from hypot square root\n ur = pu.radial2negative(Y1)\n\n if fig:\n plt.figure()\n # otherwise profile added to active plot\n\n #plt.plot(X,uy/yscale,'r.-',label='Uy') #should be zero along EW axis\n de = 90e3 / xscale #eastern data extent\n if comp2los != False:\n data_extents = (X<=de)\n if comp2los == 'west': #switch sign of radial profile\n #ux = -ux #move to comp2los function\n X = -X\n Y1 = -Y1\n de = -de\n data_extents = (X>=de)\n\n los = pu.comp2los(x,ux,uy,uz,track=comp2los)\n plt.plot(X, los/yscale, 'k-', lw=2, label='Ulos_' + comp2los)\n plt.fill_between(X,los/yscale, where=data_extents, color='gray',alpha=0.5)\n\n plt.plot(X, Y, 'b-', lw=2, label='Uz')\n plt.plot(X, Y1, 'b--',lw=2, mfc='None',label='U{0}'.format(xval))\n\n # Annotate\n plt.title(outdir)\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n plt.ylabel('Uz [{}]'.format(get_unit(yscale)))\n plt.axhline(color='k')\n plt.axvline(de,color='k', linestyle='dashed', label='EW data extent') #EW extent of InSAR coverage\n plt.legend(loc='best')\n plt.grid(True)\n plt.show()","def plot_residuals(result_file,output_fig=None,fig=None,**kwargs):\n \n \n #### Read file\n \n dic_result=file2dic(result_file)\n\n ### Get xbin range\n \n rms_val=np.append(dic_result['RMS_P'],dic_result['RMS_S'])\n x_bins=np.linspace(np.min(rms_val),np.max(rms_val),100)\n \n ### Plots\n \n if fig is None:\n fig, (ax1, ax2) = plt.subplots(2, sharex=True)\n else: \n (ax1,ax2)=fig.get_axes()\n \n ax1.hist(dic_result['RMS_P'],x_bins,edgecolor='black',**kwargs)\n ax1.set_title('RMS for %i models tested'%(len(dic_result['RMS_P'])))\n ax1.set_ylabel('P')\n ax1.tick_params('x',direction='in')\n ax2.hist(dic_result['RMS_S'],x_bins,edgecolor='black',**kwargs)\n ax2.invert_yaxis()\n ax2.set_xlabel('RMS [s]')\n ax2.set_ylabel('S')\n \n fig.subplots_adjust(hspace=0)\n plt.setp([a.get_xticklabels() for a in fig.axes[:-1]], visible=False)\n \n if output_fig:\n plt.savefig(output_fig)\n \n \n return fig","def SH_surface_plots(n_max=6,figsize=(15,15),fs=15,saveA=True,show=False,dpi=400,vis_type='real'):\n\n N = 100j\n\n for n in range(n_max+1):\n for m in range(n+1):\n plt.close('all')\n print(\"working on Y_%s^%s\" % (n,m) )\n\n PHI,THETA = np.mgrid[0:2*np.pi:N*2, 0:np.pi:N]\n if vis_type == 'real':\n R = sp.sph_harm(m,n,PHI,THETA).real\n if vis_type == 'modulus':\n r = sp.sph_harm(m,n,PHI,THETA)\n R = r * r.conjugate()\n if vis_type == 'unit':\n R = sp.sph_harm(m,n,PHI,THETA).real + 1\n\n X = np.abs(R) * np.sin(THETA) * np.cos(PHI)\n Y = np.abs(R) * np.sin(THETA) * np.sin(PHI)\n Z = np.abs(R) * np.cos(THETA)\n\n norm = colors.Normalize()\n fig, ax = plt.subplots(subplot_kw=dict(projection='3d'), figsize=(14,10))\n sm = cm.ScalarMappable(cmap=cm.seismic)\n ax.plot_surface(X, Y, Z, rstride=1, cstride=1, facecolors=cm.seismic(norm(R)))\n ax.set_title('real$(Y^%s_%s)$' % (m,n), fontsize=fs)\n ax.set_aspect(1)\n sm.set_array(R)\n fig.colorbar(sm, shrink=0.8)\n\n if saveA:\n fig.savefig('images/%s/%s_%s.png' % (vis_type,n,m), dpi=dpi)\n if show:\n plt.show()\n\n # print(\"\\n only +m values are used.\")\n # for n in range(n_max+1):\n # for m in range(n+1):\n # plt.close('all')\n # print(\"\\n n,m = %s,%s\" % (n,m) )\n #\n # R,X,Y,Z = harmonics(m,n)\n #\n # fig = plt.figure(figsize=figsize)\n # ax = plt.subplot(projection='3d')\n # ax.set_aspect(1)\n # ax.set_title(\"n: %s m: %s\" % (n,m), fontsize=fs+2)\n # ax.plot_surface(X,Y,Z,\\\n # cmap = cm.seismic,\n # norm = colors.Normalize( vmin=np.min(R),vmax=np.max(R) )\\\n # )\n #\n # if saveA:\n # fig.savefig('images/%s_%s.png' % (n,m), dpi=dpi)\n # if show:\n # plt.show()","def psfminusmodel_plot(epoch, model, features, filters, figname, fgal=0.5,\n idx=-1):\n # fetch Stripe 82 data\n X, Xcov = fetch_prepped_s82data(epoch, fgal, features, filters)\n Xcoadd, Xcoaddcov = fetch_prepped_s82data(epoch, fgal, features,\n filters, use_single=False)\n\n # unpickle the XD model\n if type(model) == str: \n f = open(model, 'rb')\n model = cPickle.load(f)\n f.close()\n\n fs = 5\n Nbins = [50, 50, 50]\n lsize = 20\n mags = [19.5, 20.5, 21.5]\n dlt = [0.15, 0.15, 0.15]\n f = pl.figure(figsize=(3 * fs, fs))\n pl.subplots_adjust(wspace=0.3)\n for i in range(len(mags)):\n ind = (Xcoadd[:, idx] < 0.03) & (Xcoadd[:, 0] > mags[i] - dlt[i])\n ind = ind & (Xcoadd[:, 0] <= mags[i] + dlt[i])\n\n x = X[ind]\n xc = Xcov[ind]\n\n a, m, v = model.posterior(x, xc)\n posts = np.zeros_like(x)\n for j in range(x.shape[0]):\n posts[j] = np.median(model.sample(a[j], m[j], v[j], size=1000),\n axis=0)\n\n ax = pl.subplot(1, 3, i + 1)\n h, b = np.histogram(x[:, idx], Nbins[i])\n d = (b[1] - b[0]) / 2.\n b = np.append([b[0] - d], b[:-1] + d)\n h = np.append([1.0], h)\n pl.plot(b, h, drawstyle='steps-mid', linestyle='dotted',\n color='k', lw=2)\n h, b = np.histogram(posts[:, idx], Nbins[i])\n d = (b[1] - b[0]) / 2.\n b = np.append([b[0] - d], b[:-1] + d)\n h = np.append([1.0], h)\n pl.plot(b, h, drawstyle='steps-mid', color='k', lw=2)\n pl.xlabel('psfmag - modelmag $r$', fontsize=lsize)\n pl.ylabel('counts', fontsize=lsize)\n ax.text(0.95, 0.95, '$r=%0.1f$' % mags[i], fontsize=lsize, ha='right',\n va='top', transform=ax.transAxes)\n pl.xlim(-0.1, 0.2)\n f.savefig(figname, bbox_inches='tight')","def plot_multiLyapunov(systems, mode=2, savefig=True, figname=None):\n if mode == 2:\n print(systems)\n# divnorm = colors.DivergingNorm(vmin=max([np.nanmin(np.nanmax(np.nanmax(system.lyapunov_2, axis=0), axis=0)) for system in systems]), vcenter=0, vmax=max[np.nanmax(system.lyapunov_2) for system in systems])\n if figname == None:\n figname = 'sum_of_first_2_lyapunov'\n \n fig, ax = plt.subplots()\n for system in systems:\n\n lyapunov_2 = system.lyapunov_2\n x = system.x\n y = system.y\n l = system.l\n a = system.a\n\n\n\n plt.contourf(a[0,0,:,:],l[0,0,:,:],np.nanmax(np.nanmax(lyapunov_2, axis=0), axis=0), levels = 100, cmap = 'RdBu_r')\n# , norm=divnorm)\n for i in range(lyapunov_2.shape[0]):\n for j in range(lyapunov_2.shape[1]):\n plt.contour(a[0,0,:,:],l[0,0,:,:],lyapunov_2[i,j], levels = [0,], colors=('k',),alpha=0.1)\n lyap_sum = plt.contour(a[0,0,:,:],l[0,0,:,:],lyapunov_2.max(axis=0).max(axis=0), levels = [0,], colors=('blue',),alpha=1)\n\n# cbar = plt.colorbar()\n plt.plot(wild_chaos[:,0],wild_chaos[:,1],'--r',lw=3)\n plt.title('Sum of the first 2 Lyapunov exponents ')\n plt.ylabel('$\\lambda$')\n plt.xlabel('a')\n# cbar.ax.set_ylabel('Sum of the first 2 Lyapunov exponents')\n\n ax.set_ylim([l.min(),l.max()])\n ax.set_xlim([a.min(),a.max()])\n if savefig:\n plt.savefig(f'images/{figname}.pdf')\n plt.show()","def make_summary_plot(run_lists, file_descriptor, attr='sipm1.threeSampleAmpl'):\n biases = []\n gains = []\n pes = []\n currs = []\n gainerrs = []\n quad_terms = []\n quad_errs = []\n for row in sorted(run_lists):\n biases.append(row[0])\n gain_out = fit_gain(row[1], attr=attr)\n out_tuple = gain_out[0]\n gains.append(out_tuple[0])\n gainerrs.append(out_tuple[3])\n smeans = sorted(gain_out[1])\n currs.append(0.5*(smeans[-1] + smeans[-2]))\n pes.append(currs[-1]/gains[-1])\n quad_terms.append(out_tuple[1])\n quad_errs.append(out_tuple[4])\n\n maxgain = max(gains)\n gains = np.array(gains)/maxgain\n gainerrs = np.array(gainerrs)/maxgain\n # gainerrs = 0.1*gains\n\n currs = np.array(currs)/max(currs)\n pes = np.array(pes)\n pe_errs = gainerrs/gains*pes\n maxpe = max(pes)\n fig, ax1 = plt.subplots()\n\n coeffs, V = np.polyfit(biases, gains, 1, w=1.0/gainerrs, cov=True)\n breakdown = -1*coeffs[1]/coeffs[0]\n\n breakdown_sigma = sigma_from_cov(coeffs, V)\n\n # calculate sigmas throughout range\n vals, vecs = np.linalg.eig(V)\n U = np.transpose(vecs)\n xs_for_error = np.arange(breakdown - 0.1, max(biases) + 0.1, 0.01)\n gain_sigmas = sig_from_diag(xs_for_error, U, vals)\n error_band_ys = np.array([i*coeffs[0] + coeffs[1] for i in xs_for_error])\n ax1.fill_between(xs_for_error, error_band_ys + gain_sigmas,\n error_band_ys - gain_sigmas, facecolor='red', alpha=0.5)\n\n fitline = [i*coeffs[0] + coeffs[1] for i in biases] + [0]\n fitbiases = biases + [breakdown]\n\n ax1.set_title('bias scan %s' % file_descriptor)\n fitplot = ax1.plot(fitbiases, fitline, 'r-')\n gainplot = ax1.errorbar(\n biases, gains, yerr=gainerrs, fmt='ro', markersize=10)\n currplot = ax1.plot(biases, currs, 'g*', markersize=15)\n ax1.set_ylim(0, 1.105)\n ax1.set_xlim([breakdown - 0.1, max(biases) + 0.1])\n ax1.set_xlabel('bias voltage [V]')\n ax1.set_ylabel('relative gain, charge [a.u.]')\n\n ticks = [breakdown]\n ticks.extend([bias for bias in biases[::2]])\n tick_labels = ['%.1f $\\pm$ %.1f' % (breakdown, breakdown_sigma)]\n tick_labels.extend([str(bias) for bias in biases[::2]])\n ax1.set_xticks(ticks)\n ax1.set_xticklabels(tick_labels)\n ax1.grid()\n ax1.get_xticklabels()[0].set_color('r')\n\n ax2 = ax1.twinx()\n peplot = ax2.errorbar(biases, pes, yerr=pe_errs, fmt='b^', markersize=10)\n ax2.set_ylabel('pe', color='b')\n ax2.set_ylim(0, maxpe*1.105)\n ax2.set_xlim([breakdown - 0.1, max(biases) + 0.1])\n for tick in ax2.get_yticklabels():\n tick.set_color('b')\n ax1.legend([gainplot[0]]+currplot+[peplot[0]]+fitplot,\n ['gain', 'charge', 'pes', 'gain fit'],\n loc='best', numpoints=1)\n\n plt.savefig('pdfs/breakdownPlot%s.pdf' % file_descriptor)\n plt.show()\n\n quadploterrs = 0.5/np.sqrt(quad_terms)*quad_errs\n plt.errorbar(biases, np.sqrt(quad_terms)*100, yerr=quadploterrs*100, fmt='ko')\n plt.xlim(min(biases) - 0.1, max(biases) + 0.1)\n plt.xlabel('bias [V]')\n plt.ylabel('sqrt(quadratic term) [%]')\n plt.title('quadratic terms %s' % file_descriptor)\n\n plt.savefig('pdfs/quadraticTerms%s.pdf' % file_descriptor)\n plt.show()","def plot_trust_region_results():\n RESULTS_DIR = \"trust_region_experiments\"\n ENV = \"DangerousPath-HalfMines-len25-dim5-v0\"\n DIR_TEMPLATE = \"{env}_lr_{learning_rate}\"\n STDOUT_TEMPLATE = \"{method}_repetition_{repetition}.txt\"\n REWARD_PATTERN = r\"ep_rew_mean[ ]*\\| ([0-9\\.\\-]*)\"\n TIMESTEP_PATTERN = r\"total_timesteps[ ]*\\| ([0-9]*)\"\n\n NUM_REPETITIONS = 50\n # Forcing to high learning rate to force out the \"constraint\"\n LEARNING_RATES = [\"1e-3\"]\n\n METHODS = {\n \"No Constraint\": [\"NoConstraint\"],\n #\"ClipPPO\": [\"ClipPPO\"],\n \"Max Action TV\": [\"PiMaxTV_{}\".format(kl) for kl in [0.001, 0.005, 0.01, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5]],\n \"Gaussian\": [\"Gaussian_{}\".format(kl) for kl in [0.5, 1.0, 2.0, 3.0, 5.0, 10.0, 15.0, 20.0]],\n \"Supervector\": [\"Supervector_{}\".format(kl) for kl in [0.01, 0.05, 0.1, 0.15, 0.2, 0.3, 0.4, 0.5]],\n }\n\n # Match with novelty search\n COLORS = [\n \"C0\",\n \"C1\",\n \"C2\",\n \"C3\",\n ]\n\n fig = pyplot.figure(figsize=[4.8, 4.8])\n path_to_log_template = os.path.join(RESULTS_DIR, DIR_TEMPLATE, STDOUT_TEMPLATE)\n\n for (legend_name, experiment_names), color in zip(METHODS.items(), COLORS):\n # For each method, find the best learning curve (based on AUC)\n # and plot it\n best_x = None\n best_y = None\n best_y_upper = None\n best_y_lower = None\n best_std = None\n best_auc = None\n best_description = \"\"\n\n for learning_rate in LEARNING_RATES:\n for experiment_name in experiment_names:\n # Construct learning curves\n xs = []\n ys = []\n for repetition in range(NUM_REPETITIONS):\n path_to_log = path_to_log_template.format(env=ENV, learning_rate=learning_rate, method=experiment_name, repetition=repetition)\n log = open(path_to_log).read()\n timesteps = list(map(float, re.findall(TIMESTEP_PATTERN, log)))\n rewards = list(map(float, re.findall(REWARD_PATTERN, log)))\n assert len(timesteps) == len(rewards)\n xs.append(np.array(timesteps))\n ys.append(np.array(rewards))\n\n average_x, average_y, std_y, lower_y, upper_y = interpolate_and_average(xs, ys, confidence_interval=True)\n # Uniformly spaced plotting points so can just take mean over ys\n auc = average_y.mean()\n if best_auc is None or auc > best_auc:\n best_x = average_x\n best_y = average_y\n best_y_upper = upper_y\n best_y_lower = lower_y\n best_std = std_y\n best_auc = auc\n best_description = \"{}. lr: {}\".format(experiment_name, learning_rate)\n print(\"Best result for {}: {}\".format(legend_name, best_description))\n pyplot.plot(best_x, best_y, label=legend_name, c=color)\n pyplot.fill_between(\n best_x,\n best_y_lower,\n best_y_upper,\n alpha=0.2,\n color=color,\n linewidth=0.0\n )\n pyplot.tick_params(axis='both', which='both', labelsize=\"x-large\")\n pyplot.grid(alpha=0.2)\n pyplot.xlabel(\"Environment steps\", fontsize=\"x-large\")\n pyplot.ylabel(\"Average return\", fontsize=\"x-large\")\n pyplot.legend(prop={\"size\": \"large\"})\n pyplot.tight_layout()\n pyplot.savefig(\"figures/trust_region_results.pdf\", bbox_inches=\"tight\", pad_inches=0.0)","def plot_envs_overall():\n AUC = []\n R_iter = []\n for i in range(len(envs)):\n env = envs[i]\n print(env)\n bestmodels, R_cum, aucurve = plot_rwds(envs_labels, cdict=color_dict,\n fdir=fdir + envs[i] + '-v1/',\n model_paths=model_paths, BEST=BEST, MAX_LEN=MAX_LEN(envs[i]),\n STEP=STEP, MAX_TRIALS=MAX_TRIALS,\n title=envs[i] + ' $R_{iter}$ ', step=max_lims[envs[i]][1],\n shape_dict=shape_dict,\n kfold=max_lims[envs[i]][1] * MAX_TRIALS)\n print('done print')\n R_iter.append(bestmodels)\n R = np.asarray(aucurve, dtype=float)\n AUC.extend(zip(np.mean(R, axis=1), np.std(R, axis=1) / np.sqrt(R.shape[1])))\n print('done. Computing AUC')\n for j in [1, 2]:\n for m in range(len(envs_labels) - 1):\n print_ttest(envs_labels, R, m, j)\n print('\\n')\n\n # Swimmer\n # t-test ( FM RPSP-VRPG )= [ -0.676586869332 , 0.507653821772 ]\n # t-test ( GRU RPSP-VRPG )= [ -11.4782215848 , 9.9484555701e-07 ]\n # t-test ( RPSP-Alt RPSP-VRPG )= [ -3.10454361915 , 0.00933872173406 ]\n # t-test ( FM RPSP-Alt )= [ 1.73508240067 , 0.111134237192 ]\n # t-test ( GRU RPSP-Alt )= [ -20.2985459977 , 2.4045809148e-09 ]\n # Hopper\n # t-test ( FM RPSP-VRPG )= [ -1.97496384693 , 0.0638921448438 ]\n # t-test ( GRU RPSP-VRPG )= [ -2.98367426585 , 0.0121047687853 ]\n # t-test ( RPSP-Alt RPSP-VRPG )= [ 2.25405603636 , 0.0382107798284 ]\n # t-test ( FM RPSP-Alt )= [ -3.92498523554 , 0.00123896806466 ]\n # t-test ( GRU RPSP-Alt )= [ -4.909161505 , 0.000577310309778 ]\n # Walker2d\n # t-test ( FM RPSP-VRPG )= [ -0.0793340586349 , 0.937667000948 ]\n # t-test ( GRU RPSP-VRPG )= [ -2.9657440937 , 0.00870691843556 ]\n # t-test ( RPSP-Alt RPSP-VRPG )= [ 2.23688724131 , 0.0412540309747 ]\n # t-test ( FM RPSP-Alt )= [ -2.05494189388 , 0.0601025184967 ]\n # t-test ( GRU RPSP-Alt )= [ -6.51606587482 , 5.3677973935e-06 ]\n # CartPole\n # t-test ( FM RPSP-VRPG )= [ -4.49013758712 , 0.00103201257316 ]\n # t-test ( GRU RPSP-VRPG )= [ 1.23597901022 , 0.232353991956 ]\n # t-test ( RPSP-Alt RPSP-VRPG )= [ -0.358340067592 , 0.726097854222 ]\n # t-test ( FM RPSP-Alt )= [ -8.06880999537 , 6.44596048562e-07 ]\n # t-test ( GRU RPSP-Alt )= [ 1.95090137725 , 0.0740240842398 ]\n # print (np.round(np.asarray(AUC)[[0, 1, 2, 3, 5, 9], :] / 1000.0, decimals=1))\n # print (reg_labels, filter_labels)\n return R_iter, AUC","def plot_results(epochs: int = 20, segments: int = 5, plot: bool = True):\n \"\"\"\n plt.figure(0)\n plot_approximation(\"product\", modelSetProd, 1, epochs, gpus=0)\n \"\"\"\n\n data = [\n {\n \"title\": \"Piecewise Discontinuous Function Approximation\",\n \"layer\": \"discontinuous\",\n \"model_set\": modelSetD,\n },\n {\n \"title\": \"Piecewise Continuous Function Approximation\",\n \"layer\": \"continuous\",\n \"model_set\": modelSetC,\n },\n {\n \"title\": \"Polynomial function approximation\",\n \"layer\": \"polynomial\",\n \"model_set\": modelSetP,\n },\n {\n \"title\": \"Fourier function approximation\",\n \"layer\": \"fourier\",\n \"model_set\": modelSetF,\n },\n ]\n\n for index, element in enumerate(data):\n if plot is True:\n plt.figure(index)\n plot_approximation(\n element[\"layer\"],\n element[\"model_set\"],\n 5,\n epochs,\n accelerator=\"cpu\",\n periodicity=2,\n )\n\n if plot is True:\n plt.title(\"Piecewise Discontinuous Function Approximation\")\n\n if plot is True:\n plt.show()","def plot_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2014/output',\n\t\t\t\tsteps=['step01','step02'],\n\t\t\t\t#labels='',\n\t\t\t\tshow=True,\n\t\t\t\txscale=1e3,\n\t\t\t\tyscale=1e-2):\n\tplt.figure()\n\t#path = '/Users/scott/Desktop/elastic'\n\n\t# Deep source\n\t#labels = ['no APMB', 'APMB']\n\t#if labels == '':\n\tlabels = steps\n\tdeep = {}\n\t#uzmax = 0.824873455364\n\t# NOT sure why hardcoded...\n\tuzmax = 1\n\tfor i,outdir in enumerate(steps):\n\t\tpointsFile = os.path.join(path, outdir, 'points.h5')\n\t\tprint(pointsFile)\n\t\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n\n\t\tX = x / xscale\n\t\tY1 = ux / yscale\n\n\t\tx_fem = X #/ xscale #double scaling!\n\t\tur_fem = Y1 #/ yscale\n\t\tuz_fem = uz / yscale\n\n\t\t#print(pointsFile)\n\t\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\n\n\t\t#normalize\n\t\tuz_fem = uz_fem / uzmax\n\t\tur_fem = ur_fem / uzmax\n\t\tx_fem = x_fem / 30.0\n\n\t\tl, = plt.plot(x_fem,uz_fem,'o-',ms=4,lw=4,label=labels[i])\n\t\tplt.plot(x_fem,ur_fem,'o--',ms=4,lw=4,color=l.get_color()) #mfc='none' transparent\n\t\tdeep[outdir] = uz_fem/uz_fem\n\n\t'''\n\t# Shallow Source\n\tshallow = {}\n\tuzmax = 0.949652827795\n\tfor i,outdir in enumerate(['step11','step12']):\n\t\tpointsFile = os.path.join(path, outdir, 'points.h5')\n\n\t\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n\n\t\tX = x / xscale\n\t\tY1 = ux / yscale\n\n\t\tx_fem = X #/ xscale #double scaling!\n\t\tur_fem = Y1 #/ yscale\n\t\tuz_fem = uz / yscale\n\n\t\t#print(pointsFile)\n\t\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\n\n\t#normalize\n\tuz_fem = uz_fem / uzmax\n\tur_fem = ur_fem / uzmax\n\tx_fem = x_fem / 20.0\n\n\t\tl, = plt.plot(x_fem,uz_fem,'.-', mfc='w', lw=4,label=labels[i])\n\t\tplt.plot(x_fem,ur_fem,'.--',lw=4, mfc='w',color=l.get_color()) #mfc='none' transparent\n\n\t\tshallow[outdir] = uz_fem/ur_fem\n\t'''\n\n\t# Annotate\n\tplt.axhline(color='k',lw=0.5)\n\t#plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n\t#plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n\tplt.legend()\n\tplt.grid()\n\t#plt.ylim(-0.5, 3.5)\n\t#plt.savefig('deep.png',bbox_inches='tight')\n\t#plt.savefig('shallow.png',bbox_inches='tight')\n\n\t# normalized\n\tplt.ylim(-0.5, 4)\n\tplt.xlim(0,10)\n\tplt.xlabel('Normalized Radial Distance [R / D]')\n\tplt.ylabel('Normalized Displacement [U / Uz_max]')\n\t#plt.savefig('normalized_deep.png',bbox_inches='tight')\n\tplt.savefig('normalized_shallow.png',bbox_inches='tight')\n\n\n\t# Plot ratios of uz versus NOTE: this plot is confusing,,, just keep ratio of uz_max to ur_max\n\t'''\n\tplt.figure()\n\tplt.plot(x_fem, deep['step01'], label='Deep no APMB')\n\tplt.plot(x_fem, deep['step02'], label='Deep w/ APMB')\n\tplt.plot(x_fem, shallow['step11'], label='Shallow no APMB')\n\tplt.plot(x_fem, shallow['step12'], label='Shallow w/ APMB')\n\tplt.xlabel('Distance [km]') #NOTE: maybe plot normailzed X-axis (R-d)\n\t#plt.xlabel('Normalized Distance [R/d]')\n\tplt.ylabel('Ratio [Uz/Ur]')\n\tplt.title('Ratio of vertical to radial displacement')\n\tplt.legend()\n\tplt.show()\n\t'''","def plot_spatial_res(data_obj, test_num):\n\n #---------------------------------------------------------------------------------------------#\n # Go through each file [image] and plot the spatial resolution ROI images and MTF data graphs #\n #---------------------------------------------------------------------------------------------#\n for i in range(len(data_obj.files)):\n\n fig = new_pdf_page(data_obj.pdf_obj) #Create a new pdf page\n plt.axis('off')\n\n # Create and plot the (centered) title of the page - that also states the MTF20 values\n str1 = 'Test ' + str(test_num) + ': Spatial Resolution \\n' + \\\n 'MTF20x = ' + \"{0:.2f}\".format(data_obj.MTF_data.MTF20_x) + \\\n '\\n MTF20y = ' + \"{0:.2f}\".format(data_obj.MTF_data.MTF20_y)\n plt.suptitle(str1)\n\n #-----------------------------------------------#\n # Plot the main image in the middle of the page #\n #-----------------------------------------------#\n ax1 = fig.add_subplot(312)\n plt.imshow(data_obj.img_data[i].lead_foil_ROI.img) #Display the ROI image of the lead foil\n\n # Display the title of the ROI image - the orientation\n plt.title('Orientation ' + str(data_obj.img_data[i].orientation))\n plt.xticks([]) # labels\n plt.yticks([])\n ax = plt.gca()\n ax.xaxis.set_ticks_position('none') # tick markers\n ax.yaxis.set_ticks_position('none')\n\n if data_obj.img_data[i].orientation % 2 == 1:\n plt.xlabel('x axis')\n plt.ylabel('y axis')\n else:\n plt.xlabel('y axis')\n plt.ylabel('x axis')\n\n #-----------------------------#\n # Display the Horizontal plot #\n #-----------------------------#\n ax2 = fig.add_subplot(325)\n plt.ylabel('MTFx')\n plt.xlabel('Spatial frequency (cycles/mm)')\n plt.plot(data_obj.img_data[i].MTF_obj.MTF_x_f, data_obj.img_data[i].MTF_obj.MTF_x)\n text = 'MTF20x = ' + \"{0:.2f}\".format(data_obj.img_data[i].MTF_obj.MTF20_x)\n\n ax2.annotate(text,\n xy=(data_obj.img_data[i].MTF_obj.MTF20_x, 0.2),\n xytext=(np.max(data_obj.img_data[i].MTF_obj.MTF_x_f), 0.7),\n arrowprops=dict(facecolor='black', shrink=0.05, width=0.5, headwidth=4),\n horizontalalignment='right')\n\n #---------------#\n # Vertical plot #\n #---------------#\n ax3 = fig.add_subplot(326)\n plt.ylabel('MTFy')\n plt.xlabel('Spatial frequency (cycles/mm)')\n plt.plot(data_obj.img_data[i].MTF_obj.MTF_y_f, data_obj.img_data[i].MTF_obj.MTF_y)\n text = 'MTF20y = ' + \"{0:.2f}\".format(data_obj.img_data[i].MTF_obj.MTF20_y)\n\n ax3.annotate(text,\n xy=(data_obj.img_data[i].MTF_obj.MTF20_y, 0.2),\n xytext=(np.max(data_obj.img_data[i].MTF_obj.MTF_y_f), 0.7),\n arrowprops=dict(facecolor='black', shrink=0.05, width=0.5, headwidth=4),\n horizontalalignment='right')","def coeff_display_file(filename,zernike_max_order=20):\n hdu = pf.open(filename)\n nn = len(hdu)\n data = []\n colnames = ['x','y','M20','M22','M31','M33']\n for hdui in hdu[1:]:\n Nobj = hdui.data.shape[0]\n M20=np.zeros(Nobj)\n M22=np.zeros(Nobj).astype(complex)\n M31=np.zeros(Nobj).astype(complex)\n M33=np.zeros(Nobj).astype(complex)\n #sigma = 1.1/0.27\n sigma = 1.08/scale\n for i in range(Nobj):\n M20[i],M22[i],M31[i],M33[i]=complexMoments(data=hdui.data[i][4:].reshape(npix,npix),sigma=sigma)\n x=hdui.header['ccdXcen']\n y=hdui.header['ccdYcen']\n data.append([x,y,np.median(M20), np.median(M22), np.median(M31), np.median(M33)])\n data=np.array(data)\n betaAll=[]\n betaErrAll=[]\n R2adjAll=[]\n beta,betaErr,R2_adj = zernikeFit(data[:,0].real,data[:,1].real,data[:,2].real,max_order=zernike_max_order)\n betaAll.append(beta)\n betaErrAll.append(betaErr)\n R2adjAll.append(R2_adj)\n for i in range(3,6):\n beta,betaErr,R2_adj = zernikeFit(data[:,0].real,data[:,1].real,data[:,i].real,max_order=zernike_max_order)\n betaAll.append(beta)\n betaErrAll.append(betaErr)\n R2adjAll.append(R2_adj)\n beta,betaErr,R2_adj = zernikeFit(data[:,0].real,data[:,1].real,data[:,i].imag,max_order=zernike_max_order)\n betaAll.append(beta)\n betaErrAll.append(betaErr)\n R2adjAll.append(R2_adj)\n betaAll = np.array(betaAll)\n betaErrAll = np.array(betaErrAll)\n R2adjAll = np.array(R2adjAll)\n ind = np.arange(len(betaAll[0]))\n momname = ('M20','M22.Real','M22.imag','M31.real','M31.imag','M33.real','M33.imag')\n fmtarr = ['bo-','ro-','go-','co-','mo-','yo-','ko-']\n pl.figure(figsize=(17,13))\n for i in range(7):\n pl.subplot(7,1,i+1)\n pl.errorbar(ind,betaAll[i],yerr = betaErrAll[i],fmt=fmtarr[i])\n if i == 0:\n pl.title('x: '+str(hdu[0].header['x'])+' y: '+str(hdu[0].header['y'])+' z: '+str(hdu[0].header['z'])+' tilt: '+str(hdu[0].header['theta'])+' fwhm: '+str(hdu[0].header['s_fwhm'])+' e1: '+str(hdu[0].header['e1'])+' e2: '+str(hdu[0].header['e2']))\n pl.grid()\n pl.xlim(-1,21)\n if i ==0:\n pl.ylim(-50,100)\n elif i ==1:\n pl.ylim(-10,10)\n elif i ==2:\n pl.ylim(-10,10)\n elif i == 3:\n pl.ylim(-0.01,0.01)\n elif i == 4:\n pl.ylim(-0.01,0.01)\n elif i ==5:\n pl.ylim(-20,20)\n elif i == 6:\n pl.ylim(-20,20)\n pl.xticks(ind,('','','','','','','','','','','','','','','','','','','',''))\n pl.ylabel(momname[i])\n pl.xticks(ind,('1','2','3','4','5','6','7','8','9','10','11','12','13','14','15','16','17','18','19','20'))\n pl.xlabel('Zernike Coefficients')\n return betaAll,betaErrAll","def plot_SS(H,E,C,nframes,nres,outdir,name_mod):\n\tH_av = np.zeros(nres) ; H_err = np.zeros(nres) \n\tE_av = np.zeros(nres) ; E_err = np.zeros(nres) \n\tC_av = np.zeros(nres) ; C_err = np.zeros(nres) \n\tfor ind in range(nres):\n\t\tH_av[ind] = sum(H[ind,:])/nframes ; H_err[ind] = np.std(H[ind,:])\n\t\tE_av[ind] = sum(E[ind,:])/nframes ; E_err[ind] = np.std(E[ind,:])\n\t\tC_av[ind] = sum(C[ind,:])/nframes ; C_err[ind] = np.std(C[ind,:])\n\n\tplt.clf()\n\tplt.plot(H_av,label='Helix',c='r') ; plt.errorbar(range(nres), H_av,yerr=H_err/(np.sqrt(nframes)-1), fmt='o',color='r')\n\tplt.plot(E_av,label='Beta Sheet',c='b') ; plt.errorbar(range(nres), E_av,yerr=E_err/(np.sqrt(nframes)-1), fmt='o',color='b')\n\tplt.plot(C_av,label='Coil',c='k') ; plt.errorbar(range(nres), C_av,yerr=C_err/(np.sqrt(nframes)-1), fmt='o',color='k')\n\tplt.legend(loc=1)\n\tplt.savefig(outdir+\"SS\" + name_mod + \".png\")\n\tnp.savetxt(outdir+\"SS_H_av\" + name_mod + \".npy\",[H_av,H_err])\n\tnp.savetxt(outdir+\"SS_E_av\" + name_mod + \".npy\",[E_av,E_err])\n\tnp.savetxt(outdir+\"SS_C_av\" + name_mod + \".npy\",[C_av,C_err])\n\treturn None","def plotAllResiduals():\n #Joint fits\n files = g.glob('results/J*.fits')\n individuals = [file for file in files if 'datafit' in file]\n for file in individuals:\n id = file.replace('results/', '').replace('datafit.fits', '')\n print 'processing:', id\n _plotModelResiduals(id=id, folder='results/', out='results/%sResidual.pdf' % id)\n\n #Individual fits\n files = g.glob('results/I*.fits')\n individuals = [file for file in files if 'model' in file]\n for file in individuals:\n id = file.replace('results/', '').replace('model.fits', '')\n print 'processing:', id\n _plotModelResiduals(id=id, folder='results/', out='results/%sResidual.pdf' % id, individual=True)","def plot_data(data, param_choice, args):\n \n ### set general plot properties\n \n savebase = '/usr/users/iff_th2/duman/Cells_in_LAMMPS/POVRAY/'\n #downlim = -1\n #uplim = sim.lx/4.\n num_ticks = 5\n ax_len = 1.0 # Length of one subplot square box\n ax_b = 0.0 # Beginning/offset of the subplot in the box\n ax_sep = 0.0 # Separation length between two subplots\n total_subplots_in_x = 1 # Total number of subplots \n fig = plt.figure()\n subp = misc_tools.Subplots(fig, ax_len, ax_sep, ax_b, total_subplots_in_x) \n ax0 = subp.addSubplot()\n \n name = ''\n pname = ''\n if param_choice == 'areak': \n name = 'AREAK'\n pname = name + '_eps_' + str(args.eps) + '_fp_' + str(args.fp) + \\\n '_kappa_' + str(args.kappa)\n xlab = '$\\kappa_A$'\n tit = '$\\epsilon=$' + str(args.eps) + ',$f_m=$' + str(args.fp) + \\\n ',$\\kappa=$' + str(args.kappa)\n elif param_choice == 'eps':\n name = 'EPS'\n pname = name + '_fp_' + str(args.fp) + '_areak_' + str(args.areak) + \\\n '_kappa_' + str(args.kappa)\n xlab = '$\\epsilon$'\n tit = '$f_m=$' + str(args.fp) + ',$\\kappa_A=$' + str(args.areak) + \\\n ',$\\kappa=$' + str(args.kappa) \n elif param_choice == 'fp':\n name = 'FP'\n pname = name + '_eps_' + str(args.eps) + '_areak_' + str(args.areak) + \\\n '_kappa_' + str(args.kappa)\n xlab = '$f_{m}$'\n tit = '$\\epsilon=$' + str(args.eps) + ',$\\kappa_A=$' + str(args.areak) + \\\n ',$\\kappa=$' + str(args.kappa) \n elif param_choice == 'kappa':\n name = 'KAPPA'\n pname = name + '_eps_' + str(args.eps) + '_fp_' + str(args.fp) + \\\n '_areak_' + str(args.areak)\n xlab = '$\\kappa$'\n tit = '$\\epsilon=$' + str(args.eps) + ',$f_m=$' + str(args.fp) + \\\n ',$\\kappa_A=$' + str(args.areak) \n base = savebase + name + '/'\n os.system(\"mkdir -p \" + base) \n \n ### plot \n\n subp = misc_tools.Subplots(fig, ax_len, ax_sep, ax_b, total_subplots_in_x) \n ax0 = subp.addSubplot()\n \n x = data.keys()\n y = [1 for j in range(len(data.keys()))]\n print x\n ax0.scatter(x, y)\n ax0.set_xscale('log')\n ax0.set_yscale('log')\n \n for j, p in enumerate(data.keys()):\n \n fname = data[p] \n \n if os.path.exists(fname):\n arr_hand = read_png(fname)\n \n zoom=0.099\n imagebox = OffsetImage(arr_hand, zoom=zoom)\n\n xy = [x[j], y[j]] # coordinates to position this image\n\n ab = AnnotationBbox(imagebox, xy,\n xybox=(0., -0.),\n xycoords='data',\n boxcoords=\"offset points\",frameon=1,pad=.1) \n \n ax0.add_artist(ab)\n \n ### title\n \n ax0.set_title(tit, fontsize=30)\n \n ### labels\n \n ax0.set_xlabel(xlab, fontsize=30)\n #ax0.set_ylabel(\"$F_{s}(q,\\\\Delta t)$\", fontsize=40)\n\n ### limits\n\n #ax0.set_xlim((-1, 15))\n ax0.set_ylim((0.9999, 1.0001))\n \n ax0.grid(1, color='#cccccc', linestyle='--')\n ax0.set_frame_on(False)\n ax0.get_xaxis().tick_bottom()\n ax0.axes.get_yaxis().set_visible(False)\n xmin, xmax = ax0.get_xaxis().get_view_interval()\n ymin, ymax = ax0.get_yaxis().get_view_interval()\n ax0.add_artist(Line2D((xmin, xmax), (ymin, ymin), color='black', linewidth=2)) \n ### ticks\n \n #ax0.xaxis.set_ticks(np.linspace(0, 15, num_ticks, endpoint=True))\n #ax0.yaxis.set_ticks(np.linspace(0, uplim, num_ticks, endpoint=True))\n plt.setp(ax0.get_yticklabels(),visible=False) \n ax0.tick_params(axis='both', which='major', labelsize=30)\n \n ### legend\n\n# ax0.legend(bbox_to_anchor=(1.005, 0.,0.65, 1.), loc=2, borderaxespad=0., \\\n# prop={'size': 20}, mode=\"expand\", frameon=False)\n \n ### save \n \n savepath = base + \"images_per_\" + pname + \".pdf\"\n print savepath\n plt.savefig(savepath, dpi=300, bbox_inches='tight', pad_inches=0.08) \n fig.clf() \n \n return","def display4(*args):\n #-------------------- unpack\n twiss_func = args[0]\n cos_like = args[1]\n sin_like = args[2]\n lat_plot = args[3]\n #-------------------- beta x,y & dispersion x\n s = [twiss_func(i,'s') for i in range(twiss_func.nbpoints)] # Abszisse\n bx = [twiss_func(i,'bx') for i in range(twiss_func.nbpoints)] # beta x\n by = [twiss_func(i,'by') for i in range(twiss_func.nbpoints)] # beta y\n dx = [twiss_func(i,'dx') for i in range(twiss_func.nbpoints)] # dispersion x\n#-------------------- longitudinal trajectories\n z1= [cos_like(i,'s') for i in range(cos_like.nbpoints)]\n cz= [cos_like(i,'cz') for i in range(cos_like.nbpoints)]\n cdp= [cos_like(i,'cdp') for i in range(cos_like.nbpoints)]\n\n z2= [sin_like(i,'s') for i in range(sin_like.nbpoints)]\n sz= [sin_like(i,'sz') for i in range(sin_like.nbpoints)]\n sdp= [sin_like(i,'sdp') for i in range(sin_like.nbpoints)]\n #-------------------- lattice viseo\n vzero = [0. for i in range(lat_plot.nbpoints)] # zero line\n vis_abszisse = [lat_plot(i,'s') for i in range(lat_plot.nbpoints)]\n vis_ordinate = [lat_plot(i,'viseo') for i in range(lat_plot.nbpoints)]\n #-------------------- figure frame\n width=14; height=7.6\n # fighdr = 'lattice version = {}, input file = {}'.format(PARAMS['lattice_version'],PARAMS['input_file'])\n fig = plt.figure(num=1,figsize=(width,height),facecolor='#eaecef',tight_layout=False)\n\n #-------------------- beta functions\n splot211=plt.subplot(211)\n splot211.set_title('beta x,y')\n # mapping box\n splot211.text(0.01, 1.1, UTIL.FLAGS.get('mapping'),transform=splot211.transAxes,fontsize=8,bbox=dict(boxstyle='round',facecolor='wheat',alpha=0.5),verticalalignment='top')\n # function plots\n plt.plot(s,bx, label=r\"$\\beta$x [m]\", color='black', linestyle='-')\n plt.plot(s,by, label=r\"$\\beta$y [m]\", color='red', linestyle='-')\n plt.plot(s,dx, label=r'$\\eta_x$ [m]' , color='green', linestyle='-') # dispersion x\n vscale=splot211.axis()[3]*0.25\n viseoz = [x*vscale for x in vis_ordinate]\n plt.plot(vis_abszisse,viseoz,label='',color='black')\n plt.plot(vis_abszisse,vzero,color='green',linestyle='--')\n # zero line\n splot211.plot(vis_abszisse,vzero,color='green',linestyle='--')\n plt.legend(loc='lower right',fontsize='x-small')\n\n #-------------------- longitudinal tracks z, dP/P\n # ax_l = left abszisse\n ax_l=plt.subplot(212)\n # ax_l=plt.subplot(10,1,(7,9))\n ax_l.set_title('synchrotron oscillation')\n ax_l.set_ylabel(r\"z [mm]\")\n ax_l.tick_params(axis='y', colors='green')\n ax_l.yaxis.label.set_color('green')\n ax_l.plot(z1,cz,label='C',color='green')\n ax_l.plot(z2,sz,label='S',color='green',linestyle=':')\n plt.legend(loc='lower left',fontsize='x-small')\n # ax_r = right abszisse\n ax_r = ax_l.twinx()\n ax_r.set_ylabel(r'$\\Delta$p/p [%]')\n ax_r.tick_params(axis='y', colors='red')\n ax_r.yaxis.label.set_color('red')\n ax_r.plot(z2,cdp,label='C',color='red')\n ax_r.plot(z2,sdp,label='S',color='red',linestyle=':')\n ax_r.plot(vis_abszisse,vzero,color='red', linestyle='--')\n plt.legend(loc='lower right',fontsize='x-small')\n # lattice elements\n vscale=ax_l.axis()[3]*0.25\n viseoz = [x*vscale for x in vis_ordinate]\n ax_l.plot(vis_abszisse,viseoz,label='',color='black')\n ax_l.plot(vis_abszisse,vzero,color='green',linestyle='--')","def plot_visual_abstract():\n # Which generations to plot\n GENERATIONS = [100, 230, 350]\n\n # LunarLander CMA-ES\n experiment_path = glob(\"experiments/wann_LunarLander-v2_CMAES*\")\n assert len(experiment_path) == 1, \"There should be only one CMA-ES experiment with LunarLander-v2\"\n experiment_path = experiment_path[0]\n\n pivector_paths = glob(os.path.join(experiment_path, \"pivectors\", \"*\"))\n\n tsnes = []\n rewards = []\n for generation in GENERATIONS:\n # Find pivector files for specific generation, load them and store points\n generation_paths = [path for path in pivector_paths if \"gen_{}_\".format(generation) in path]\n\n population = [np.load(path) for path in generation_paths]\n population_tsnes = np.array([x[\"tsne\"] for x in population])\n population_rewards = np.array([x[\"average_episodic_reward\"] for x in population])\n tsnes.append(population_tsnes)\n rewards.append(population_rewards)\n\n figure, axs = pyplot.subplots(\n figsize=[2.5 * 3, 2.5],\n nrows=1,\n ncols=len(GENERATIONS),\n sharex=\"all\",\n sharey=\"all\"\n )\n\n min_reward = min(x.min() for x in rewards)\n max_reward = max(x.max() for x in rewards)\n scatter = None\n\n for idx in range(len(GENERATIONS)):\n population_tsne = tsnes[idx]\n population_rewards = rewards[idx]\n generation = GENERATIONS[idx]\n ax = axs[idx]\n\n scatter = ax.scatter(\n population_tsne[:, 0],\n population_tsne[:, 1],\n c=population_rewards,\n vmin=min_reward,\n vmax=max_reward,\n cmap=\"plasma\"\n )\n ax.set_title(\"Generation {}\".format(generation))\n ax.set_xticks([])\n ax.set_yticks([])\n ax.axis(\"off\")\n\n # Making room for colorbar\n # Stackoverflow #13784201\n figure.subplots_adjust(right=1.0)\n cbar = figure.colorbar(scatter)\n cbar.set_ticks([])\n cbar.ax.set_ylabel(\"Reward $\\\\rightarrow$\", rotation=90, fontsize=\"large\")\n\n figure.tight_layout()\n figure.savefig(\"figures/visual_abstract.pdf\", bbox_inches=\"tight\", pad_inches=0.05)","def simplexPlot(results):\n _, hole1Values, logProbs = getStatistics(results.items())\n import matplotlib.pyplot as plt\n plt.plot(hole1Values, logProbs)\n plt.show()","def plot_variables(self, val=None, roi=None) -> None:\n\n if val is None:\n val = self.history.MAP\n\n if roi is None:\n roi = np.array([0])\n elif np.isscalar:\n roi = np.array([roi])\n\n data = self.data\n\n dt = val.dt\n gain = val.gain\n states = val.states\n mu_flor = val.mu_flor\n mu_back = val.mu_back\n num_rois = val.num_rois\n num_load = val.num_load\n num_data = val.num_data\n num_states = val.num_states\n\n times = np.arange(num_data) * dt\n\n fig = plt.gcf()\n fig.clf()\n #fig.set_size_inches(12, 6)\n ax = np.empty((len(roi), 1), dtype=object)\n gs = gridspec.GridSpec(nrows=len(roi), ncols=1, figure=fig)\n ax[0, 0] = fig.add_subplot(gs[0, 0])\n for i in range(len(roi)-1):\n ax[i, 0] = fig.add_subplot(gs[i, 0], sharex=ax[0, 0])\n\n for i, r in enumerate(roi):\n\n brightness = mu_flor @ states_to_pops(states[r, :, :], num_states) + mu_back[r]\n\n ax[i, 0].set_title('roi {}: {} flors'.format(r, val.num_flor[r]))\n ax[i, 0].set_xlabel('time (s)')\n ax[i, 0].set_ylabel('brightness (ADU)')\n ax[i, 0].plot(times, data[r, :], color='g', label='data')\n ax[i, 0].plot(times, brightness * gain, color='b', label='sampled')\n ax[i, 0].legend()\n\n # plt.tight_layout()\n plt.pause(.1)\n\n return","def plot_uwrz_field(f=False,ax=False, oro='h500a7', vm=[-2,2],tinst=18,var='QVrz',ik=0,jk=0):\n\n tinst = int(tinst)\n \n # in case f is not passed, f and ax are created\n if not f:\n f,ax=plt.subplots()\n\n # Name the axes \n decorate_ax(ax,'',daytime(tinst),'')\n \n\n # specify full path of the data\n\n iensmean = 1\n \n if iensmean:\n srcpath = BASE3D + oro + '/' + sm +'/' + CIRCMEAN\n print srcpath\n else: # 1 single ensemble member first day\n srcpath = BASE3D + oro + '/' + sm +'/'\n seedname= filter(lambda x: x.startswith('circmean_seed'), os.listdir(srcpath))[0]\n srcpath +=seedname\n\n # Open the data in netcdf format and read it only \n ncfl = Dataset(srcpath,'r')\n \n # Load the fields of interest\n # COSMO fields dimensions are (time, z,rlat,rlon)\n #\n # Field dimensions in the following are (time,z,r)\n #\n # By specifing '::-1' the second timension is inverted\n urz = ncfl.variables['Urz'][tinst,::-1,:] # U component of wind\n wrz = ncfl.variables['Wrz'][tinst,::-1,:] # W component of wind\n\n speedrz = ncfl.variables['Speedrz'][tinst,::-1,:] # wind speed\n rhorz = ncfl.variables['RHOrz'][:,::-1,:] # density in rz coordinates\n TOTP = ncfl.variables['TOT_PRECr'][:,:]/2. # half-hourly output\n \n LCLr= ncfl.variables['LCL_MLr'][tinst,:]/1000. # LCL\n LFCr = ncfl.variables['LFC_MLr'][tinst,:]/1000. # LFC\n hPBLr = ncfl.variables['HPBLr'][tinst,:]/1000. \n \n CAPEr = ncfl.variables['CAPE_MLr'][tinst,:] # CAPE\n CINr = ncfl.variables['CIN_MLr'][tinst,:] # CIN\n \n TOTPsum = np.sum(TOTP[:tinst,:],axis=0)\n TOTPsum = TOTP[tinst,:]\n \n TPthres = 0.5\n rainyr=np.where(TOTPsum>TPthres)\n\n\n if var: #select a specific humidity var\n qvrz = ncfl.variables[var][:,::-1,:] # specficif humidity\n qcrz = ncfl.variables['QCrz'][:,::-1,:]\n else: # otherwise sum it all up:\n qxrzvars = filter(lambda x: x.startswith('Q'),ncfl.variables.keys())\n \n qvrz = np.zeros(ncfl.variables['QVrz'].shape)\n for var in qxrzvars:\n print var\n qvrz+=ncfl.variables[var][:,::-1,:]\n \n tref = 12 # 06:00\n ipltdiff= 0\n if ipltdiff:\n plotvar = rhorz[tinst,:]*qvrz[tinst,:]-rhorz[tref,:]*qvrz[tref,:]\n qcrz = rhorz[tinst,:]*qcrz[tinst,:]-rhorz[tref,:]*qcrz[tref,:]\n else:\n plotvar = rhorz[tinst,:]*qvrz[tinst,:]\n \n\n rhorz = rhorz[tinst,:]\n \n \n # Load the grid in r, z coordinate\n X = ncfl.variables['X'][:]\n \n \n # nasty and temporary workaround as Z is empty in single seed data - just\n # take it from the circmean field\n srcpath2 = BASE3D + oro + '/' + sm +'/' + CIRCMEAN\n ncfl2=Dataset(srcpath2)\n Z = ncfl2.variables['Z'][::-1,:]/1000. # highest index <-> ground\n ncfl2.close() \n \n # Add mountain contour\n r=X[0,:]\n ax.plot(r,Z[0,:],color='grey',linewidth=2)\n \n# ax.plot(r,hPBLr,'k-.',linewidth=1)\n# ax.plot(r,LCLr,'k-',linewidth=1) \n \n ax.fill_between(X[0,:],Z[0,:],0,color='lightgrey')\n \n #indicate rainy region\n \n ifillrainy = False\n if ifillrainy:\n ax.fill_between(X[0,rainyr][0],Z[0,rainyr][0],color='lightblue',alpha=0.8) \n ax.plot(X[0,rainyr][0],Z[0,rainyr][0],color='lightblue',linewidth=2)\n else:\n pass#ax.plot(X[0,rainyr][0],Z[0,rainyr][0],color='blue',linewidth=2,linestyle='dashed')\n \n # Velocity vectors with speed (length) smaller than speedthres are not \n # shown\n oroorig = oro\n if oro.endswith('bell') or oro.endswith('cos2'):\n \n oro = oro[:-5]\n print oro\n \n i,j=np.where(expnames==oro)\n\n if i==[]:\n print 'HH'\n \n oro = oro.split('_')[0]\n h,a = getha(oro)\n #h,a = hrange[i],arange[j]\n print h,a\n xrang = [0,40]\n yrang = [0,10.]\n delx = xrang[1]-xrang[0]\n dely = yrang[1]-yrang[0]\n \n speedthres = 0.1# m/s\n M = speedrz[:] < speedthres\n U = ma.masked_array(urz[:,:],mask=M)\n scalefac_w = 1. #delx/dely\n W = ma.masked_array(scalefac_w*wrz[:,:],mask=M) \n \n \n \n if 0: # REMOVE\n fact_agl = -dely/delx\n sin = np.arcsin(fact_agl)\n cos = np.arccos(fact_agl)\n U=cos*U-sin*W\n W=sin*U+cos*W\n # Plot radial velocity\n urzlevs = np.linspace(vm[0],vm[1],10)\n\n\n levs = np.array([2,4,6,8,10,12,14,16])\n #levs = np.array([0.25,0.5,1,2,4,8,16,32])\n #levs = np.array([0.5,1,2,4,8,16,32])\n if ipltdiff:\n levs=levs/8. #np.linspace(0.001,0.004,11)d\n #else:\n # levs=np.array([0.001,0.0015,0.002,0.0025,0.003,0.0035,0.004])*50\n #if var.startswith('QC'): levs=np.linspace(0.1,1.5,9)/1000.\n \n #cf = ax.contourf(X,Z,plotvar*1000., levels=levs*1000.,cmap=viridis_inv,extend='both')\n \n ipltmoistening = False \n if ipltmoistening:\n cf = ax.contourf(X,Z,plotvar*1000.,cmap=viridis_inv,extend='both',\n levels=levs)\n else:\n cf = 0\n \n #cfc = ax.contourf(X,Z,qvrz*1000.,cmap='Blues',extend='both', alpha=1,\n # levels=levs/4.) \n\n iplt_thermodynvar = False\n if iplt_thermodynvar:\n for var in [LFCr]:\n print var.shape\n print X.shape\n ax.plot(var)\n \n \n qstx = 2\n qstz = 2\n Q=ax.quiver(X[::qstz,::qstx],(Z+0.02)[::qstz,::qstx],U[::qstz,::qstx],W[::qstz,::qstx],\n units='inches',scale=10,angles='xy', color='red',pivot='mid',\n headwidth=4,width=0.009)\n #Q=ax.quiverkey(Q,a/2,h/2000.,1,r'$1\\frac{m}{s}$',labelpos='N',coordinates='data')\n\n if jk==2 or oroorig.endswith('cos2'):#(ik,jk)==(1,0):\n ax.quiverkey(Q,-2,0.05,1,r'$1 \\frac{m}{s}$',labelsep=0.05,\n labelpos='N',coordinates='data')\n\n\n ax.set_xticks(np.arange(0,80,20)) \n\n ax.set_xlim(xrang)\n ax.set_ylim(yrang)\n\n if ik==2:\n ax.set_xlabel('r in km')\n if jk==0:\n ax.set_ylabel('z in km') \n \n ax.grid(True)\n\n ncfl.close()\n \n return f,ax ,cf # plot_uwrz_field","def plot_results(models,\n data,\n batch_size=128,\n model_name=\"vae_mnist\"):\n\n encoder, decoder = models\n x_test, y_test = data\n os.makedirs(model_name, exist_ok=True)\n\n filename = os.path.join(model_name, \"vae_mean.png\")\n # display a 2D plot of the digit classes in the latent space\n z_mean, _, _ = encoder.predict(x_test,\n batch_size=batch_size)\n plt.figure(figsize=(12, 10))\n plt.scatter(z_mean[:, 0], z_mean[:, 1], c=y_test)\n plt.colorbar()\n plt.xlabel(\"z[0]\")\n plt.ylabel(\"z[1]\")\n plt.savefig(filename)\n plt.show()\n\n filename = os.path.join(model_name, \"digits_over_latent.png\")\n # display a 30x30 2D manifold of digits\n n = 30\n digit_size = 28\n figure = np.zeros((digit_size * n, digit_size * n))\n # linearly spaced coordinates corresponding to the 2D plot\n # of digit classes in the latent space\n grid_x = np.linspace(-4, 4, n)\n grid_y = np.linspace(-4, 4, n)[::-1]\n\n for i, yi in enumerate(grid_y):\n for j, xi in enumerate(grid_x):\n z_sample = np.array([[xi, yi]])\n x_decoded = decoder.predict(z_sample)\n digit = x_decoded[0].reshape(digit_size, digit_size)\n figure[i * digit_size: (i + 1) * digit_size,\n j * digit_size: (j + 1) * digit_size] = digit\n\n plt.figure(figsize=(10, 10))\n start_range = digit_size // 2\n end_range = n * digit_size + start_range + 1\n pixel_range = np.arange(start_range, end_range, digit_size)\n sample_range_x = np.round(grid_x, 1)\n sample_range_y = np.round(grid_y, 1)\n plt.xticks(pixel_range, sample_range_x)\n plt.yticks(pixel_range, sample_range_y)\n plt.xlabel(\"z[0]\")\n plt.ylabel(\"z[1]\")\n plt.imshow(figure, cmap='Greys_r')\n plt.savefig(filename)\n plt.show()","def plot_vis_test(plotfile,pdf_file):\n\t# First some parameters looked up from configfile---------------------------------\n\t\n\tgrbdir = runconf['l2file'][0:10]\n\tpre_tstart = runconf['bkg1start']\n\tpre_tend = runconf['bkg1end']\n\ttrigtime = runconf['trigtime']\n\tgrb_tstart = runconf['transtart']\n\tgrb_tend = runconf['tranend']\n\tpost_tstart = runconf['bkg2start']\n\tpost_tend = runconf['bkg2end']\n\tt_src = grb_tend - grb_tstart \n\tt_tot = (pre_tend-pre_tstart)+(post_tend-post_tstart)\n\tra_tran = runconf['ra']\n\tdec_tran = runconf['dec']\n\tlc_bin = runconf['lc_bin']\n\talpha = runconf['alpha']\n\tbeta = runconf['beta']\n\tE0 = runconf['E0']\n\tA = runconf['A']\n\tsim_scale = t_src\n\tpixbin = int(runconf['pixsize'])\n\tcomp_bin = int(runconf['comp_bin'])\n\ttyp = runconf['typ']\n\n\t# Calling txy to calculate thetax thetay and the coordinates----------------------\n\t\n\tthetax,thetay,x,y,z,t = txy(runconf['mkffile'], trigtime, ra_tran, dec_tran)\n\t\n\t# Plot the 3d visualisation for the position of the transient---------------------\n\tplt.figure()\n\tfig = visualize_3d(grbdir,x,y,z, t, thetax, thetay, grbdir)\t\n\tpdf_file.savefig(fig)\n\t\n\t# Plotting the lightcurves for the four quadrants---------------------------------\n\tfig = plt.figure()\n\tclean_file = fits.open(runconf['infile'])\n\tplt.title('Light curves for '+grbdir + \"\\n\" + r\"$\\theta_x$={tx:0.1f} and $\\theta_y$={ty:0.1f} \".format(tx=thetax,ty=thetay))\n\t\n\tquad0 = clean_file[1].data\n\tdata0,bin_edge = np.histogram(quad0['time'], bins=np.arange(quad0['time'][0],quad0['time'][-1],lc_bin))\n\tplt.plot((bin_edge[:-1]+bin_edge[1:])/2.0,data0,label='Quad 0',lw=0.7)\n quad1 = clean_file[2].data\n\tdata1,bin_edge = np.histogram(quad1['time'], bins=np.arange(quad1['time'][0],quad1['time'][-1],lc_bin))\n\tplt.plot((bin_edge[:-1]+bin_edge[1:])/2.0,data1,label='Quad 1',lw=0.7) \n\tquad2 = clean_file[3].data\n\tdata2,bin_edge = np.histogram(quad2['time'], bins=np.arange(quad2['time'][0],quad2['time'][-1],lc_bin))\n\tplt.plot((bin_edge[:-1]+bin_edge[1:])/2.0,data2,label='Quad 2',lw=0.7)\n quad3 = clean_file[4].data\n data3,bin_edge = np.histogram(quad3['time'], bins=np.arange(quad3['time'][0],quad3['time'][-1],lc_bin))\n plt.plot((bin_edge[:-1]+bin_edge[1:])/2.0,data3,label='Quad 3',lw=0.7)\n\tplt.axvspan(grb_tstart,grb_tend,color='blue',alpha=0.1,label='GRB')\n\tplt.axvspan(pre_tstart,pre_tend,color='orange',alpha=0.2)\n\tplt.axvspan(post_tstart,post_tend,color='orange',alpha=0.2,label='Background')\n\tplt.legend(prop={'size':6})\n\tplt.xlim(pre_tstart-100,post_tend+100)\n\tpdf_file.savefig(fig)\n\t\n\t# Calling the sim_dph--------------------------------------------------------------\n\t\n\tgrb_flat,bkgd_flat,grb_dph,bkgd_dph,t_src,t_total = data_bkgd_image(grbdir,pre_tstart,pre_tend,grb_tstart,grb_tend,post_tstart,post_tend)\n\n\tsim_flat,sim_dph,badpix_mask,sim_err_dph = simulated_dph(grbdir,typ,t_src,alpha,beta,E0,A)\n\n\tsrc_dph = grb_dph-bkgd_dph*t_src/t_tot\n\n print \"Total counts in simulated dph: \",(sim_dph).sum()\n print \"Total counts after badpix mask is applied: \",(sim_dph*badpix_mask).sum()\n\tprint \"Excess counts in badpix masked src dph: \",(src_dph*badpix_mask).sum()\n \n\t# Plotting the DPHs before badpix correction---------------------------------------\n\t\n\tf,((ax1,ax2),(ax3,ax4)) = plt.subplots(2,2)\n\tplt.suptitle('DPHs before badpix correction for '+grbdir + \"\\n\" + r\"$\\theta_x$={tx:0.1f} and $\\theta_y$={ty:0.1f} \".format(tx=thetax,ty=thetay))\n \t# Sim\n\tim = ax3.imshow(sim_dph,interpolation='none')\n\tax3.set_title('Sim DPH',fontsize=8)\n\tax3.set_xlim(-1,128 - 0.5)\n\tax3.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\n\tax3.spines['left'].set_position(('data',-0.5))\n\tax3.set_yticklabels([])\n\tax3.xaxis.set_ticks(np.arange(0,128,16))\n\tf.colorbar(im,ax=ax3,fraction=0.046, pad=0.04)\n\t\n\t # Source \n\tim = ax4.imshow(src_dph,interpolation='none',vmin=0)\n\tax4.set_title('Src DPH (bkg subtracted)',fontsize=8)\n\tax4.set_xlim(-1,128 -0.5)\n\tax4.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\n\tax4.spines['left'].set_position(('data',-0.5))\n\tax4.set_yticklabels([])\n\tax4.xaxis.set_ticks(np.arange(0,128,16))\n\tf.colorbar(im,ax=ax4,fraction=0.046, pad=0.04)\n\n \t# Source + Background\n\tim = ax1.imshow(grb_dph,interpolation='none')\n\tax1.set_title('Src + Bkg DPH',fontsize=8)\n\tax1.set_xlim(-1,128 -0.5)\n\tax1.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\n\tax1.spines['left'].set_position(('data',-0.5))\n\tax1.set_yticklabels([])\n\tax1.xaxis.set_ticks(np.arange(0,128,16))\n\tf.colorbar(im,ax=ax1,fraction=0.046, pad=0.04)\n\n \t# Background\n\tim = ax2.imshow(bkgd_dph*t_src/t_total,interpolation='none')\n\tax2.set_title('Bkg DPH',fontsize=8)\n\tax2.set_xlim(-1,128 -0.5)\n\tax2.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\n\tax2.spines['left'].set_position(('data',-0.5))\n\tax2.set_yticklabels([])\n\tax2.xaxis.set_ticks(np.arange(0,128,16))\n\tf.colorbar(im,ax=ax2,fraction=0.046, pad=0.04)\n\tf.set_size_inches([6.5,6.5])\n\tpdf_file.savefig(f) # saves the current figure into a pdf_file page\n\t\n\t# Plotting the Badpix mask---------------------------------------------\n\n\tfig = plt.figure()\n\tax = plt.subplot(111)\n\tplt.title('Badpix Mask for '+grbdir+ \"\\n\" + r\"$\\theta_x$={tx:0.1f} and $\\theta_y$={ty:0.1f} \".format(tx=thetax,ty=thetay))\n\tim = ax.imshow(badpix_mask,interpolation='none')\n\tax.set_xlim(-9,128 -0.5)\n\tax.axvline(x=-5.,ymin=0,ymax=64,linewidth=5,color='k')\n\tax.spines['left'].set_position(('data',-0.5))\n\tax.xaxis.set_ticks(np.arange(0,128,16))\n\tax.yaxis.set_ticks(np.arange(0,128,16))\n\tfig.colorbar(im,ax=ax,fraction=0.046, pad=0.04)\n\t\n\tpdf_file.savefig(fig) # saves the current figure into a pdf_file page\n\n\t# Plotting badpix masked graphs--------------------------------------------\n\tf,((ax1,ax2),(ax3,ax4)) = plt.subplots(2,2)\n\tplt.suptitle('DPHs after badpix correction for '+grbdir+ \"\\n\" + r\"$\\theta_x$={tx:0.1f} and $\\theta_y$={ty:0.1f} \".format(tx=thetax,ty=thetay))\n \t# Sim\n\tim = ax3.imshow(sim_dph*badpix_mask,interpolation='none')\n\tax3.set_title('Sim DPH',fontsize=8)\n\tax3.set_xlim(-1,128 -0.5)\n\tax3.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\n\tax3.spines['left'].set_position(('data',-0.5))\n\tax3.set_yticklabels([])\n\tax3.xaxis.set_ticks(np.arange(0,128,16))\n\tf.colorbar(im,ax=ax3,fraction=0.046, pad=0.04)\n\n\t # Source \n\tim = ax4.imshow(src_dph*badpix_mask,interpolation='none',vmin=0)\n\tax4.set_title('Src DPH (bkg subtracted)',fontsize=8)\n\tax4.set_xlim(-1,128 -0.5)\n\tax4.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\n\tax4.spines['left'].set_position(('data',-0.5))\n\tax4.set_yticklabels([])\n\tax4.xaxis.set_ticks(np.arange(0,128,16))\n\tf.colorbar(im,ax=ax4,fraction=0.046, pad=0.04)\n\n\t # Source + Background\n\tim = ax1.imshow(grb_dph*badpix_mask,interpolation='none')\n\tax1.set_title('Src + Bkg DPH',fontsize=8)\n\tax1.set_xlim(-1,128 -0.5)\n\tax1.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\n\tax1.spines['left'].set_position(('data',-0.5))\n\tax1.set_yticklabels([])\n\tax1.xaxis.set_ticks(np.arange(0,128,16))\n\tf.colorbar(im,ax=ax1,fraction=0.046, pad=0.04)\n\t\n\t # Background\n\tim = ax2.imshow(bkgd_dph*badpix_mask*t_src/t_total,interpolation='none')\n\tax2.set_title('Bkg DPH',fontsize=8)\n\tax2.set_xlim(-1,128 -0.5)\n\tax2.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\n\tax2.spines['left'].set_position(('data',-0.5))\n\tax2.set_yticklabels([])\n\tax2.xaxis.set_ticks(np.arange(0,128,16))\n\tf.colorbar(im,ax=ax2,fraction=0.046, pad=0.04)\n\tf.set_size_inches([6.5,6.5])\n\tpdf_file.savefig(f) # saves the current figure into a pdf_file page\n\n\t# Plotting badpix masked graphs (Binned) ----------------------------------------------------\n\tfor p in [4,8,16]:\n\t\tf,((ax1,ax2),(ax3,ax4)) = plt.subplots(2,2)\n\t\tplt.suptitle('DPHs after badpix correction for '+grbdir+ \"\\n\" + r\"$\\theta_x$={tx:0.1f} and $\\theta_y$={ty:0.1f} \".format(tx=thetax,ty=thetay)+ \"pixsize=\"+str(p))\n\t\t # Sim\n\t\tim = ax3.imshow(resample(sim_dph*badpix_mask,p),interpolation='none')\n\t\tax3.set_title('Sim DPH',fontsize=8)\n\t\tax3.set_xlim(-1,128/p -0.5)\n\t\tax3.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\n\t\tax3.spines['left'].set_position(('data',-0.5))\n\t\tax3.set_yticklabels([])\n\t\tax3.xaxis.set_ticks(np.arange(0,(128/p),16/p))\n\t\tax3.set_xticklabels(np.arange(0,128,16))\n\t\tf.colorbar(im,ax=ax3,fraction=0.046, pad=0.04)\n\t\t\n\t\t # Source \n\t\tim = ax4.imshow(resample(src_dph*badpix_mask,p),interpolation='none',vmin=0)\n\t\tax4.set_title('Src DPH (bkg subtracted)',fontsize=8)\n\t\tax4.set_xlim(-1,128/p -0.5)\n\t\tax4.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\n\t\tax4.spines['left'].set_position(('data',-0.5))\n\t\tax4.set_yticklabels([])\n ax4.xaxis.set_ticks(np.arange(0,(128/p),16/p))\n ax4.set_xticklabels(np.arange(0,128,16))\t\t\n\t\tf.colorbar(im,ax=ax4,fraction=0.046, pad=0.04)\n\t\t\n\t\t # Source + Background\n\t\tim = ax1.imshow(resample(grb_dph*badpix_mask,p),interpolation='none')\n\t\tax1.set_title('Src + Bkg DPH',fontsize=10)\n\t\tax1.set_xlim(-1,128/p -0.5)\n\t\tax1.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\n\t\tax1.spines['left'].set_position(('data',-0.5))\n\t\tax1.set_yticklabels([])\n ax1.xaxis.set_ticks(np.arange(0,(128/p),16/p))\n ax1.set_xticklabels(np.arange(0,128,16))\t\t\n\t\tf.colorbar(im,ax=ax1,fraction=0.046, pad=0.04)\n\t\t\n\t\t # Background\n\t\tim = ax2.imshow(resample(bkgd_dph*badpix_mask*t_src/t_total,p),interpolation='none')\n\t\tax2.set_title('Bkg DPH',fontsize=8)\n\t\tax2.set_xlim(-1,128/p -0.5)\n\t\tax2.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\n\t\tax2.spines['left'].set_position(('data',-0.5))\n\t\tax2.set_yticklabels([])\n ax2.xaxis.set_ticks(np.arange(0,(128/p),16/p))\n ax2.set_xticklabels(np.arange(0,128,16))\t\t\n\t\tf.colorbar(im,ax=ax2,fraction=0.046, pad=0.04)\n\t\tf.set_size_inches([6.5,6.5])\n\t\t\n\t\tpdf_file.savefig(f) # saves the current figure into a pdf_file page\n\n\n\t# Plotting the comparison graphs with equal bins ---------------------------------------\n\tprint \"No. of pixels with zero counts in sim_dph: \",sim_dph[sim_dph==0].size\n\tprint \"No. of pixels with zero counts in grb_dph(no bkg subtration): \",grb_dph[grb_dph==0].size\n\t\n\t# Generating the array for module number ------------------------------------------------\n\tA = ['A'+str(i) for i in range(16)]\n\tB = np.flip(['B'+str(i) for i in range(16)],0)\n\tC = np.flip(['C'+str(i) for i in range(16)],0)\n\tD = ['D'+str(i) for i in range(16)]\n\tquad_a = np.reshape(A,(4,4))\n\tquad_b = np.reshape(B,(4,4))\n\tquad_c = np.reshape(C,(4,4))\n\tquad_d = np.reshape(D,(4,4))\n\tMod_arr = np.ndarray((8,8),dtype='|S3')\n\tMod_arr[:4,:4] = quad_a\n\tMod_arr[:4,4:] = quad_b\n\tMod_arr[4:,4:] = quad_c\n\tMod_arr[4:,:4] = quad_d\n\tMod_names = Mod_arr.flatten()\n\t#print \"Module name array : \",Mod_names\n\t#-----------------------------------------------------------------------------------------\n\t\t\n\tsim_dph = sim_dph*badpix_mask\n\tsim_err_dph = sim_err_dph*badpix_mask\n grb_dph = grb_dph*badpix_mask\n bkgd_dph = bkgd_dph*badpix_mask\n\tgrb_err_dph = np.sqrt(grb_dph)*badpix_mask\n\tbkgd_err_dph = np.sqrt(bkgd_dph)*badpix_mask\n\n\tsim_bin = resample(sim_dph,pixbin)\n\tsim_err_bin = np.sqrt(resample(sim_err_dph**2,pixbin))\t\n\tgrb_bin = resample(grb_dph,pixbin)\n\tbkgd_bin = resample(bkgd_dph,pixbin)\n\tgrb_err_bin = np.sqrt(resample(grb_err_dph,pixbin))\t\n\tbkgd_err_bin = np.sqrt(resample(bkgd_err_dph,pixbin))\t\n\n\tsim_flat_bin = sim_bin.flatten()\n\tsim_err_flat_bin = sim_err_bin.flatten()\n\tgrb_flat_bin = grb_bin.flatten()\n\tbkgd_flat_bin = bkgd_bin.flatten()\n\tgrb_err_flat_bin = grb_err_bin.flatten()\n\tbkgd_err_flat_bin = bkgd_err_bin.flatten()\n\t\n\n\t # Defining model background and data\n\tmodel = sim_flat_bin\n\tmodel_copy = np.copy(model)\n\tbkgd = bkgd_flat_bin*t_src/t_tot\n\tsrc = grb_flat_bin\n\t\n\tdata = src - bkgd\n\tdata_copy = np.copy(data)\n\t\n\terr_src = grb_err_flat_bin\n\terr_bkgd = bkgd_err_flat_bin\n\terr_model = sim_err_flat_bin\n\terr_model_copy = np.copy(err_model)\n\terr_data = np.sqrt(((err_src)**2) + ((err_bkgd)**2)*(t_src/t_total)**2)\n\terr_data_copy = np.copy(err_data)\n\t\n\tratio = data/model\n\terr_ratio = ratio*np.sqrt(((err_data/data)**2) + ((err_model/model)**2))\n\t\n\tchi_sq = (((model-data)**2)/((err_model)**2 + (err_data)**2)).sum()\n\t\n\t # PLotting the comparison plots\n\tf,(ax1,ax2) = plt.subplots(2,gridspec_kw={'height_ratios':[2,1]},sharex='row')\n\t\n\tax1.set_title(\"Comparison between simulated and real data for \"+grbdir+ \"\\n\" + r\"$\\theta_x$={tx:0.1f} and $\\theta_y$={ty:0.1f} $\\chi^2$={c:0.1f}\".format(tx=thetax,ty=thetay,c=chi_sq))\n\tax1.errorbar(np.arange(0,(len(data))),data,yerr=err_data,fmt='.',markersize=2,label=\"Data\",elinewidth=0.5)\n\tax1.errorbar(np.arange(0,(len(model))),model,yerr=err_model,fmt='.',markersize=2,label=\"Simulation\",elinewidth=0.5)\n\tax1.legend()\n ax1.xaxis.set_ticks(np.arange(0,len(data)))\n\tax1.set_ylabel('Counts')\n\tax1.xaxis.grid(linewidth=0.5,alpha=0.3)\n ax1.set_xticklabels(Mod_names,rotation=90,fontsize=5)\n\n\tax2.errorbar(np.arange(0,(len(ratio))),ratio,yerr=err_ratio,fmt='.',markersize=2,label=\"Ratio = Data/Model\",elinewidth=0.5)\n\tax2.xaxis.set_ticks(np.arange(0,len(data)))\n ax2.set_xticklabels(Mod_names,rotation=90,fontsize=5)\n ax2.yaxis.set_ticks(np.arange(int(min(ratio-err_ratio)-1),int(max(ratio+err_ratio)+2),1))\n\tax2.tick_params(labelsize=5)\n\tax2.axhline(y=1,linewidth=0.5,color='k')\n\tax2.legend()\n\tax2.set_xlabel('CZT Modules')\n\tax2.set_ylabel('Ratio of counts')\n\tax2.xaxis.grid(linewidth=0.5,alpha=0.3)\n\tplt.tight_layout(h_pad=0.0)\n\tf.set_size_inches([6.5,10])\n\tpdf_file.savefig(f,orientation='portrait') # saves the current figure into a pdf_file page\n\n\t# Plotting comparison graphs with random binning------------------------------\n\t\n sim_flat = sim_dph.flatten()\n\tsim_err_flat = sim_err_dph.flatten()\n grb_flat = grb_dph.flatten()\n bkgd_flat = bkgd_dph.flatten()\n\tsrc_flat = src_dph.flatten()\n\t\n\torder = np.random.permutation(np.arange(0,len(sim_flat)))\n\t\n sim_flat = sim_flat[order]\n\tsim_err_flat = sim_err_flat[order]\n\tgrb_flat = grb_flat[order]\n\tbkgd_flat = bkgd_flat[order]\n\tsrc_flat = src_flat[order]\n\t\n\tprint \"No. of pixels with zero counts in sim_flat: \",sim_flat[sim_flat==0].size\n\tprint \"No. of pixels with zero counts in src_flat: \",src_flat[src_flat==0].size\n\t\n\tbins = np.array(np.sort(np.random.uniform(0,1,comp_bin)*len(sim_flat)),dtype=np.int64)\n\tx = np.zeros(len(bins)+2,dtype=np.int64)\n\tx[0] = 0\n\tx[-1] = len(sim_flat)\n\tx[1:-1] = bins\n\t\n\t#print \"The bin edges: \",x # ---------------------------------------------------------------\n\t\n\tsim_flat_bin = np.array([sim_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)])\n\tsim_err_flat_bin = np.sqrt(np.array([(sim_err_flat[x[i]:x[i+1]]**2).sum() for i in range(comp_bin+1)]))\n\tgrb_flat_bin = np.array([grb_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)])\n\tgrb_err_flat_bin = np.sqrt(np.array([grb_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)]))\n\tbkgd_flat_bin = np.array([bkgd_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)])\n\tbkgd_err_flat_bin = np.sqrt(np.array([bkgd_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)]))\n\tsrc_flat_bin = np.array([src_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)])\n\t\n\tprint \"Total sim_flat_bin : \",sim_flat_bin.sum() #-----------------------------------------\n\t#print \" Max(cumsum) : \",max(np.cumsum(sim_flat)) #-----------------------------------------\n\n # Defining model background and data\n model = sim_flat_bin #avg_flat_bin\n bkgd = bkgd_flat_bin*t_src/t_tot\n src = grb_flat_bin\n\t\n data = src - bkgd\n\n err_src = np.sqrt(src)\n err_bkgd = np.sqrt(bkgd_flat_bin)\n err_model = sim_err_flat_bin\n err_data = np.sqrt(((err_src)**2) + ((err_bkgd)**2)*(t_src/t_total)**2)\n\t\n\tchi_sq_new = (((model-data)**2)/((err_model)**2 + (err_data)**2)).sum()\n # PLotting the comparison plots\n fig = plt.figure()\n plt.title(\"Comparison between simulated and real data for \"+grbdir+ \"\\n\" + r\"$\\theta_x$={tx:0.1f} and $\\theta_y$={ty:0.1f} $\\chi^2$={c:0.1f} \".format(tx=thetax,ty=thetay,c=chi_sq_new))\n plt.errorbar(np.arange(0,(len(data))),data,yerr=err_data,fmt='.',markersize=2,label=\"Data\",elinewidth=0.5)\n plt.errorbar(np.arange(0,(len(model))),model,yerr=err_model,fmt='.',markersize=2,label=\"Simulation\",elinewidth=0.5)\n plt.ylabel('Counts')\n\tplt.xlabel('Random Bins')\n\tplt.xticks(np.arange(0,(len(data)),1))\n\tplt.legend()\n pdf_file.savefig(fig) #saves the current figure into a pdf_file page\n\n\t# Plotting observed vs predicted counts------------------------------------------------------\n\n\tfig = plt.figure()\n\tplt.title(grbdir + r\" : Observed vs Predicted counts with $\\chi^2$={cs:0.1f}\".format(cs=chi_sq))\n\tplt.errorbar(model_copy,data_copy,xerr=err_model_copy,yerr=err_data_copy,fmt='g.',markersize=2,elinewidth=0.5)\n\tfor i in range(len(model_copy)):\n\t\tplt.text(model_copy[i],data_copy[i],Mod_names[i],fontsize=5)\n\tplt.plot(np.arange(-1000,1000),np.arange(-1000,1000),'k',linewidth=0.5)\n\tplt.xlim(min(model_copy)-5,max(model_copy)+5)\n\tplt.ylim(min(data_copy)-5,max(data_copy)+5)\n\tplt.xlabel('Predicted Counts')\n\tplt.ylabel('Observed Counts')\n\tplt.legend()\n\tplt.grid()\n\tpdf_file.savefig(fig)\n\n\t# Scaling the model using curve fit =============================================================== \n\t\n\tparam,pcov = curve_fit(fit_line_int,model_copy,data_copy)\n\tscaling = param[0]\n\tintercept = param[1]\n\t\n\t# Plotting the scaled plots ===================================================================\n\t# Plotting the comparison graphs with equal bins ---------------------------------------\n\n\tsim_dph = sim_dph*badpix_mask\n\tsim_err_dph = sim_err_dph*badpix_mask\n grb_dph = grb_dph*badpix_mask\n bkgd_dph = bkgd_dph*badpix_mask\n\tgrb_err_dph = np.sqrt(grb_dph)*badpix_mask\n\tbkgd_err_dph = np.sqrt(bkgd_dph)*badpix_mask\n\n\tsim_bin = resample(sim_dph,pixbin)\n\tsim_err_bin = np.sqrt(resample(sim_err_dph**2,pixbin))\t\n\tgrb_bin = resample(grb_dph,pixbin)\n\tbkgd_bin = resample(bkgd_dph,pixbin)\n\tgrb_err_bin = np.sqrt(resample(grb_err_dph,pixbin))\t\n\tbkgd_err_bin = np.sqrt(resample(bkgd_err_dph,pixbin))\t\n\n\tsim_flat_bin = sim_bin.flatten()\n\tsim_err_flat_bin = sim_err_bin.flatten()\n\tgrb_flat_bin = grb_bin.flatten()\n\tbkgd_flat_bin = bkgd_bin.flatten()\n\tgrb_err_flat_bin = grb_err_bin.flatten()\n\tbkgd_err_flat_bin = bkgd_err_bin.flatten()\n\t\n\n\t # Defining model background and data\n\t#model = sim_flat_bin*scaling\n\tmodel = sim_flat_bin*scaling + intercept\n\tbkgd = bkgd_flat_bin*t_src/t_tot\n\tsrc = grb_flat_bin\n\t\n\tdata = src - bkgd\n\t\n\terr_src = grb_err_flat_bin\n\terr_bkgd = bkgd_err_flat_bin\n\t#err_model = sim_err_flat_bin*scaling\n\terr_model = sim_err_flat_bin*scaling\n\terr_data = np.sqrt(((err_src)**2) + ((err_bkgd)**2)*(t_src/t_total)**2)\n\t\n\tratio = data/model\n\terr_ratio = ratio*np.sqrt(((err_data/data)**2) + ((err_model/model)**2))\n\t\n\tchi_sq = (((model-data)**2)/((err_model)**2 + (err_data)**2)).sum()\n\t\n\t # PLotting the comparison plots\n\tf,(ax1,ax2) = plt.subplots(2,gridspec_kw={'height_ratios':[2,1]},sharex='row')\n\t\n\tax1.set_title(\"Comparison between simulated (scaled) and real data for \"+grbdir+ \"\\n\" + r\"$\\theta_x$={tx:0.1f} and $\\theta_y$={ty:0.1f} $\\chi^2$={c:0.1f} \".format(tx=thetax,ty=thetay,c=chi_sq))\n\tax1.errorbar(np.arange(0,(len(data))),data,yerr=err_data,fmt='.',markersize=2,label=\"Data\",elinewidth=0.5)\n\tax1.errorbar(np.arange(0,(len(model))),model,yerr=err_model,fmt='.',markersize=2,label=\"Simulation (scaling = {s:0.2f},offset = {o:0.2f})\".format(s=scaling,o=intercept),elinewidth=0.5)\n\tax1.legend()\n ax1.xaxis.set_ticks(np.arange(0,len(data)))\n\tax1.set_ylabel('Counts')\n\tax1.xaxis.grid(linewidth=0.5,alpha=0.3)\n ax1.set_xticklabels(Mod_names,rotation=90,fontsize=5)\n\t\n\tax2.errorbar(np.arange(0,(len(ratio))),ratio,yerr=err_ratio,fmt='.',markersize=2,label=\"Ratio = Data/Model(scaling = {s:0.2f}, offset={o:0.2f})\".format(s=scaling,o=intercept),elinewidth=0.5)\n\tax2.xaxis.set_ticks(np.arange(0,len(data)))\n ax2.set_xticklabels(Mod_names,rotation=90,fontsize=5)\n ax2.yaxis.set_ticks(np.arange(int(min(ratio-err_ratio)-1),int(max(ratio+err_ratio)+2),1))\n\tax2.tick_params(labelsize=5)\n\tax2.axhline(y=1,linewidth=0.5,color='k')\n\tax2.legend()\n\tax2.set_xlabel('CZT Modules')\n\tax2.set_ylabel('Ratio of counts')\n\tax2.xaxis.grid(linewidth=0.5,alpha=0.3)\n\tplt.tight_layout(h_pad=0.0)\n\tf.set_size_inches([6.5,10])\n\tpdf_file.savefig(f,orientation='portrait') # saves the current figure into a pdf_file page\n\n\t# Plotting comparison graphs with random binning------------------------------\n\t\n sim_flat = sim_dph.flatten()\n\tsim_err_flat = sim_err_dph.flatten()\n grb_flat = grb_dph.flatten()\n bkgd_flat = bkgd_dph.flatten()\n\tsrc_flat = src_dph.flatten()\n\t\n\torder = np.random.permutation(np.arange(0,len(sim_flat)))\n\t\n sim_flat = sim_flat[order]\n\tsim_err_flat = sim_err_flat[order]\n\tgrb_flat = grb_flat[order]\n\tbkgd_flat = bkgd_flat[order]\n\tsrc_flat = src_flat[order]\n\t\n\tbins = np.array(np.sort(np.random.uniform(0,1,comp_bin)*len(sim_flat)),dtype=np.int64)\n\tx = np.zeros(len(bins)+2,dtype=np.int64)\n\tx[0] = 0\n\tx[-1] = len(sim_flat)\n\tx[1:-1] = bins\n\t\n\tsim_flat_bin = np.array([sim_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)])\n\tsim_err_flat_bin = np.sqrt(np.array([(sim_err_flat[x[i]:x[i+1]]**2).sum() for i in range(comp_bin+1)]))\n\tgrb_flat_bin = np.array([grb_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)])\n\tgrb_err_flat_bin = np.sqrt(np.array([grb_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)]))\n\tbkgd_flat_bin = np.array([bkgd_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)])\n\tbkgd_err_flat_bin = np.sqrt(np.array([bkgd_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)]))\n\tsrc_flat_bin = np.array([src_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)])\n\t\n # Defining model background and data\n #model = sim_flat_bin*scaling\n\tmodel = sim_flat_bin*scaling + intercept\n bkgd = bkgd_flat_bin*t_src/t_tot\n src = grb_flat_bin\n\t\n data = src - bkgd\n\n err_src = np.sqrt(src)\n err_bkgd = np.sqrt(bkgd_flat_bin)\n #err_model = sim_err_flat_bin*scaling\n\terr_model = sim_err_flat_bin*scaling\n err_data = np.sqrt(((err_src)**2) + ((err_bkgd)**2)*(t_src/t_total)**2)\n\t\n\tchi_sq_new = (((model-data)**2)/((err_model)**2 + (err_data)**2)).sum()\n # PLotting the comparison plots\n fig = plt.figure()\n plt.title(\"Comparison between simulated(scaled) and real data for \"+grbdir+ \"\\n\" + r\"$\\theta_x$={tx:0.1f} and $\\theta_y$={ty:0.1f} $\\chi^2$={c:0.1f} \".format(tx=thetax,ty=thetay,c=chi_sq_new))\n plt.errorbar(np.arange(0,(len(data))),data,yerr=err_data,fmt='.',markersize=2,label=\"Data\",elinewidth=0.5)\n plt.errorbar(np.arange(0,(len(model))),model,yerr=err_model,fmt='.',markersize=2,label=\"Simulation (scaling = {s:0.2f}, offset = {o:0.2f})\".format(s=scaling,o=intercept),elinewidth=0.5)\n plt.ylabel('Counts')\n\tplt.xlabel('Random Bins')\n\tplt.xticks(np.arange(0,(len(data)),1))\n\tplt.legend()\n pdf_file.savefig(fig) #saves the current figure into a pdf_file page\n\n\n\t# Plotting observed vs predicted counts--------------------------------------------------------\n\n\tfig = plt.figure()\n plt.title(grbdir + r\" : Observed vs Predicted counts with $\\chi^2$ = {cs:0.1f}\".format(cs=chi_sq))\n plt.errorbar(model_copy,data_copy,xerr=err_model_copy,yerr=err_data_copy,fmt='g.',markersize=2,elinewidth=0.5)\n\tfor i in range(len(model_copy)):\t\n\t\tplt.text(model_copy[i],data_copy[i],Mod_names[i],fontsize=5)\n #plt.plot(np.arange(-1000,1000),fit_line(np.arange(-1000,1000),scaling),'k',linewidth=0.5,label='m = {s:0.2f}'.format(s=scaling))\n\tplt.plot(np.arange(-1000,1000),fit_line_int(np.arange(-1000,1000),scaling,intercept),'k',linewidth=0.5,label='scaling = {s:0.2f}, offset = {i:0.2f}'.format(s=scaling,i=intercept))\n\tplt.plot(np.arange(min(model_copy)-5,max(model_copy)+5),np.ones(len(np.arange(min(model_copy)-5,max(model_copy)+5)))*intercept,'r-',label='intercept',linewidth=0.5)\n plt.xlim(min(model_copy)-5,max(model_copy)+5)\n plt.ylim(min(data_copy)-5,max(data_copy)+5)\n plt.xlabel('Predicted Counts')\n plt.ylabel('Observed Counts')\n\tplt.legend()\n\tplt.grid()\n pdf_file.savefig(fig)\n\t\t\n\tprint \"===============================================================================================\"\n\t\n\treturn","def data_model_residual(surface, dem, unw, incidence):\n los,fem_los,residual = pu.los2pylith(surface,dem,unw,incidence)\n\n # Using image_grid\n fig = plt.figure()\n grid = ImageGrid(fig, 111, # similar to subplot(111)\n nrows_ncols = (1, 3),\n direction=\"row\",\n axes_pad = 0.05,\n add_all=True,\n label_mode = \"1\",\n share_all = True,\n cbar_location=\"top\",\n cbar_mode=\"each\", #\"single\"\n cbar_size=\"5%\",\n cbar_pad=0.05,\n )\n #grid[0].set_xlabel(\"X\")\n #grid[0].set_ylabel(\"Y\")\n #grid2[0].set_xticks([-2, 0])\n #grid2[0].set_yticks([-2, 0, 2])\n\n #NOTE: could find global min/max from three arrays here\n norm = Normalize(vmin=np.nanmin(los), vmax=np.nanmax(los))\n #for ax,data in zip(grid,[los,fem_los,residual]):\n im = grid[0].imshow(los,origin='upper',norm=norm,cmap=plt.cm.jet)\n grid[0].axhline(100,color='m') #show profile\n cax = grid.cbar_axes[0]\n cax.colorbar(im)\n grid[1].axhline(100,color='k') #show profile\n im1 = grid[1].imshow(fem_los,origin='upper',norm=norm,cmap=plt.cm.jet)\n\n cax = grid.cbar_axes[1]\n cax.colorbar(im1)\n\n im2 = grid[2].imshow(residual,origin='upper',cmap=plt.cm.jet)\n cax = grid.cbar_axes[2]\n cax.colorbar(im2)\n\n # Add letter labels\n for ax, label in zip(grid,['A', 'B', 'C']):\n ax.text(0.05, 0.95, label, transform=ax.transAxes,\n fontsize=16, fontweight='bold', va='top')\n\n # Annotate\n # NOTE: way too high!\n #plt.suptitle('FEM Results')\n\n # Add profile\n # NOTE: for now EW, but would be easy to do arbitrary line, and convert to km\n fig = plt.figure()\n #x = arange(los.shape[0])\n plt.axhline(color='k',ls='--')\n plt.plot(los[100],'m.',label='data')\n plt.plot(fem_los[100],'k-',lw=2,label='model')\n plt.xlabel('Distance [km]')\n plt.ylabel('Distance [km]')\n plt.legend(loc='upper left')\n\n plt.show()","def _plot_comparison(xs, pan, other_program_name, **kw):\n\n pans = ['Bmax', 'Emax']\n units = ['(mG)', '(kV/m)']\n title_app = [', Max Magnetic Field', ', Max Electric Field']\n save_suf = ['-%s-comparison-Bmax' % other_program_name,\n '-%s-comparison-Emax' % other_program_name]\n\n for p,u,t,s in zip(pans, units, title_app, save_suf):\n #figure object and axes\n fig = plt.figure()\n ax_abs = fig.add_subplot(2,1,1)\n ax_per = ax_abs.twinx()\n ax_mag = fig.add_subplot(2,1,2)\n #Bmax\n #init handles and labels lists for legend\n kw['H'], kw['L'] = [], []\n _plot_comparison_repeatables(ax_abs, ax_per, ax_mag, pan, p, u,\n other_program_name, **kw)\n _plot_wires(ax_mag, xs.hot, xs.gnd, pan['emf.fields-results'][p], **kw)\n _check_und_conds([xs], [ax_mag], **kw)\n ax_abs.set_title('Absolute and Percent Difference' + t)\n ax_mag.set_ylabel(p + ' ' + u)\n ax_mag.set_title('Model Results' + t)\n ax_mag.legend(kw['H'], kw['L'], **_leg_kw)\n _color_twin_axes(ax_abs, mpl.rcParams['axes.labelcolor'], ax_per, 'firebrick')\n _format_line_axes_legends(ax_abs, ax_per, ax_mag)\n #_format_twin_axes(ax_abs, ax_per)\n _save_fig(xs.sheet + s, fig, **kw)","def analyse_plots(plot_dict, data_dict) :\n for component in [ '_x', '_y' ] :\n z_pos = array.array( 'd' )\n trans_pos = array.array( 'd' )\n errors = array.array( 'd' )\n zeros = array.array( 'd' )\n\n plot = plot_dict['beam_positions'+component]\n\n for i in range( plot.GetXaxis().GetNbins()+2 ) :\n projection = plot.ProjectionY( \\\n 'profile'+component+'_pro_'+str(i), i, i )\n if projection.GetEntries() == 0 :\n continue\n\n pro_mean, pro_mean_err, pro_std, pro_std_err = \\\n scifi.fit_gaussian( projection )\n\n errors.append( pro_mean_err )\n trans_pos.append( pro_mean )\n z_pos.append( data_dict['station_positions'][ i-6 ] )\n zeros.append(0.0)\n\n position_graph = ROOT.TGraphErrors( len(zeros), z_pos, trans_pos, \\\n zeros, errors )\n position_graph.SetName('beam_profile'+component)\n plot_dict['beam_profile'+component] = position_graph\n\n profile_x = plot_dict['beam_profile_x']\n profile_y = plot_dict['beam_profile_y']\n\n up_x_func = ROOT.TF1( \"up_fit_x\", \"pol1\", -5000.0, 0.0 )\n up_y_func = ROOT.TF1( \"up_fit_y\", \"pol1\", -5000.0, 0.0 )\n down_x_func = ROOT.TF1( \"down_fit_x\", \"pol1\", 0.0, 5000.0 )\n down_y_func = ROOT.TF1( \"down_fit_y\", \"pol1\", 0.0, 5000.0 )\n\n up_fit_x = profile_x.Fit( 'up_fit_x', \"QSR\" )\n up_fit_y = profile_y.Fit( 'up_fit_y', \"QSR\" )\n down_fit_x = profile_x.Fit( 'down_fit_x', \"QSR\" )\n down_fit_y = profile_y.Fit( 'down_fit_y', \"QSR\" )\n\n plot_dict['beam_profile_x_up_fit'] = up_x_func\n plot_dict['beam_profile_y_up_fit'] = up_y_func\n plot_dict['beam_profile_x_down_fit'] = down_x_func\n plot_dict['beam_profile_y_down_fit'] = down_y_func\n\n\n up_beam_gra_x = up_x_func.GetParameter(1)\n up_beam_gra_x_err = up_x_func.GetParError(1)\n up_beam_gra_y = up_y_func.GetParameter(1)\n up_beam_gra_y_err = up_y_func.GetParError(1)\n\n up_beam_pos_x = data_dict['station_positions'][-1]*up_beam_gra_x + up_x_func.GetParameter(0)\n up_beam_pos_x_err = up_x_func.GetParError(0)\n up_beam_pos_y = data_dict['station_positions'][-1]*up_beam_gra_y + up_y_func.GetParameter(0)\n up_beam_pos_y_err = up_y_func.GetParError(0)\n\n up_beam_rot_x = math.atan( up_beam_gra_x )\n up_beam_rot_x_err = up_beam_gra_x_err # Approx linear\n up_beam_rot_y = math.atan( up_beam_gra_y )\n up_beam_rot_y_err = up_beam_gra_y_err # Approx linear\n\n\n\n down_beam_gra_x = down_x_func.GetParameter(1)\n down_beam_gra_x_err = down_x_func.GetParError(1)\n down_beam_gra_y = down_y_func.GetParameter(1)\n down_beam_gra_y_err = down_y_func.GetParError(1)\n\n down_beam_pos_x = data_dict['station_positions'][1]*down_beam_gra_x + down_x_func.GetParameter(0)\n down_beam_pos_x_err = down_x_func.GetParError(0)\n down_beam_pos_y = data_dict['station_positions'][1]*down_beam_gra_y + down_y_func.GetParameter(0)\n down_beam_pos_y_err = down_y_func.GetParError(0)\n\n down_beam_rot_x = math.atan( down_beam_gra_x )\n down_beam_rot_x_err = down_beam_gra_x_err # Approx linear\n down_beam_rot_y = math.atan( down_beam_gra_y )\n down_beam_rot_y_err = down_beam_gra_y_err # Approx linear\n\n\n# down_pos_x = down_beam_pos_x - data_dict['station_positions'][1]*up_beam_gra_x + up_x_func.GetParameter(0)\n# down_pos_x_err = math.sqrt( up_x_func.GetParError(0)**2 + down_beam_pos_x_err**2 )\n# down_pos_y = down_beam_pos_y - data_dict['station_positions'][1]*up_beam_gra_y + up_y_func.GetParameter(0)\n# down_pos_y_err = math.sqrt( up_y_func.GetParError(0)**2 + down_beam_pos_y_err**2 )\n\n length = TRACKER_SEPARATION\n down_pos_x = down_beam_pos_x - ( up_beam_pos_x + length*up_beam_gra_x )\n down_pos_x_err = math.sqrt( up_beam_pos_x_err**2 + down_beam_pos_x_err**2 + (length*up_beam_gra_x_err)**2 )\n down_pos_y = down_beam_pos_y - ( up_beam_pos_y + length*up_beam_gra_y )\n down_pos_y_err = math.sqrt( up_beam_pos_y_err**2 + down_beam_pos_y_err**2 + (length*up_beam_gra_y_err)**2 )\n\n down_rot_x = down_beam_rot_x - up_beam_rot_x\n down_rot_x_err = math.sqrt( down_beam_rot_x_err**2 + up_beam_rot_x_err**2 )\n down_rot_y = down_beam_rot_y - up_beam_rot_y\n down_rot_y_err = math.sqrt( down_beam_rot_y_err**2 + up_beam_rot_y_err**2 )\n\n\n print\n print \"Incoming Beam Misalignments:\"\n print\n print \"Displacement and rotation of beam with respect to upstream tracker:\"\n print\n print \"X Position = {0:0.3f} +/- {1:0.3f} mm\".format( up_beam_pos_x, up_beam_pos_x_err )\n print \"Y Position = {0:0.3f} +/- {1:0.3f} mm\".format( up_beam_pos_y, up_beam_pos_y_err )\n print\n print \"X Rotation = {0:0.3f} +/- {1:0.3f} mrad\".format( up_beam_rot_x*1000.0, up_beam_rot_x_err*1000.0 )\n print \"Y Rotation = {0:0.3f} +/- {1:0.3f} mrad\".format( up_beam_rot_y*1000.0, up_beam_rot_y_err*1000.0 )\n print\n\n print\n print \"Downstream Tracker Beam Misalignments:\"\n print\n print \"Displacement and rotation of beam with respect to downstream tracker:\"\n print\n print \"X Position = {0:0.3f} +/- {1:0.3f} mm\".format( down_beam_pos_x, down_beam_pos_x_err )\n print \"Y Position = {0:0.3f} +/- {1:0.3f} mm\".format( down_beam_pos_y, down_beam_pos_y_err )\n print\n print \"X Rotation = {0:0.3f} +/- {1:0.3f} mrad\".format( down_beam_rot_x*1000.0, down_beam_rot_x_err*1000.0 )\n print \"Y Rotation = {0:0.3f} +/- {1:0.3f} mrad\".format( down_beam_rot_y*1000.0, down_beam_rot_y_err*1000.0 )\n print\n\n print\n print \"Downstream Tracker Alignment:\"\n print\n print \"Displacement and rotation of between the two trackers:\"\n print\n print \"X Position = {0:0.3f} +/- {1:0.3f} mm\".format( down_pos_x, down_pos_x_err )\n print \"Y Position = {0:0.3f} +/- {1:0.3f} mm\".format( down_pos_y, down_pos_y_err )\n print\n print \"X Rotation = {0:0.3f} +/- {1:0.3f} mrad\".format( down_rot_x*1000.0, down_rot_x_err*1000.0 )\n print \"Y Rotation = {0:0.3f} +/- {1:0.3f} mrad\".format( down_rot_y*1000.0, down_rot_y_err*1000.0 )\n print","def plotEvaluation(results,nbr_file : int,path : str, labels = [\"\"],target_name = \"\"):\n fig,ax = plt.subplots(1,1)\n ax.set_yscale(\"log\")\n for res in range(len(results)):\n data = [np.array(p[1]) for p in results[res]]\n number_of_simulation = len(data)\n\n average_values = np.zeros(len(data[0]))\n for d in data:\n average_values =average_values + d\n average_values = np.array(average_values) / number_of_simulation\n \n error_values = [0 for i in range(len(average_values))]\n for j in range(len(error_values)):\n if j%int(len(error_values)/50)==0 :\n for i in range(len(data)):\n error_values[j] += (data[i][j] - average_values[j])**2\n error_values[j] = np.sqrt(error_values[j]/number_of_simulation)\n opt = 0\n tfile = ''\n if path == 'data/B/b':\n opt = B_opts[nbr_file-1]\n tfile = 'b'\n else:\n opt = C_opts[nbr_file-1]\n tfile = 'c'\n \n \n ax.errorbar(range(len(average_values)),average_values,yerr = error_values, ecolor = \"black\", linewidth = 1, elinewidth = 1, label = labels[res])\n \n \n #ax.ylim((opt-5,max(opt*2,average_values[-1]+10)))\n plt.title(f'{target_name} : The evolution of the best evaluation (in average) \\nfor graph {tfile}{nbr_file}.stp for {number_of_simulation} simulations')\n plt.xlabel(\"steps\")\n plt.ylabel(\"evaluation\")\n ax.legend()\n ax.axhline(opt, color='red', label = \"Optimal solution\")\n plt.savefig(f'best_{tfile}{nbr_file}_evaluation_{target_name}.png')\n plt.show()","def param_evol(sample_results, showpars=None, start=0, **plot_kwargs):\n import matplotlib.pyplot as pl\n\n chain = sample_results['chain'][:, start:, :]\n lnprob = sample_results['lnprobability'][:, start:]\n nwalk = chain.shape[0]\n try:\n parnames = np.array(sample_results['theta_labels'])\n except(KeyError):\n parnames = np.array(sample_results['model'].theta_labels())\n\n # Restrict to desired parameters\n if showpars is not None:\n ind_show = np.array([p in showpars for p in parnames], dtype=bool)\n parnames = parnames[ind_show]\n chain = chain[:, :, ind_show]\n\n # Set up plot windows\n ndim = len(parnames) + 1\n nx = int(np.floor(np.sqrt(ndim)))\n ny = int(np.ceil(ndim * 1.0 / nx))\n sz = np.array([nx, ny])\n factor = 3.0 # size of one side of one panel\n lbdim = 0.2 * factor # size of left/bottom margin\n trdim = 0.2 * factor # size of top/right margin\n whspace = 0.05 * factor # w/hspace size\n plotdim = factor * sz + factor * (sz - 1) * whspace\n dim = lbdim + plotdim + trdim\n\n fig, axes = pl.subplots(nx, ny, figsize=(dim[1], dim[0]))\n lb = lbdim / dim\n tr = (lbdim + plotdim) / dim\n fig.subplots_adjust(left=lb[1], bottom=lb[0], right=tr[1], top=tr[0],\n wspace=whspace, hspace=whspace)\n\n # Sequentially plot the chains in each parameter\n for i in range(ndim - 1):\n ax = axes.flatten()[i]\n for j in range(nwalk):\n ax.plot(chain[j, :, i], **plot_kwargs)\n ax.set_title(parnames[i])\n # Plot lnprob\n ax = axes.flatten()[-1]\n for j in range(nwalk):\n ax.plot(lnprob[j, :])\n ax.set_title('lnP')\n return fig","def display1(*args):\n #----------*----------* # unpack\n twiss_func = args[0]\n lat_plot = args[3]\n #-------------------- beta x,y & dispersion x\n s = [twiss_func(i,'s') for i in range(twiss_func.nbpoints)]\n bx = [twiss_func(i,'bx') for i in range(twiss_func.nbpoints)]\n by = [twiss_func(i,'by') for i in range(twiss_func.nbpoints)]\n dx = [twiss_func(i,'dx') for i in range(twiss_func.nbpoints)]\n #-------------------- lattice viseo\n vzero = [0. for i in range(lat_plot.nbpoints)] # zero line\n vis_abszisse = [lat_plot(i,'s') for i in range(lat_plot.nbpoints)]\n vis_ordinate = [lat_plot(i,'viseo') for i in range(lat_plot.nbpoints)]\n #-------------------- figure frame\n width=14; height=7.6\n plt.figure(num=0,figsize=(width,height),facecolor='#eaecef',tight_layout=False)\n\n #-------------------- transverse X\n splot111=plt.subplot(111)\n splot111.set_title('beta functions')\n plt.plot(s,bx, label=r'$\\beta_x$ [m]', color='red', linestyle='-') # beta x\n plt.plot(s,by, label=r'$\\beta_y$ [m]', color='blue', linestyle='-') # beta y\n plt.plot(s,dx, label=r'$\\eta_x$ [m]' , color='green',linestyle='-') # dispersion x\n vscale=splot111.axis()[3]*0.25\n viseoz = [x*vscale for x in vis_ordinate]\n plt.plot(vis_abszisse,viseoz,label='',color='black')\n plt.plot(vis_abszisse,vzero,color='black')\n plt.legend(loc='lower right',fontsize='x-small')","def ResBeam_Stats_plot(n, header_bmaj, header_bmin): \n\n file_dir = 'SpectralCube_BeamLogs'\n basename = '/beamlog.image.restored.' + imagebase + field\n\n # use different basename for the Milky Way range\n if not glob.glob(file_dir + basename +'*.txt'):\n basename = '/beamlog.image.restored.' + imagebase + 'MilkyWay.' + field\n\n \n BEAM_THRESHOLD = []\n \n title1 = 'Restoring beam bmaj standard deviation [arcsec]'\n plt_name1 = 'BmajStdev.png'\n saved_fig1 = fig_dir+'/'+plt_name1\n\n title2 = 'Restoring beam bmin standard deviation [arcsec]'\n plt_name2 = 'BminStdev.png'\n saved_fig2 = fig_dir+'/'+plt_name2\n\n title3 = 'Maximum ratio of beam area'\n plt_name3 = 'max_ratioBA.png'\n saved_fig3 = fig_dir+'/'+plt_name3\n\n title4 = 'Minimum ratio of beam area' \n plt_name4 = 'min_ratioBA.png'\n saved_fig4 = fig_dir+'/'+plt_name4\n \n params = {'axes.labelsize': 10,\n 'axes.titlesize': 10,\n 'font.size':10}\n\n pylab.rcParams.update(params)\n\n beamXPOS, beamYPOS = BeamPosition()\n fig1, ax1 = plt.subplots()\n fig2, ax2 = plt.subplots()\n fig3, ax3 = plt.subplots()\n fig4, ax4 = plt.subplots()\n \n for i in range(0,36):\n bnum = n[i]\n infile = file_dir + basename +'.beam%02d.txt'%(bnum)\n bmaj_stdev, bmin_stdev, beam_threshold, max_ratio_BA, min_ratio_BA = cal_ResBeam_Stats(infile, header_bmaj, header_bmin)\n BEAM_THRESHOLD.append(beam_threshold)\n\n ax1.scatter([beamXPOS[i]], [beamYPOS[i]], s=1400, edgecolors='black', facecolors='none')\n ax1.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\n ax1.text(beamXPOS[i], beamYPOS[i]-0.02, round(bmaj_stdev, 3), va='center', ha='center', fontsize=8, color='blue')\n\n ax2.scatter([beamXPOS[i]], [beamYPOS[i]], s=1400, edgecolors='black', facecolors='none')\n ax2.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\n ax2.text(beamXPOS[i], beamYPOS[i]-0.02, round(bmin_stdev,3), va='center', ha='center', fontsize=8, color='blue')\n\n maxplot = ax3.scatter([beamXPOS[i]], [beamYPOS[i]], s=1300, c=[max_ratio_BA], cmap='summer', edgecolors='black', vmin=0, vmax=1.1)\n ax3.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\n ax3.text(beamXPOS[i], beamYPOS[i]-0.02, round(max_ratio_BA,3), va='center', ha='center', fontsize=8, color='blue')\n \n minplot = ax4.scatter([beamXPOS[i]], [beamYPOS[i]], s=1300, c=[min_ratio_BA], cmap='summer', edgecolors='black', vmin=0, vmax=1.1)\n ax4.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\n ax4.text(beamXPOS[i], beamYPOS[i]-0.02, round(min_ratio_BA,3), va='center', ha='center', fontsize=8, color='blue')\n \n ax1.set_xlim(0,0.7)\n ax1.set_ylim(0,1.4)\n ax1.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\n ax1.set_title(title1)\n\n ax2.set_xlim(0,0.7)\n ax2.set_ylim(0,1.4)\n ax2.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\n ax2.set_title(title2)\n\n ax3.set_xlim(0,0.7)\n ax3.set_ylim(0,1.4)\n ax3.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\n ax3.set_title(title3)\n plt.colorbar(maxplot, ax=ax3)\n\n ax4.set_xlim(0,0.7)\n ax4.set_ylim(0,1.4)\n ax4.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\n ax4.set_title(title4)\n plt.colorbar(minplot, ax=ax4)\n\n fig1.savefig(saved_fig1, bbox_inches='tight')\n fig2.savefig(saved_fig2, bbox_inches='tight')\n fig3.savefig(saved_fig3, bbox_inches='tight')\n fig4.savefig(saved_fig4, bbox_inches='tight')\n\n plt.close('all')\n\n return saved_fig1, saved_fig2, plt_name1, plt_name2, saved_fig3, saved_fig4, plt_name3, plt_name4, BEAM_THRESHOLD","def plot_optimal_uncertainty_reduction(results_for_exp, results_for_exp_inftau):\n plt.ylim(0, 1)\n\n plot_param_per_l4_and_l2(\n sp.mean(sp.amax(results_for_exp, axis=2), axis=2),\n sp.std(sp.amax(results_for_exp, axis=2), axis=2))\n plot_param_per_l4_and_l2(sp.mean(results_for_exp_inftau, axis=2), c='g')","def main(result_dir, figure_dir, *, n_samples=1000):\n\n # define input and output directories\n result_path = Path(result_dir)\n figure_path = Path(figure_dir)\n figure_path.mkdir(parents=True, exist_ok=True)\n\n # load model parameters\n model_params = np.load(result_path / 'model_params_best.npz')\n\n # plot posterior distributions\n keys = [k for k in sorted(model_params) if k.startswith('FVGP/kern')]\n for key in keys:\n params = model_params[key]\n\n if not key.endswith('W'):\n continue\n\n loc, scale = params[0], np.exp(params[1])\n figname = key.replace('/', '_')\n\n # retrieve corresponding precision parameter\n gamma_key = key.replace('FVGP', 'PartialSVGP') + '/precision'\n gamma_loc = model_params[gamma_key][0, 0, :]\n gamma_scale = np.exp(model_params[gamma_key][1, 0, :])\n\n # sort by increasing (log)-precision\n idx = np.argsort(gamma_loc)\n gamma_loc, gamma_scale = gamma_loc[idx], gamma_scale[idx]\n loc, scale = loc[:, idx], scale[:, idx]\n\n # flip to make bigger deviation positive\n flip_mask = loc.mean(0) < 0\n loc[:, flip_mask] = -loc[:, flip_mask]\n\n # plot posterior distributions\n gamma_figname = key.replace('/', '_') + '_precision.png'\n fig = plot_gamma_posterior(gamma_loc, gamma_scale, n_samples)\n fig.savefig(str(figure_path / gamma_figname))\n\n fig = plot_W_posterior(loc, scale)\n\n fig.savefig(str(figure_path / figname))","def compare_parameter_plots(result_file, result_file_eccentric, fitted_params, resultType, planet,\n plotPublished = False, publishedDataFile = None, saveplot=True, foldext=''):\n\n # Check if we are wanting to compare the eccentric and circular resutls.\n\n inputData_circular = np.genfromtxt(result_file, dtype=None, delimiter=', ', comments='#', encoding = None)\n inputData_eccentric = np.genfromtxt(result_file_eccentric, dtype=None, delimiter=', ', comments='#', encoding = None)\n\n inputData = [inputData_circular, inputData_eccentric]\n\n # Find out the indices of the type of average and the error\n if 't0' in str(inputData[0][0]):\n values = [s for i, s in enumerate(inputData[0][0]) if 't0' in s]\n indices = [i for i, s in enumerate(inputData[0][0]) if 't0' in s]\n Nvalues = len(indices)\n Nbefore = indices[0]\n\n if resultType == 'Mean':\n k = values.index('t0_mu') + Nbefore\n e = values.index('t0_std') + Nbefore\n\n elif resultType == 'Median':\n k = values.index('t0_med') + Nbefore\n e = values.index('t0_poserr') + Nbefore\n\n elif resultType == 'LSQ':\n k = values.index('t0_lqs') + Nbefore\n e = values.index('t0_std') + Nbefore\n\n else:\n raise ValueError(\"Result type not recognised, please chose Mean, Median or LSQ.\")\n\n elif 't_secondary' in str(inputData[0]):\n values = [s for i, s in enumerate(inputData[0]) if 't_secondary' in s]\n indices = [i for i, s in enumerate(inputData[0]) if 't_secondary' in s]\n Nvalues = len(indices)\n Nbefore = indices[0]\n\n if resultType == 'Mean':\n k = values.index('t_secondary_mu') + Nbefore\n e = values.index('t_secondary_std') + Nbefore\n\n elif resultType == 'Median':\n k = values.index('t_secondary_med') + Nbefore\n e = values.index('t_secondary_poserr') + Nbefore\n\n elif resultType == 'LSQ':\n k = values.index('t_secondary_lqs') + Nbefore\n e = values.index('t_secondary_std') + Nbefore\n\n else:\n raise ValueError(\"Result type not recognised, please chose Mean, Median or LSQ.\")\n\n else:\n raise ValueError(\"Not implemented indices selection if we have not fit for t0\")\n\n # If we have some published values, create a table of the Nsigma difference\n if plotPublished:\n print \"\\nOpening file for writing nsigma from published...\"\n f = open(\"{3}/PhD/SpitzerTransits/{0}{1}/{0}_NsigmaFEccentricCircular.txt\".format(planet, foldext), 'w')\n print >> f, (\"Param\\tAOR\\tChannel\\tMethod\\tCirc_val\\tCirc_err\\tEcc_val\\tEcc_err\\tSigma\\tNsigdiff\")\n print >> f, (\"==============================================================================================\")\n\n for p in range(len(fitted_params)):\n\n # Figure out which parameter we are looking at\n param = fitted_params[p]\n\n # Initialise plotting the parameters\n fig = plt.figure(figsize=(8,5))\n ax1 = fig.add_axes([0.1, 0.1, 0.4, 0.8])\n ax2 = fig.add_axes([0.5, 0.1, 0.4, 0.8])\n ax1.set_title(r'Ch1 ($3.6\\mu m$)')\n ax2.set_title(r'Ch2 ($4.5\\mu m$)')\n ax1.set_ylabel(param)\n\n markers = ['o', '*']\n offset = [0,0.01]\n lab = [' cir',' ecc']\n\n # create lists to save the parameters to so that we can compare the circular and elliptical results\n ch1polyMean_list, ch1PLDMean_list, ch1polyStds_list, ch1PLDStds_list = [],[],[],[]\n ch2polyMean_list, ch2PLDMean_list, ch2polyStds_list, ch2PLDStds_list = [],[],[],[]\n\n for c in range(len(inputData)):\n\n # Get the AOR labels for poly and PLD and check that they are the same for channel 1\n ch1polyAORs = [line[0] for line in inputData[c] if 'ch1' in line and 'poly' in line]\n ch1PLDAORs = [line[0] for line in inputData[c] if 'ch1' in line and 'PLD' in line]\n\n if ch1polyAORs != ch1PLDAORs:\n warnings.warn(\"The PLD and poly AORs for channel 1 are not the same, plotted labels might be wrong!\")\n\n # Get the Mean and stddev of poly and PLD for the parameter that we are looking at for channel 1\n ch1polyMean = [float(line[k+p*Nvalues]) for line in inputData[c] if 'ch1' in line and 'poly' in line]\n ch1PLDMean = [float(line[k+p*Nvalues]) for line in inputData[c] if 'ch1' in line and 'PLD' in line]\n if resultType == 'Mean' or resultType == 'LSQ':\n ch1polyStds = np.array([float(line[e+p*Nvalues]) for line in inputData[c] if 'ch1' in line and 'poly' in line])\n ch1PLDStds = np.array([float(line[e+p*Nvalues]) for line in inputData[c] if 'ch1' in line and 'PLD' in line])\n elif resultType == 'Median':\n # asymetric errors\n ch1polyStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData[c] if 'ch1' in line and 'poly' in line]).T\n ch1PLDStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData[c] if 'ch1' in line and 'PLD' in line]).T\n\n ch1polyMean_list.append(ch1polyMean)\n ch1PLDMean_list.append(ch1PLDMean)\n ch1polyStds_list.append(ch1polyStds)\n ch1PLDStds_list.append(ch1PLDStds)\n\n\n # Get the AOR labels for poly and PLD and check that they are the same for channel 2\n ch2polyAORs = [line[0] for line in inputData[c] if 'ch2' in line and 'poly' in line]\n ch2PLDAORs = [line[0] for line in inputData[c] if 'ch2' in line and 'PLD' in line]\n\n if ch2polyAORs != ch2PLDAORs:\n warnings.warn(\"The PLD and poly AORs for channel 2 are not the same, plotted labels might be wrong!\")\n\n # Get the Mean and stddev of poly and PLD for the parameter that we are looking at for channel 2\n ch2polyMean = [float(line[k+p*Nvalues]) for line in inputData[c] if 'ch2' in line and 'poly' in line]\n ch2PLDMean = [float(line[k+p*Nvalues]) for line in inputData[c] if 'ch2' in line and 'PLD' in line]\n if resultType == 'Mean' or resultType == 'LSQ':\n ch2polyStds = np.array([float(line[e+p*Nvalues]) for line in inputData[c] if 'ch2' in line and 'poly' in line])\n ch2PLDStds = np.array([float(line[e+p*Nvalues]) for line in inputData[c] if 'ch2' in line and 'PLD' in line])\n elif resultType == 'Median':\n # asymmetric errors\n ch2polyStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData[c] if 'ch2' in line and 'poly' in line]).T\n ch2PLDStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData[c] if 'ch2' in line and 'PLD' in line]).T\n\n ch2polyMean_list.append(ch2polyMean)\n ch2PLDMean_list.append(ch2PLDMean)\n ch2polyStds_list.append(ch2polyStds)\n ch2PLDStds_list.append(ch2PLDStds)\n\n # Calculate the weighted means...\n WMch1poly, TSch1poly = weightedMean(np.array(ch1polyMean), np.array(ch1polyStds))\n WMch1PLD, TSch1PLD = weightedMean(np.array(ch1PLDMean), np.array(ch1PLDStds))\n WMch2poly, TSch2poly = weightedMean(np.array(ch2polyMean), np.array(ch2polyStds))\n WMch2PLD, TSch2PLD = weightedMean(np.array(ch2PLDMean), np.array(ch2PLDStds))\n\n # Channel 1\n # polynomial\n ax1.errorbar(np.array(range(len(ch1polyMean)))-0.05+offset[c], ch1polyMean, yerr = ch1polyStds, marker = markers[c], linestyle='', color ='b', label = 'Poly' + lab[c])\n # PLD\n ax1.errorbar(np.array(range(len(ch1PLDMean)))+0.05+offset[c], ch1PLDMean, yerr = ch1PLDStds, marker = markers[c], linestyle='', color = 'r', label = 'PLD' + lab[c])\n # labels\n ax1.set_xticks(range(len(ch1PLDMean)))\n ax1.set_xticklabels(ch1polyAORs, rotation='vertical')\n\n\n # Channel2\n # polynomial\n ax2.errorbar(np.array(range(len(ch2polyMean )))-0.05+offset[c], ch2polyMean, yerr = ch2polyStds, marker = markers[c], linestyle='', color ='b')\n # PLD\n ax2.errorbar(np.array(range(len(ch2PLDMean )))+0.05+offset[c], ch2PLDMean, yerr = ch2PLDStds, marker = markers[c], linestyle='', color = 'r')\n # labmarkers[c]\n ax2.set_xticks(range(len(ch2PLDMean)))\n ax2.set_xticklabels(ch2polyAORs, rotation='vertical')\n\n # Plot the weighted means\n if len(ch1polyMean) > 1.:\n ax1.axhline(WMch1poly, color = 'b')\n ax1.axhspan(WMch1poly - TSch1poly,\n WMch1poly + TSch1poly,\n alpha = 0.3, color='b',label='Weighted Mean')\n ax1.axhline(WMch1PLD, color = 'r')\n ax1.axhspan(WMch1PLD - TSch1PLD,\n WMch1PLD + TSch1PLD,\n alpha = 0.3, color='r',label='Weighted Mean')\n\n ax2.axhline(WMch2poly, color = 'b')\n ax2.axhspan(WMch2poly - TSch2poly,\n WMch2poly + TSch2poly,\n alpha = 0.3, color='b')\n ax2.axhline(WMch2PLD, color = 'r')\n ax2.axhspan(WMch2PLD - TSch2PLD,\n WMch2PLD + TSch2PLD,\n alpha = 0.3, color='r')\n\n\n if plotPublished:\n # Plot the published values if they they are given\n # and calculate Nsigma from published and save to a file\n data = np.genfromtxt(publishedDataFile, dtype=None, delimiter=', ', encoding = None)\n\n if param in data.T[0].tolist():\n\n pIdx = data.T[0].tolist().index(param)\n ax1.axhline(float(data[pIdx][1]), color = 'k', linestyle = 'dashed')\n ax1.axhspan(float(data[pIdx][1]) - float(data[pIdx][2]),\n float(data[pIdx][1]) + float(data[pIdx][2]),\n alpha = 0.3, color='k',label='Literature')\n\n ax2.axhline(float(data[pIdx][3]),color = 'k', linestyle = 'dashed')\n ax2.axhspan(float(data[pIdx][3]) - float(data[pIdx][4]),\n float(data[pIdx][3]) + float(data[pIdx][4]),\n alpha = 0.3, color='k',label='Literature')\n\n\n # Save the number of sigma to a file\n # This doesn't need to be in param loop because we want to do it for all the parameters\n # regardless if we have published values.\n # polynomial\n for i in range(len(ch1polyAORs)):\n print >> f, ('{0:}\\t{1:}\\t{2:}\\t{3:}\\t{4:.4f}\\t{5:.4f}\\t{6:.4f}\\t{7:.4f}\\t{8:.4f}\\t{9:.4f}'.format(\n param, ch1polyAORs[i], 'ch1', 'poly',\n float(ch1polyMean_list[0][i]), float(ch1polyStds_list[0].T[i].max()), #channel 1\n float(ch1polyMean_list[1][i]), float(ch1polyStds_list[1].T[i].max()), # choose the biggest error\n *nsigma(float(ch1polyMean_list[0][i]), float(ch1polyStds_list[0].T[i].max()),\n float(ch1polyMean_list[1][i]), float(ch1polyStds_list[0].T[i].max()))))\n\n for i in range(len(ch2polyAORs)):\n print >> f, ('{0:}\\t{1:}\\t{2:}\\t{3:}\\t{4:.4f}\\t{5:.4f}\\t{6:.4f}\\t{7:.4f}\\t{8:.4f}\\t{9:.4f}'.format(\n param, ch2polyAORs[i], 'ch2', 'poly',\n float(ch2polyMean_list[0][i]), float(ch2polyStds_list[0].T[i].max()), #channel 1\n float(ch2polyMean_list[1][i]), float(ch2polyStds_list[1].T[i].max()), # choose the biggest error\n *nsigma(float(ch2polyMean_list[0][i]), float(ch2polyStds_list[0].T[i].max()),\n float(ch2polyMean_list[1][i]), float(ch2polyStds_list[0].T[i].max()))))\n #PLD\n for i in range(len(ch1PLDAORs)):\n print >> f, ('{0:}\\t{1:}\\t{2:}\\t{3:}\\t{4:.4f}\\t{5:.4f}\\t{6:.4f}\\t{7:.4f}\\t{8:.4f}\\t{9:.4f}'.format(\n param, ch1PLDAORs[i], 'ch1', 'PLD',\n float(ch1PLDMean_list[0][i]), float(ch1PLDStds_list[0].T[i].max()), #channel 1\n float(ch1PLDMean_list[1][i]), float(ch1PLDStds_list[1].T[i].max()), # choose the biggest error\n *nsigma(float(ch1PLDMean_list[0][i]), float(ch1PLDStds_list[0].T[i].max()),\n float(ch1PLDMean_list[1][i]), float(ch1PLDStds_list[0].T[i].max()))))\n\n for i in range(len(ch2PLDAORs)):\n print >> f, ('{0:}\\t{1:}\\t{2:}\\t{3:}\\t{4:.4f}\\t{5:.4f}\\t{6:.4f}\\t{7:.4f}\\t{8:.4f}\\t{9:.4f}'.format(\n param, ch2PLDAORs[i], 'ch2', 'PLD',\n float(ch2PLDMean_list[0][i]), float(ch2PLDStds_list[0].T[i].max()), #channel 1\n float(ch2PLDMean_list[1][i]), float(ch2PLDStds_list[1].T[i].max()), # choose the biggest error\n *nsigma(float(ch2PLDMean_list[0][i]), float(ch2PLDStds_list[0].T[i].max()),\n float(ch2PLDMean_list[1][i]), float(ch2PLDStds_list[0].T[i].max()))))\n pass\n\n # Set the y limits of both plots to be the same sacle and to include both ch1 and ch2 points\n axis1ylim = ax1.get_ylim()\n axis2ylim = ax2.get_ylim()\n if ax1.get_ylim()[0] < ax2.get_ylim()[0]:\n ymin = ax1.get_ylim()[0]\n else:\n ymin = ax2.get_ylim()[0]\n if ax1.get_ylim()[1] < ax2.get_ylim()[1]:\n ymax = ax2.get_ylim()[1]\n else:\n ymax = ax1.get_ylim()[1]\n ax1.set_ylim(ymin,ymax)\n ax2.set_ylim(ax1.get_ylim())\n ax2.get_yaxis().set_visible(False)\n\n ax1.legend(loc = 'best')\n\n\n # Save if required\n if saveplot:\n plt.savefig(\"{3}/PhD/SpitzerTransits/{0}{1}/{0}_{2}_eccentricCircular.png\".format(planet,foldext,param, os.getenv('HOME')),bbox_inches='tight')\n #plt.close()\n if plotPublished:\n f.close()\n else:\n pass","def plot_results(outputs, x, e, t, a, folds, groups,\n quantiles, strat='quantile', adj='KM', plot=True):\n if plot:\n mpl.rcParams['hatch.linewidth'] = 2.0\n\n fig, big_axes = plt.subplots(\n figsize=(8 * (len(groups) + 2), 6 * len(quantiles)),\n nrows=len(quantiles),\n ncols=1)\n\n plt.subplots_adjust(hspace=0.4)\n\n i = 0\n for _, big_ax in enumerate(big_axes, start=1):\n big_ax.set_title(\n 'Receiver Operator Characteristic and Calibration at t=' +\n str(quantiles[i]) + '\\n',\n fontsize=16)\n big_ax.tick_params(\n labelcolor=(1., 1., 1., 0.0),\n top='off',\n bottom='off',\n left='off',\n right='off')\n i += 1\n \n eces = {}\n metrics = {}\n\n for quant in quantiles:\n eces[quant] = {}\n \n for i in range(len(quantiles)):\n\n scores = outputs[quantiles[i]]\n for j in range(len(groups) + 2):\n\n pt = (i * (len(groups) + 2) + j + 1)\n if plot:\n ax = fig.add_subplot(len(quantiles), len(groups) + 2, pt)\n else:\n ax = None\n \n if (j==1):\n eces[quantiles[i]]['all'] = plot_calibration_curve(ax,\n scores,\n e,\n t,\n a,\n folds,\n None,\n quantiles[i],\n strat=strat,\n adj=adj,\n plot=plot) \n \n if (j>1):\n eces[quantiles[i]][groups[j - 2]] = plot_calibration_curve(ax,\n scores,\n e,\n t,\n a,\n folds,\n groups[j - 2],\n quantiles[i],\n strat=strat,\n adj=adj,\n plot=plot)\n \n if (j==0):\n metrics[quantiles[i]] = plot_roc_curve(ax,\n scores,\n e,\n t,\n a,\n folds,\n groups,\n quantiles[i],\n plot=plot)\n\n for quant in quantiles:\n metrics[quant] = metrics[quant] + (eces[quant], )\n \n if plot: \n plt.show()\n return metrics","def results():\n\n # # 1. tau_e graph\n # # ------------------------------------------------------------\n\n tau_es = np.load(datapath / \"tau_es.npy\", allow_pickle=True)\n\n # I want to plot tau_e against b for various Ns. Annoyingly this\n # means I have to do some index juggling.\n\n # This is all because of the way I set up datagen.DataSet... oh well.\n\n for i, N in enumerate(Ns):\n\n # values to plot against b for the specific N\n vals = []\n\n for j, b in enumerate(bs):\n\n k = Nb_to_ks[i][j]\n vals.append(tau_es[k])\n\n plt.plot(bs, vals, \"-\")\n\n plt.title(\"Auto-correlation e-folding timelag for \"\n \"variable temperatures, grid sizes\")\n\n plt.xlabel(\"$\\\\beta$\")\n plt.ylabel(\"$\\\\tau_e$\")\n\n plt.legend([f\"N={N}\" for N in Ns])\n\n plt.savefig(resultspath / \"tau_es.pdf\")\n # plt.show()\n plt.close()\n\n # 2. magnetisation graphs\n # ------------------------------------------------------------\n\n mags_list = [np.load(datapath / f\"mags-{k}.npy\") for k in range(kcount)]\n\n for i, N in enumerate(Ns):\n\n plt.title(f\"Square magnetisations N={N}\")\n plt.xlabel(\"t\")\n plt.ylabel(\"M\")\n\n for j, b in enumerate(bs):\n\n c = np.max([0, np.min([1, 10 * (b - 0.4)])])\n\n k = Nb_to_ks[i][j]\n vals = np.mean(mags_list[k]**2, axis=1)\n plt.plot(vals, color=(1 - c, 0, c))\n\n plt.savefig(resultspath / f\"mags-{N}.pdf\")\n # plt.show()\n plt.close()\n\n # 3. autoc graphs\n # ------------------------------------------------------------\n\n autocs_list = [\n np.load(datapath / f\"autocs-{k}.npy\") for k in range(kcount)]\n\n for i, N in enumerate(Ns):\n\n plt.figure(figsize=(8, 6))\n plt.axes(position=[.05, .05, .8, .9])\n\n plt.title(f\"Auto-correlation of $|M|$ with N={N}\")\n plt.xlabel(\"$ \\\\tau $\")\n plt.ylabel(\"$ A(\\\\tau) $\")\n\n for j, b in enumerate(bs):\n\n c = np.max([0, np.min([1, 10 * (b - 0.4)])])\n\n k = Nb_to_ks[i][j]\n autocs = np.load(datapath / f\"autocs-{k}.npy\")\n\n iternum = autocs.shape[0]\n sysnum = autocs.shape[1]\n vals = np.mean(autocs, axis=1)\n errs = np.std(autocs, axis=1, ddof=1) / np.sqrt(sysnum)\n\n plt.errorbar(range(iternum), vals, errs,\n color=(1 - c, 0, c), ecolor=(1 - c, 0, c, 0.4),\n elinewidth=1.5)\n\n # plt.plot(np.log(vals))\n\n plt.legend(bs, loc='center left', bbox_to_anchor=(1, 0.5))\n\n plt.savefig(resultspath / f\"autocs-{N}.pdf\")\n # plt.show()\n plt.close()","def plot_iminuit_contours():\n log.info(\"plotting parameters contours obtained from iminuit\")\n # where to take the results, configurations for the individual butterflies\n instruments = [\"fermi\", \"magic\", \"veritas\", \"fact\", \"hess\", \"joint\"]\n labels = [\"Fermi-LAT\", \"MAGIC\", \"VERITAS\", \"FACT\", \"H.E.S.S.\", \"joint fit\"]\n colors = COLORS\n lss = [\"--\", \"--\", \"--\", \"--\", \"--\", \"-\"]\n\n fig, axarr = plt.subplots(1, 3, figsize=(16, 5))\n\n # with one loop we realize all the contour plots\n for instrument, label, color, ls in zip(instruments, labels, colors, lss):\n path = config.repo_path / f\"results/fit/gammapy/{instrument}\"\n\n contours_path = path / \"fit_1.0_sigma_contours_logparabola.npy\"\n results_path = path / \"fit_results_logparabola.yaml\"\n\n if not path.exists():\n log.warning(f\"Missing: {path} . Skipping.\")\n continue\n\n # load the contours and the results of the fit\n contours = np.load(contours_path).tolist()\n results = load_yaml(results_path)\n # true values to be plotted\n amplitude = float(results[\"parameters\"][0][\"value\"])\n alpha = float(results[\"parameters\"][2][\"value\"])\n beta = float(results[\"parameters\"][3][\"value\"])\n\n # amplitude vs alpha\n amplitude_alpha = contours[\"contour_amplitude_alpha\"]\n axarr[0].plot(\n amplitude_alpha[\"amplitude\"] * 10,\n amplitude_alpha[\"alpha\"],\n marker=\"\",\n ls=\"-\",\n lw=2.5,\n color=color,\n )\n # plot actual value\n axarr[0].plot(\n amplitude * 1e11, alpha, marker=\"X\", markersize=7, color=color, lw=2.5\n )\n axarr[0].set_xlabel(\n r\"$\\phi_0 \\,/\\,(10^{-11}\\,{\\rm TeV} \\, {\\rm cm}^{-2} {\\rm s}^{-1})$\",\n size=FONTSIZE_CONTOURS,\n )\n axarr[0].set_ylabel(r\"$\\Gamma$\", size=FONTSIZE_CONTOURS)\n # make axis thicker\n for axis in [\"top\", \"bottom\", \"left\", \"right\"]:\n axarr[0].spines[axis].set_linewidth(2.5)\n axarr[0].set_yticks([2.2, 2.4, 2.6, 2.8])\n axarr[0].set_ylim([2.1, 2.9])\n axarr[0].set_xticks([3, 4, 5])\n axarr[0].set_xlim([2.8, 5.2])\n axarr[0].tick_params(\n \"both\", length=7, width=1.6, which=\"major\", labelsize=FONTSIZE_CONTOURS\n )\n axarr[0].tick_params(\n \"both\", length=4, width=1.6, which=\"minor\", labelsize=FONTSIZE_CONTOURS\n )\n\n # amplitude vs beta\n amplitude_beta = contours[\"contour_amplitude_beta\"]\n axarr[1].plot(\n amplitude_beta[\"amplitude\"] * 10,\n # contour have a scale factor of 1e-10, parameters are in units of 1e-11\n amplitude_beta[\"beta\"],\n marker=\"\",\n ls=\"-\",\n lw=2.5,\n color=color,\n )\n # plot actual value\n axarr[1].plot(amplitude * 1e11, beta, marker=\"X\", markersize=7, color=color)\n axarr[1].set_xlabel(\n r\"$\\phi_0 \\,/\\,(10^{-11}\\,{\\rm TeV} \\, {\\rm cm}^{-2} {\\rm s}^{-1})$\",\n size=FONTSIZE_CONTOURS,\n )\n axarr[1].set_ylabel(r\"$\\beta$\", size=FONTSIZE_CONTOURS)\n axarr[1].set_xticks([3, 4, 5])\n axarr[1].set_xlim([2.8, 5.2])\n axarr[1].set_yticks([0.2, 0.4, 0.6])\n axarr[1].set_ylim([0.0, 0.8])\n # make axis thicker\n for axis in [\"top\", \"bottom\", \"left\", \"right\"]:\n axarr[1].spines[axis].set_linewidth(2.5)\n axarr[1].tick_params(\n \"both\", length=7, width=1.6, which=\"major\", labelsize=FONTSIZE_CONTOURS\n )\n axarr[1].tick_params(\n \"both\", length=4, width=1.6, which=\"minor\", labelsize=FONTSIZE_CONTOURS\n )\n\n # alpha vs beta\n alpha_beta = contours[\"contour_alpha_beta\"]\n axarr[2].plot(\n alpha_beta[\"alpha\"],\n alpha_beta[\"beta\"],\n marker=\"\",\n ls=\"-\",\n lw=2.5,\n color=color,\n )\n # plot actual value\n axarr[2].plot(alpha, beta, marker=\"X\", markersize=7, color=color)\n axarr[2].set_xlabel(r\"$\\Gamma$\", size=FONTSIZE_CONTOURS)\n axarr[2].set_ylabel(r\"$\\beta$\", size=FONTSIZE_CONTOURS)\n axarr[2].set_xticks([2.2, 2.4, 2.6, 2.8])\n axarr[2].set_xlim([2.1, 2.9])\n axarr[2].set_yticks([0.2, 0.4, 0.6])\n axarr[2].set_ylim([0.0, 0.8])\n # make axis thicker\n for axis in [\"top\", \"bottom\", \"left\", \"right\"]:\n axarr[2].spines[axis].set_linewidth(2.5)\n axarr[2].tick_params(\n \"both\", length=7, width=1.6, which=\"major\", labelsize=FONTSIZE_CONTOURS\n )\n axarr[2].tick_params(\n \"both\", length=4, width=1.6, which=\"minor\", labelsize=FONTSIZE_CONTOURS\n )\n\n # legend\n import matplotlib.lines as mlines\n\n fermi = mlines.Line2D(\n [], [], color=COLORS[0], marker=\"\", ls=\"-\", lw=2.5, label=\"Fermi-LAT\"\n )\n magic = mlines.Line2D(\n [], [], color=COLORS[1], marker=\"\", ls=\"-\", lw=2.5, label=\"MAGIC\"\n )\n veritas = mlines.Line2D(\n [], [], color=COLORS[2], marker=\"\", ls=\"-\", lw=2.5, label=\"VERITAS\"\n )\n fact = mlines.Line2D(\n [], [], color=COLORS[3], marker=\"\", ls=\"-\", lw=2.5, label=\"FACT\"\n )\n hess = mlines.Line2D(\n [], [], color=COLORS[4], marker=\"\", ls=\"-\", lw=2.5, label=\"H.E.S.S.\"\n )\n joint = mlines.Line2D(\n [], [], color=COLORS[5], marker=\"\", ls=\"-\", lw=2.5, label=\"joint fit\"\n )\n\n box = axarr[2].get_position()\n axarr[2].set_position([box.x0, box.y0, box.width * 0.97, box.height])\n # plot the legend on top of the central plot\n axarr[2].legend(\n handles=[fermi, magic, veritas, fact, hess, joint],\n loc=\"center left\",\n fontsize=FONTSIZE_CONTOURS,\n bbox_to_anchor=(1., 0.5),\n )\n\n plt.tight_layout()\n filename = \"results/figures/iminuit_logparabola_contour.png\"\n filename_pdf = \"results/figures/iminuit_logparabola_contour.pdf\"\n fig.savefig(filename)\n log.info(f\"Writing {filename}\")\n fig.savefig(filename)\n fig.savefig(filename_pdf)","def plot_parameter_evolution(analyses, pdf=False):\n ncs = np.arange(11, 15)\n genes = set(analyses.gene)\n constructs = set(analyses.construct)\n long_labels = {'bac': 'bac', 'no_pr': 'no pr', 'no_sh': 'no sh'}\n gene_long = {'hb': 'hunchback', 'kn': 'knirps', 'sn': 'snail'}\n y_label = {'j': 'Normalized flux $j$',\n 'rho': 'Site occupation density $\\\\rho$', 'tau': 'Residence time $\\\\tau$ (s)', 'alpha_comb': 'Initiation rate $\\\\alpha$ (pol/min)'}\n\n # Add extra jiggle to be able to distinguish overlapping data points\n x_jiggle = 0.04\n x_shifts = np.array([-1, 0, 1]) * x_jiggle\n\n # Plot parameters\n capsize = 0\n markersize = 4\n lw = 1 # line width\n\n for gene in genes:\n grouped_data = analyses.groupby(by=['gene', 'construct', 'nc'])\n all_means = grouped_data.mean()\n all_stds = grouped_data.std(ddof=1)\n all_ps = analyses.groupby(by=['gene', 'nc']).first()\n\n for quantity in ['j', 'rho', 'tau', 'alpha_comb']:\n ymaxs = {'j': 0.36, 'rho': 0.27, 'tau': 103, 'alpha_comb': 12}\n num = 12\n set_figure_size(num=num, rows=1, page_width_frac=0.5, clear=True, height_factor=0.7)\n fig, ax = plt.subplots(1, 1, num=num, clear=True)\n avg_data, std_data = {}, {}\n for construct in constructs:\n if quantity in ['rho', 'j']:\n avg_data[construct] = all_means.loc[(\n gene, construct, slice(None)), quantity].values\n std_data[construct] = all_stds.loc[(\n gene, construct, slice(None)), quantity].values\n\n elif quantity in ['tau', 'alpha_comb']:\n avg_data[construct] = all_means.loc[(\n gene, construct, slice(None)), quantity].values\n std_data[construct] = np.sqrt(\n all_means.loc[(gene, construct, slice(None)), quantity + 'V'].values)\n\n # Prepare a marker generator and plot the data with errorbars\n marker_gen = itertools.cycle(markers_additivity)\n for i, construct in enumerate(constructs):\n m = next(marker_gen)\n plt.errorbar(\n ncs + x_shifts[i], avg_data[construct],\n yerr=std_data[construct],\n fmt='-' + m, color=colors_additivity[construct],\n capsize=capsize, label=long_labels[construct],\n markersize=markersize, lw=lw)\n\n # Adjust plot\n plt.xlabel('Nuclear cycle')\n plt.ylabel(y_label[quantity])\n plt.ylim(ymin=0, ymax=ymaxs[quantity])\n\n plt.xticks(ncs)\n plt.title(gene_long[gene])\n\n plt.tight_layout()\n plt.show()\n\n # Save figure\n figname = 'additivity_' + quantity + '_' + gene\n figpath = os.path.join(figures_folder, figname)\n fig.savefig(figpath + '.png', pad_inches=0, bbox_inches='tight')\n if pdf:\n fig.savefig(figpath + '.pdf', pad_inches=0, bbox_inches='tight')","def plotResults(results):\n e = results['eclean'] - results['eCTI']\n e1 = results['e1clean'] - results['e1CTI']\n e2 = results['e2clean'] - results['e2CTI']\n\n print 'Delta e, e_1, e_2:', np.mean(e), np.mean(e1), np.mean(e2)\n print 'std e, e_1, e_2:', np.std(e), np.std(e1), np.std(e2)\n\n fig = plt.figure()\n ax = fig.add_subplot(111)\n ax.hist(e, bins=15, label='$e$', alpha=0.5)\n ax.hist(e1, bins=15, label='$e_{2}$', alpha=0.5)\n ax.hist(e2, bins=15, label='$e_{1}$', alpha=0.5)\n ax.set_xlabel(r'$\\delta e$ [no CTI - CDM03 corrected]')\n plt.legend(shadow=True, fancybox=True)\n plt.savefig('ellipticityDelta.pdf')\n plt.close()\n\n r2 = (results['R2clean'] - results['R2CTI'])/results['R2clean']\n print 'delta R2 / R2: mean, std ', np.mean(r2), np.std(r2)\n\n fig = plt.figure()\n ax = fig.add_subplot(111)\n ax.hist(r2, bins=15, label='$R^{2}$')\n ax.set_xlabel(r'$\\frac{\\delta R^{2}}{R^{2}_{ref}}$ [no CTI - CDM03 corrected]')\n plt.legend(shadow=True, fancybox=True)\n plt.savefig('sizeDelta.pdf')\n plt.close()","def plot_evaluation(parameters_dict, log_df, settings, evaluation_set_kde, plotname):\n\n\n plots = []\n\n\n ### setup the colors for each component\n if int(settings['nr_components']) < 3:\n colors = ['rgb(228,26,28)', 'rgb(55,126,184)']\n elif int(settings['nr_components']) < 13:\n colors = np.array(cl.scales[str(settings['nr_components'])]['qual']['Paired'])\n else:\n colors = cl.interp(cl.scales['10']['qual']['Paired'], 20)\n\n\n ### set up ab list\n ab_list = evaluation_set_kde['contact'].keys()\n\n\n\n\n ####################### plotting of settings\n print_to_table = {}\n for key in sorted(settings.keys()):\n if key not in ['fold_id_dir','plot_name', 'fixed_parameters', 'threads_proteins', 'qijab_dir',\n 'debug_mode', 'parameter_file', 'settings_file', 'optimization_log_file', 'braw_dir', 'pdb_dir', 'paramdir',\n 'mask_sse', 'lambda_w_fix', 'lfactor', 'plotdir', 'psicov_dir', 'contact', 'hessian_pseudocount']:\n print_to_table[key] = settings[key]\n\n print(\"Generate settings table...\")\n table_settings_1 = plot_settings_table(print_to_table, 1)\n table_settings_2 = plot_settings_table(print_to_table, 2)\n table_settings_3 = plot_settings_table(print_to_table, 3)\n plots.append(table_settings_1)\n plots.append(table_settings_2)\n plots.append(table_settings_3)\n\n\n ####################### negLL and realted plots\n if 'step' in log_df.columns and 'pass' in log_df.columns:\n\n if 'negLL' in log_df.columns:\n plot_negll = plot_convergence_trace_plotly(log_df,\n name=['negLL', 'negLL_crossval'],\n plot_title='neg LL trace for training and cross-val set')\n plots.append(plot_negll)\n\n plot_expfit_negll = plot_exponentialFit_negLL(log_df, plot_title='exponential Fit neg LL')\n plots.append(plot_expfit_negll)\n\n if 'timestamp' in log_df.columns:\n plot_timestamps = plot_convergence_trace_plotly(log_df,\n name=['timestamp'],\n plot_title='time (s) per iteration')\n plots.append(plot_timestamps)\n\n\n if 'gradient_norm_weights' in log_df.columns:\n plot_grad_norm_weights = plot_convergence_trace_plotly(log_df,\n name=['gradient_norm_weights'],\n plot_title='norm of weight gradients')\n plots.append(plot_grad_norm_weights)\n\n if 'gradient_norm_means' in log_df.columns:\n plot_grad_norm_means = plot_convergence_trace_plotly(log_df,\n name=['gradient_norm_means'],\n plot_title='norm of mean gradients')\n plots.append(plot_grad_norm_means)\n\n if 'gradient_norm_prec' in log_df.columns:\n plot_grad_norm_prec = plot_convergence_trace_plotly(log_df,\n name=['gradient_norm_prec'],\n plot_title='norm of precMat gradients')\n plots.append(plot_grad_norm_prec)\n\n\n ####################### plotting of parameters\n print(\"Generate distribution of parameters...\")\n\n #weights\n weights_dict = {}\n for component in range(settings['nr_components']):\n weights_dict['component ' + str(component)] = {\n 'weights (contact)': parameters_dict[\"weight_contact_\" + str(component)][0],\n 'weights (bg)': parameters_dict[\"weight_bg_\" + str(component)][0]\n }\n plot_weights = plot_barplot(\n weights_dict,\n 'Distribution of weights',\n 'component weights',\n type='group',\n colors=colors\n #,plot_out=\"/home/vorberg/weights.html\"\n )\n\n #mu\n mu_df = pd.DataFrame.from_dict(dict((k, parameters_dict[k]) for k in sorted(parameters_dict.keys()) if 'mu' in k))\n plot_means = plot_boxplot(\n mu_df,\n 'Distribution of Means',\n \"values of mean parameters\",\n colors=colors\n #,plot_out=\"/home/vorberg/mus.html\"\n )\n\n #std deviation\n prec_df = pd.DataFrame.from_dict(dict((k, parameters_dict[k]) for k in sorted(parameters_dict.keys()) if 'prec' in k))\n try:\n std_dev = prec_df.apply(lambda p: np.sqrt(1.0/p))\n if settings['prec_wrt_L']:\n std_dev = prec_df.apply(lambda p: np.sqrt(1.0/(p*142))) #in case precision is specified depending on L=142\n except ZeroDivisionError as e:\n print(e)\n std_dev=prec_df\n\n std_dev.columns = [column_name.replace(\"prec\", \"std\") for column_name in std_dev.columns]\n plot_stddev = plot_boxplot(\n std_dev,\n 'Distribution of std deviations',\n \"values of std deviation parameters\",\n colors=colors\n #,plot_out=\"/home/vorberg/std.html\"\n )\n\n\n plots.append(plot_weights)\n plots.append(plot_means)\n plots.append(plot_stddev)\n\n ####################### Scatterplot mu vs std dev\n print(\"Generate scatter plot mu vs std...\")\n scatter_dict = {}\n for component in range(settings['nr_components']):\n scatter_dict['mu_'+str(component)] = [\n mu_df['mu_'+str(component)].tolist(),\n std_dev['std_'+str(component)].tolist(),\n AB.values()\n ]\n plot_mu_vs_stddev = plot_scatter(scatter_dict,\n 'Mean vs std deviation',\n 'mean',\n \"std deviation\",\n False,\n colors\n #,plot_out=\"/home/vorberg/mu_vs_std.html\"\n )\n\n plots.append(plot_mu_vs_stddev)\n\n\n ############################################## plotting of gradient norms\n print(\"Generate gradient norms plot...\")\n\n #gradients for mu\n mu_grad_dict = {}\n annotations_dict = {}\n for component in range(settings['nr_components']):\n key = 'mu_'+str(component)\n mu_grad_dict[key] = log_df[key].tolist()[-1]\n annotations_dict[key] = AB\n\n\n plot_gradient_mu_stats = jitter_plot(mu_grad_dict,\n 'Distribution of gradients for mean in last iteration',\n annotations_dict,\n colors,\n None)\n plots.append(plot_gradient_mu_stats)\n\n\n #gradients for precMat\n precMat_grad_dict = {}\n annotations_dict = {}\n for component in range(settings['nr_components']):\n key = 'prec_'+str(component)\n precMat_grad_dict['diagPrecMat_'+str(component)] = log_df[key].tolist()[-1]\n annotations_dict['diagPrecMat_'+str(component)] = AB\n\n\n plot_gradient_precMat_stats = jitter_plot(\n precMat_grad_dict,\n 'Distribution of gradients for precMat in last iteration',\n annotations_dict,\n colors,\n None\n )\n plots.append(plot_gradient_precMat_stats)\n\n ##################################### plotting of gradient trace of a specific ab pair for all components\n print(\"Generate gradient trace plot...\")\n\n gradient_df = log_df.filter(regex=(\"mu_[0-9]*\"))\n plot_gradient_mu_ab_trace = plot_gradient_ab_trace(gradient_df,\n ab_list,\n colors\n )\n plots.append(plot_gradient_mu_ab_trace)\n\n gradient_df = log_df.filter(regex=(\"prec_[0-9]*\"))\n plot_gradient_prec_ab_trace = plot_gradient_ab_trace(\n gradient_df,\n ab_list,\n colors\n )\n plots.append(plot_gradient_prec_ab_trace)\n\n\n ##################################### plotting of univariate mixtures\n if len(evaluation_set_kde['contact']) == 0 or len(evaluation_set_kde['bg']) == 0:\n print \"Evaluation set is empty. Cannot plot Mixture Visualization.\"\n else:\n print(\"Generate parameter visualization 1d plots...\")\n plots.append(plot_parameter_visualisation_1d(parameters_dict, evaluation_set_kde, settings, colors, settings['prec_wrt_L']))\n # plot_parameter_visualisation_1d(parameters_dict, evaluation_set_kde, settings, colors, settings['prec_wrt_L'], plot_out=\"/home/vorberg/1d_vis.html\")\n\n # ------------------------------------------------------------------------------\n ### define merged plot\n # ------------------------------------------------------------------------------\n cols = 3.0\n rows = int(np.ceil((len(plots)-1) / cols)) + 2\n subplot_titles = []\n\n # set up titles\n for plot in range(len(plots)-1):\n subplot_titles.append(plots[plot]['layout']['title'])\n if len(subplot_titles) < (cols * (rows-2)):\n for i in range(int((cols * (rows-2))) - len(subplot_titles) ):\n subplot_titles.append(\" \")\n subplot_titles.append(plots[-1]['layout']['title'])\n\n\n # plot all plots as subplots\n fig = tools.make_subplots(rows=rows,\n cols=3,\n specs = [ [{} for col in range(int(cols))] for row in range(rows-2)] + \\\n [[{'rowspan':2, 'colspan': 3}, None, None], [None, None, None]],\n subplot_titles=tuple(subplot_titles),\n print_grid=False)\n\n\n\n\n for i, plot in enumerate(plots[:-1]):\n col = i % int(cols)\n row = (i - col) / int(cols)\n\n #add traces to subplot\n for trace in plot['data']:\n trace['showlegend']=False\n fig.append_trace(trace, row + 1, col + 1)\n\n # adjust x and y axis for table plotting\n if 'annotations' in plot['layout'].keys():\n for cell in plot['layout']['annotations']:\n cell['yref'] = 'y' + str(i + 1)\n cell['xref'] = 'x' + str(i + 1)\n fig['layout']['annotations'] += plot['layout']['annotations']\n\n # adjust axis for all plots\n fig['layout']['xaxis' + str(i + 1)].update(plot['layout']['xaxis1'])\n fig['layout']['yaxis' + str(i + 1)].update(plot['layout']['yaxis1'])\n\n ## add mixture visualisation plot - spans 3 columns\n for trace in plots[-1]['data']:\n fig.append_trace(trace, int(rows)-1, 1)\n fig['layout']['xaxis' + str(int(cols * (rows-2) + 1))].update(plots[-1]['layout']['xaxis1'])\n fig['layout']['yaxis' + str(int(cols * (rows-2) + 1))].update(plots[-1]['layout']['yaxis1'])\n\n #check which plots are visible/invisible according to menu selection\n trace_visibility_ab = {}\n for ab in range(len(ab_list)):\n trace_visibility_ab[ab] = []\n for i, plot in enumerate(plots):\n if 'updatemenus' not in plot['layout'].keys():\n trace_visibility_ab[ab].extend([True] * len(plot['data']))\n else:\n trace_visibility_ab[ab].extend(plot['layout']['updatemenus'][0]['buttons'][ab]['args'][1])\n\n\n #use menu of last plot (=vis of mixture) as template for multiplot menu\n fig['layout']['updatemenus'] = plots[-1]['layout']['updatemenus']\n for ab in range(len(ab_list)):\n fig['layout']['updatemenus'][0]['buttons'][ab]['args'][1] = trace_visibility_ab[ab]\n\n\n fig['layout']['legend']['yanchor'] = 'bottom'\n fig['layout']['legend']['y'] = 0\n fig['layout']['height'] = rows * 250\n fig['layout']['font'] = {'size': 18} # set global font size\n\n plotly_plot(fig, filename=plotname, auto_open=False)","def plot(results, key, titles):\n # get parametric sweep data\n N = int(math.sqrt(len(results.data)))\n M = results.data[key].reshape(N, N)\n R = results.data['r'].reshape(N, N)\n PD = results.data['pd'].reshape(N, N)\n\n fig = plt.figure()\n ax = fig.gca(projection='3d')\n surf = ax.plot_surface(R, PD, M,\n cmap=cm.viridis, linewidth=0,\n vmin=0, vmax=np.nanmax(M),\n antialiased=False)\n\n # set x/y axis labels, ticks\n ax.set_xlabel(\"Coolant Channel Diameter [m]\", fontsize=7)\n plt.xticks(rotation=25, fontsize=6)\n ax.set_ylabel(\"Fuel Pitch to Coolant D Ratio [-]\", fontsize=7)\n plt.yticks(rotation=25, fontsize=6)\n ax.set_zlabel(titles[key][1], fontsize=7)\n\n # Customize the z axis.\n ax.set_zlim(np.nanmin(M), np.nanmax(M))\n ax.zaxis.set_major_locator(LinearLocator(10))\n ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))\n\n # edit z tick labels\n for t in ax.zaxis.get_major_ticks():\n t.label.set_fontsize(6)\n niceMathTextForm = ScalarFormatter(useMathText=True)\n ax.w_zaxis.set_major_formatter(niceMathTextForm)\n ax.ticklabel_format(axis=\"z\", style=\"sci\", scilimits=(0, 0))\n plt.title(titles[key][0])\n\n # Add a color bar which maps values to colors.\n fig.colorbar(surf, shrink=0.5, aspect=5, format='%.0e')\n\n return plt","def plot_u(self, **kwargs):\r\n\r\n # Get the kwargs.\r\n items = kwargs['items']\r\n if type(items) is not list:\r\n items = [items]\r\n if 'desc' in kwargs.keys():\r\n desc = kwargs['desc']\r\n else:\r\n desc = ''\r\n\r\n # Loop and plot each requested dof.\r\n fig = figure()\r\n ax = subplot(111)\r\n for item in items:\r\n if item.__len__() != 3:\r\n raise Exception('!!! You must supply (case, acron, dof) to plot !!!')\r\n c = item[0]\r\n if c not in self.u.keys():\r\n raise Exception('!!! Case {0} is has not been run or does not exist !!!'.format(c))\r\n dof = (item[1], item[2])\r\n\r\n # Find the dof tuple in the acron_dof list or the dof list from the ltm object.\r\n if dof in self.ltm.acron_dofs:\r\n i_dof = self.ltm.acron_dofs.index(dof)\r\n elif dof in self.ltm.dofs:\r\n i_dof = self.ltm.dofs.index(dof)\r\n else:\r\n raise Exception(\"!!! DOF \" + dof.__str__() + \" not in LTM \" + self.ltm.name)\r\n\r\n # Plot the requested time history.\r\n label = '({0}, {1}) case: {2}'.format(dof[0], dof[1], c)\r\n ax.plot(self.time[c], self.u[c][i_dof, :], label=label)\r\n ax.legend()\r\n title('Response of FF: %s' % (self.pfile.name))\r\n xlabel('Time (s)')\r\n fig.canvas.set_window_title('{0} {1}'.format(self.name, desc))\r\n show()","def plot_all_LLRs(self, outdir):\n\t\t#Iterate over all parameter groups\n\t\tfor group in self.group_names:\n\t\t\tself.plot_group_LLR(groupname=group, outdir=outdir)","def plot(filename):\n\tdata = np.load(filename)\n\tAlpha = data['ALPHA']\n\tCn = data['NFE']\n\tCf = data['FFE']\n\tP = data['PHINORM']\n\tSr = data['STABILITY']\n\tFlag = data['FLAG']\n\tIter = data['ITER']\n\tF = data['F']\n\tD = data['D']\n\tE = data['EPSILON']\n\tdelta = data['DELTA']\n\n\t#auxiliary variables\n\tLogA = np.log10(Alpha)\n\tLogP = np.log10(P)\n\n\tplt.rc('text', usetex=False)\n\tplt.rc('font', family='serif')\n\torient = 'vertical'\n\tXLABEL = r\"$d$\"\n\tYLABEL = r\"$\\epsilon$\"\n\t\n\tNd = D.shape[0]\n\tNepsilon = D.shape[1]\n\tN = Nd*Nepsilon\n\t\n\tD = np.reshape(D, (N, ))\n\tE = np.reshape(E, (N, ))\n\tSr = np.reshape(Sr, (N, ))\n\tLogA = np.reshape(LogA, (N, ))\n\tLogP = np.reshape(LogP, (N, ))\n\tG = np.sqrt(np.abs(F))/delta\n\tG = np.reshape(G, (N, ))\n\n\tfig = plt.figure(1)\n\tax = fig.add_subplot(221, projection='3d')\n\tax.set_xlabel(XLABEL, fontsize=AXESFONTSIZE)\n\tax.set_ylabel(YLABEL, fontsize=AXESFONTSIZE)\n\tax.set_zlabel(r\"$\\log_{10}{\\alpha}$\", fontsize=AXESFONTSIZE)\n\tax.set_xlim3d(D.min(), D.max())\n\tax.set_ylim3d(E.min(), E.max())\n\tax.set_zlim3d(LogA.min(), LogA.max())\n\tsurf1 = ax.plot_trisurf(D, E, LogA, vmin=LogA.min(), vmax=LogA.max(), cmap=cm.jet, edgecolor='none')\n\tfig.colorbar(surf1, shrink=0.5, aspect=5, pad=0.05, orientation = orient)\n\n\tax = fig.add_subplot(222, projection='3d')\n\tax.set_xlabel(XLABEL, fontsize=AXESFONTSIZE)\n\tax.set_ylabel(YLABEL, fontsize=AXESFONTSIZE)\n\tax.set_zlabel(\"\\n\" + r\"$\\log\\left(\\Vert \\phi\\Vert_{L^{2}(\\partial D_{a})} \\right)$\", fontsize=AXESFONTSIZE, linespacing=2)\n\tax.set_xlim3d(D.min(), D.max())\n\tax.set_ylim3d(E.min(), E.max())\n\tsurf2 = ax.plot_trisurf(D, E, LogP, cmap=cm.jet, vmin=LogP.min(), vmax=LogP.max(), edgecolor='none')\n\tfig.colorbar(surf2, shrink=0.5, aspect=5, pad=0.05, orientation = orient)\n\n\tax = fig.add_subplot(223, projection='3d')\n\tax.set_xlabel(XLABEL, fontsize=AXESFONTSIZE)\n\tax.set_ylabel(YLABEL, fontsize=AXESFONTSIZE)\n\tax.set_zlabel(\"\\n\" + r\"$\\frac{\\Vert \\phi^{\\epsilon} - \\phi_{0}\\Vert}{\\Vert \\phi^{0}\\Vert}$\", fontsize=AXESFONTSIZE, linespacing=2)\n\tax.set_xlim3d(D.min(), D.max())\n\tax.set_ylim3d(E.min(), E.max())\n\tsurf3 = ax.plot_trisurf(D, E, Sr, cmap=cm.jet, vmin=Sr.min(), vmax=Sr.max(), edgecolor='none')\n\tfig.colorbar(surf3, shrink=0.5, aspect=5, pad=0.05, orientation = orient)\n\n\tax = fig.add_subplot(224, projection='3d')\n\tax.set_xlabel(XLABEL, fontsize=AXESFONTSIZE)\n\tax.set_ylabel(YLABEL, fontsize=AXESFONTSIZE)\n\tax.set_zlabel(\"\\n\" + r\"$\\frac{\\sqrt{|F(\\alpha)|}}{\\delta}$\", fontsize=AXESFONTSIZE, linespacing=2)\n\tax.set_xlim3d(D.min(), D.max())\n\tax.set_ylim3d(E.min(), E.max())\n\tscatter4 = ax.scatter(D, E, G, c=G, s=5)\n\tfig.colorbar(scatter4, shrink=0.5, aspect=5, pad=0.05, orientation = orient)\n\tax.view_init(azim=-129, elev=20)\n\n\tfig.subplots_adjust(left = 0.02, right = 0.98, wspace=0.05, hspace=0.05, top=0.95, bottom=0.05)\n\tplt.show()","def plotGrid(parameters, plot_name):\n\n allNames = sorted(parameters)\n combinations = it.product(*(parameters[Name] for Name in allNames))\n\n combs = [list(c) for c in list(combinations) ]\n combs_df = pd.DataFrame(combs, columns=[\"criterion\", \"max_features\", \"n_estimators\"])\n\n trace = go.Scatter3d(\n x=combs_df['criterion'],\n y=combs_df['max_features'],\n z=combs_df['n_estimators'],\n mode='markers',\n marker=dict(\n size= 5,\n color='green',\n opacity=0.99,\n colorscale='Viridis',\n showscale=False\n )\n )\n data = [trace]\n layout = go.Layout(\n margin=dict(\n l=30,\n r=30,\n b=30,\n t=30\n ),\n height=700,\n width=960,\n showlegend=True,\n scene=dict(\n xaxis=dict(\n title='criterion',\n nticks=10,\n ),\n yaxis=dict(\n title='max_features',\n nticks=10,\n ),\n zaxis=dict(\n title='n_estimators',\n nticks=10,\n ),\n camera=dict(\n eye=dict(\n y=2.089757339892154,\n x=-0.5464711077183096,\n z=0.14759264478960377,\n )\n ),\n ),\n )\n\n fig = go.Figure(data=data, layout=layout)\n fig.show()\n fig.write_image(plot_name)\n fig.write_html(script_path + \"/results/GridSearchPlot.html\")","def plot_specific_forward_model_result(real_data_array, synth_forward_model_result_array, data_labels, plot_title=\"\", perform_normallised_waveform_inversion=True):\n fig, axarr = plt.subplots(len(real_data_array[:,0]), sharex=True)\n for i in range(len(axarr)):\n if perform_normallised_waveform_inversion:\n axarr[i].plot(real_data_array[i,:]/np.max(np.absolute(real_data_array[i,:])),c='k', alpha=0.6) # Plot real data\n axarr[i].plot(synth_forward_model_result_array[i,:]/np.max(np.absolute(synth_forward_model_result_array[i,:])),c='r',linestyle=\"--\", alpha=0.6) # Plot synth data\n else:\n axarr[i].plot(real_data_array[i,:],c='k', alpha=0.6) # Plot real data\n axarr[i].plot(synth_forward_model_result_array[i,:],c='r',linestyle=\"--\", alpha=0.6) # Plot synth data\n axarr[i].set_title(data_labels[i])\n plt.suptitle(plot_title)\n plt.show()","def plotMSSpectra3D(listOfFilesToPlot, listOfNames=None, listOfColors=None, gridLines=False, yMin=0.5, yMax=2.5, yScale = 1.0,\r\n legend=True, normalizeToN15=False, subtractRef=None, legendLoc=4, lw=1.5, xMin=0, xMax=2000, scaleP=False, scaleI=0, scaleVal=1.0,\r\n figsize=(10,10), tLeft=0, tRight=-1, fixedOffset=False, noTicks=False, xlabel='mass', zlabel='intensity', a14=1.0): \r\n if listOfNames==None:\r\n listOfNames = listOfFilesToPlot\r\n if listOfColors==None:\r\n listOfColors = [pylab.cm.jet(float(i)/float(len(listOfFilesToPlot))) for i in range(len(listOfFilesToPlot))]\r\n \r\n fig = pylab.figure(figsize=figsize)\r\n ax = fig.add_subplot(111, projection='3d')\r\n\r\n yTotal = len(listOfFilesToPlot)\r\n top = 0.0\r\n\r\n if not (subtractRef is None):\r\n [bhah, zsRef, blah] = qMS.readMSSpectraFile(listOfFilesToPlot[subtractRef])\r\n #zsRef = list(numpy.array(zsRef)-fixedOffset\r\n zNorm = max(zsRef[len(zsRef)/2:])\r\n zsRef = numpy.array(zsRef)/zNorm\r\n \r\n for i,f in enumerate(listOfFilesToPlot):\r\n [xs, zs, name] = qMS.readMSSpectraFile(f)\r\n if fixedOffset:\r\n off = zs[len(zs)/2]\r\n print off\r\n #zs = list(numpy.array(zs)-zs[len(zs)/2])\r\n zs = list(numpy.array(zs)-off)\r\n ys = [yTotal-i]*len(xs)\r\n ys = numpy.array(ys)*yScale\r\n if normalizeToN15:\r\n zNorm = max(zs[len(zs)/2:])\r\n zs = numpy.array(zs)/zNorm\r\n if not (subtractRef is None):\r\n zNorm = max(zs[len(zs)/2:])\r\n zs = numpy.array(zs)/zNorm\r\n zs[:len(zsRef)/2] = zs[:len(zs)/2]-zsRef[:len(zsRef)/2]\r\n zs = zs*zNorm\r\n #xs = xs[:len(xs)/2]\r\n #ys = ys[:len(ys)/2]\r\n #zs = zs[:len(zs)/2]\r\n zs[:len(zs)/2] = numpy.array(zs[:len(zs)/2])*a14\r\n if (scaleP is True) and (i==scaleI):\r\n zs = numpy.array(zs)*scaleVal\r\n ax.plot(numpy.array(xs[tLeft:tRight]),numpy.array(ys[tLeft:tRight]),numpy.array(zs[tLeft:tRight]), color=listOfColors[i], lw=lw, label=listOfNames[i])\r\n top = max([top, float(max(zs))])\r\n\r\n\r\n ax.w_xaxis.pane.set_visible(False)\r\n ax.w_yaxis.pane.set_visible(False)\r\n ax.w_zaxis.pane.set_visible(False)\r\n\r\n if gridLines: \r\n ax.w_xaxis.gridlines.set_linewidth(1)\r\n ax.w_yaxis.gridlines.set_linewidth(1)\r\n ax.w_zaxis.gridlines.set_linewidth(1)\r\n \r\n else:\r\n ax.w_xaxis.gridlines.set_visible(False)\r\n ax.w_yaxis.gridlines.set_visible(False)\r\n ax.w_zaxis.gridlines.set_visible(False)\r\n\r\n [i.set_linewidth(1) for i in ax.w_xaxis.get_ticklines()]\r\n [i.set_linewidth(1) for i in ax.w_yaxis.get_ticklines()]\r\n [i.set_linewidth(1) for i in ax.w_zaxis.get_ticklines()]\r\n\r\n ax.w_xaxis.line.set_linewidth(1)\r\n ax.w_yaxis.line.set_linewidth(1)\r\n ax.w_zaxis.line.set_linewidth(1)\r\n \r\n ax.set_zticks([round(i,1) for i in [0, top/3, 2*top/3, top]])\r\n ax.set_zlim3d([0, top])\r\n ax.set_ylim3d(yMin, yMax)\r\n ax.set_yticks(range(1,yTotal+1))\r\n pylab.yticks(range(1,yTotal+1), ['']*yTotal)\r\n ax.set_xlim3d([xMin, xMax])\r\n \r\n if noTicks:\r\n ax.set_zticks([])\r\n ax.set_xticks([])\r\n ax.set_yticks([])\r\n\r\n ax.set_xlabel(xlabel)\r\n ax.set_zlabel(zlabel)\r\n\r\n ax.view_init(15, -60)\r\n if legend:\r\n pylab.legend(loc=legendLoc)\r\n \r\n pylab.tight_layout()\r\n return ax","def plot_profiles(self, parameters, fig=1):\n # Make sure the parameters are a list\n if isinstance(parameters, str) or isinstance(parameters, unicode):\n parameters = [parameters]\n \n # Decide how many subplots to create\n nrows = int(len(parameters) / 3)\n if len(parameters) % 3 > 0:\n nrows += 1\n \n # Initialize a figure for plotting\n width = 8\n height = 4 * nrows\n plt.figure(fig, figsize=(width, height))\n plt.clf()\n \n # Plot each parameter\n for parm in parameters:\n ax = plt.subplot(nrows, 3, parameters.index(parm)+1)\n self.plot_parameter(parm)\n \n plt.tight_layout()\n \n plt.show()","def plot_source_residuals_comparison(source_truth, source_model_list, name_list, \n vmin_res=-0.5, vmax_res=-0.5, cmap='cubehelix',\n fontsize=12):\n n_model = len(source_model_list)\n fig, axes = plt.subplots(1+n_model, 2, figsize=(9, (1+n_model)*3.5))\n axes[0, 1].axis('off')\n ax = axes[0, 0]\n #ax.get_xaxis().set_visible(False)\n #ax.get_yaxis().set_visible(False)\n ax.set_title(\"true source\", fontsize=fontsize)\n im = ax.imshow(source_truth, cmap=cmap, vmin=0)\n lims = (len(source_truth)/4, 3*len(source_truth)/4) # zoom a bit on the image\n #ax.set_xlim(*lims)\n #ax.set_ylim(*lims)\n plot_util.nice_colorbar(im, label=\"flux\", fontsize=fontsize)\n \n i = 1\n for source_model, name in zip(source_model_list, name_list):\n print(\"min/max for source model '{}': {}/{}\".format(name, source_model.min(), source_model.max()))\n\n residuals_source = source_model - source_truth\n\n ax = axes[i, 0]\n ax.set_title(\"model '{}'\".format(name), fontsize=fontsize)\n #ax.get_xaxis().set_visible(False)\n #ax.get_yaxis().set_visible(False)\n im = ax.imshow(source_model, cmap=cmap)\n #ax.set_xlim(*lims)\n #ax.set_ylim(*lims)\n plot_util.nice_colorbar(im, label=\"flux\", fontsize=fontsize)\n \n ax = axes[i, 1]\n #ax.get_xaxis().set_visible(False)\n #ax.get_yaxis().set_visible(False)\n ax.set_title(\"difference\", fontsize=fontsize)\n #ax.set_xlim(*lims)\n #ax.set_ylim(*lims)\n im = ax.imshow(residuals_source, cmap='RdBu_r', vmin=vmin_res, vmax=vmax_res)\n plot_util.nice_colorbar_residuals(im, residuals_source, vmin_res, vmax_res,\n label=r\"f${}_{\\rm model}$ - f${}_{\\rm truth}$\", fontsize=fontsize)\n \n print(\"SDR for model '{}' = {:.3f}\".format(name, metrics_util.SDR(source_truth, source_model)))\n i += 1\n\n return fig","def plot_fit_results(tool):\n fig, ax = plt.subplots()\n\n model_meyer_ref = CrabSpectrum(\"meyer\").model\n model_meyer_ref.plot(\n [10 * u.GeV, 100 * u.TeV],\n energy_power=2,\n flux_unit=\"erg-1 cm-2 s-1\",\n ls=\":\",\n lw=2.2,\n color=\"#555555\",\n label=\"Meyer et al. (2010)\",\n )\n\n # where to take the results, configurations for the individual butterflies\n instruments = [\"fermi\", \"magic\", \"veritas\", \"fact\", \"hess\", \"joint\"]\n labels = [\"Fermi-LAT\", \"MAGIC\", \"VERITAS\", \"FACT\", \"H.E.S.S.\", \"joint fit\"]\n lss = [\"--\", \"--\", \"--\", \"--\", \"--\", \"-\"]\n colors = COLORS\n # with one loop we realize all the butterfly plots\n for instrument, label, color, ls in zip(instruments, labels, colors, lss):\n\n path = (\n config.repo_path\n / f\"results/fit/{tool}/{instrument}/fit_results_logparabola.yaml\"\n )\n\n if not path.exists():\n log.warning(f\"Missing: {path} . Skipping.\")\n continue\n\n results = load_yaml(path)\n parameters = results[\"parameters\"]\n\n model_lp = LogParabola.from_log10(\n amplitude=parameters[0][\"value\"] * u.Unit(parameters[0][\"unit\"]),\n reference=parameters[1][\"value\"] * u.Unit(parameters[1][\"unit\"]),\n alpha=parameters[2][\"value\"] * u.Unit(parameters[2][\"unit\"]),\n beta=parameters[3][\"value\"] * u.Unit(parameters[3][\"unit\"]),\n )\n\n # energy range for the plot\n dataset = config.get_dataset(instrument)\n energy_range = dataset.energy_range\n\n # just in case of the joint fit put a thicker line and a less transparent butterfly\n if instrument == \"joint\":\n model_lp.plot(\n energy_range,\n energy_power=2,\n flux_unit=\"erg-1 cm-2 s-1\",\n ls=ls,\n lw=3,\n color=color,\n label=label,\n )\n else:\n model_lp.plot(\n energy_range,\n energy_power=2,\n flux_unit=\"erg-1 cm-2 s-1\",\n ls=ls,\n lw=2.2,\n color=color,\n label=label,\n )\n\n # read the butterfly from the multivariate sampling results\n table_path = Path(\n f\"{config.repo_path}/results/figures/stat_err/{instrument}_flux_errorband.dat\"\n )\n log.info(f\"reading butterfly values from {table_path}\")\n t = Table.read(table_path, format=\"ascii.ecsv\")\n energies = t[\"energies\"].data * t[\"energies\"].unit\n flux_lo = t[\"flux_lo\"].data * t[\"flux_lo\"].unit\n flux_hi = t[\"flux_hi\"].data * t[\"flux_hi\"].unit\n\n if instrument == \"joint\":\n alpha = 0.38\n else:\n alpha = 0.28\n\n plt.fill_between(\n energies.to(\"TeV\"),\n (energies ** 2 * flux_lo).to(\"erg cm-2 s-1\"),\n (energies ** 2 * flux_hi).to(\"erg cm-2 s-1\"),\n color=color,\n alpha=alpha,\n label=\"\",\n )\n\n ax.legend(fontsize=FONTSIZE)\n ax.set_ylim([1e-12, 2e-10])\n\n ax.set_xlabel(E_UNIT_LABEL, size=FONTSIZE)\n ax.set_ylabel(SED_UNIT_LABEL, size=FONTSIZE)\n # make axis thicker\n for axis in [\"top\", \"bottom\", \"left\", \"right\"]:\n ax.spines[axis].set_linewidth(1.6)\n ax.tick_params(\"both\", length=7, width=1.6, which=\"major\", labelsize=FONTSIZE)\n ax.tick_params(\"both\", length=4, width=1.6, which=\"minor\", labelsize=FONTSIZE)\n\n plt.tight_layout()\n\n filename = f\"results/figures/crab_sed_{tool}_fit.png\"\n filename_pdf = f\"results/figures/crab_sed_{tool}_fit.pdf\"\n log.info(f\"Writing {filename}\")\n fig.savefig(filename)\n fig.savefig(filename_pdf)","def plot_results(self, a):\n import matplotlib.pyplot as plt\n fig, axes = plt.subplots(nrows=len(a.data_vars), sharex='all', sharey='all')\n for ax, var in zip(axes, a.data_vars):\n data = a[var]\n plt.sca(ax)\n data.plot(x='time', cmap=plt.cm.viridis_r, yincrease=False, robust=True)\n plt.show()","def plot_model(model, inputs, outputs, tss=90):\n mdl = np.load(model)\n sys = ss(mdl['A'], mdl['B'], mdl['C'], mdl['D'],1)\n gain_matrix = dcgain(sys).T\n num_i = len(inputs)\n num_o = len(outputs)\n fig, axs = plt.subplots(num_i,num_o, figsize=(3*len(outputs), 2*len(inputs)), facecolor='w', edgecolor='k')\n fig.suptitle('Step responce: '+model)\n T = np.arange(tss)\n for idx_i in range(num_i):\n for idx_o in range(num_o):\n ax = axs[idx_i][idx_o]\n t,y_step = step_response(sys,T, input=idx_i, output=idx_o)\n gain = round(gain_matrix[idx_i][idx_o],4)\n ax.plot(t, y_step,color='r')\n if idx_i == 0:\n ax.set_title(outputs[idx_o], rotation='horizontal', ha='center', fontsize=10)\n if idx_o == 0:\n ax.set_ylabel(inputs[idx_i], rotation=90, fontsize=10)\n ax.grid(color='k', linestyle='--', linewidth=0.5)\n ax.tick_params(axis='x', colors='red',size=0,labelsize=4)\n ax.tick_params(axis='y', colors='red',size=0,labelsize=4)\n ax.annotate(str(gain),xy=(.72,.8),xycoords='axes fraction')\n # fig.tight_layout()\n plt.show()","def fdd_plot(result_file_list,default_fdds,ion_default):\n # Getting data from the file\n fdd_param_keys = [result_file.split('_')[0] for result_file in result_file_list]\n# print \" Parameters to plot for:\", fdd_param_keys\n fig = plt.figure(figsize=(14,12))#(8.27,11.69))\n axs = [None]*(len(result_file_list)*5 + 1) # List of axes: 2 ions x (1 uncert + 1 value) + 1 for iterations (axs[0] will not be used)\n for j,result_file_name in enumerate(result_file_list):\n with open(result_file_name,'r') as res_file:\n res_data = res_file.read().split('\\n')\n if res_data[-1] == \"\": # delete empty line if present\n del res_data[-1]\n else:\n pass\n fdd_list, H_list, Hunc_list, D_list, Dunc_list, n_iter_list,fdd_iter_list = [[] for i in range(7)]\n for line in res_data:\n line_split = line.split()\n if line_split[1] == '0' or line_split[1] == '-1':\n fdd_list.append(float(line_split[0].split('_')[-1])) # fdd_list\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\n if line_split[1] == '0':\n n_iter_list.append(int(line_split[2])) # number of iterations list\n else:\n n_iter_list.append(-1) # 125, number of iterations\n H_list.append(float(line_split[3])) # H_list\n Hunc_list.append(float(line_split[4])) # Hunc_list\n D_list.append(float(line_split[5])) # D_list\n Dunc_list.append(float(line_split[6])) # Dunc_list\n elif line_split[1] == '1':\n print \" {} = {} <- excluded: error '1' (no f26 file was found, check 'stdout.dat' and 'stderr.dat')\".format(fdd_param_keys[j], line_split[0])\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\n n_iter_list.append(0) # number of iterations list\n elif line_split[1] == '2':\n print \" {} = {} <- excluded: error '2' (error happened during VPFITing, check 'stderr.dat')\".format(fdd_param_keys[j], line_split[0])\n\t\tfdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\n\t\tn_iter_list.append(0) # number of iterations list\n elif line_split[1] == '3':\n print \" {} = {} <- excluded: error '3' (zero size f26 file, check 'stdout.dat')\".format(fdd_param_keys[j], line_split[0])\n\t\tfdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\n\t\tn_iter_list.append(0) # number of iterations list\n elif line_split[1] == '4':\n print \" {} = {} <- excluded: error '4' (new and original f26's have different number of lines, check 'stdout.dat')\".format(fdd_param_keys[j], line_split[0])\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\n\t\tn_iter_list.append(-3) # number of iterations list\n elif line_split[1] == '5':\n print \" {} = {} <- excluded: error '5' ('****' uncertainty was found for one of specified ion! Check f26 file)\".format(fdd_param_keys[j], line_split[0])\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\n\t\tn_iter_list.append(-2) # number of iterations list\n else:\n print \" Unknown error code was specified in {}\".format(result_file_name)\n\n # Data are ready to plot\n # First column of subplots (uncertainties)\n axs[5*j+1] = plt.subplot(len(fdd_param_keys),3,3*j+1)\n axs[5*j+1].plot(fdd_list,Dunc_list,color='b',drawstyle=\"steps-mid\") # Plotting data\n axs[5*j+1].plot(default_fdds[fdd_param_keys[j]],ion_default[3],'bo',mew=0.0) # plotting default result\n axs[5*j+1].set_ylabel(r'$\\Delta$N(D I)',color='b')\n axs[5*j+1].tick_params('y',colors='b')\n axs[5*j+1].ticklabel_format(useOffset=False)\n axs[5*j+1].set_xscale('log')\n if fdd_param_keys[j] == 'fdbstep':\n axs[5*j+1].set_xlabel('{} [{:g}], km/s'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\n else:\n axs[5*j+1].set_xlabel('{} [{:g}]'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\n axs[5*j+1].axvline(default_fdds[fdd_param_keys[j]],linewidth=1,color='g') # indicate fdd from vp_setup.dat\n# axs[5*j+1].margins(y=np.ptp(Dunc_list)/2.0) # Include marging above and below the data to show default fdds\n axs[5*j+2] = axs[5*j+1].twinx() # second plot on the same axis\n axs[5*j+2].plot(fdd_list,Hunc_list,color='r',drawstyle=\"steps-mid\")\n axs[5*j+2].plot(default_fdds[fdd_param_keys[j]],ion_default[1],'ro',mew=0.0)\n axs[5*j+2].set_ylabel(r'$\\Delta$N(H I)',color='r')\n axs[5*j+2].tick_params('y',colors='r')\n axs[5*j+2].ticklabel_format(useOffset=False,axis='y')\n # Second column of subplots (middle values)\n axs[5*j+3] = plt.subplot(len(fdd_param_keys),3,3*j+2)\n plot_interal = False # Add 1-sigma interval\n if plot_interal == True:\n median = np.median(D_list)\n med_unc = np.median(Dunc_list)\n print \"median = {} +/- {} for {}\".format(median,med_unc,fdd_param_keys[j])\n axs[5*j+3].fill_between(fdd_list, median-med_unc, median+med_unc,facecolor='green', alpha=0.4)\n axs[5*j+3].plot(fdd_list,D_list,color='b',drawstyle=\"steps-mid\",zorder=2) # Plotting data\n axs[5*j+3].plot(default_fdds[fdd_param_keys[j]],ion_default[2],'bo',zorder=10,mew=0.0)\n axs[5*j+3].set_ylabel(r'N(D I)',color='b')\n axs[5*j+3].ticklabel_format(useOffset=False)\n axs[5*j+3].tick_params('y',colors='b')\n axs[5*j+3].set_xscale('log')\n if fdd_param_keys[j] == 'fdbstep':\n axs[5*j+3].set_xlabel('{} [{:g}], km/s'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\n else:\n axs[5*j+3].set_xlabel('{} [{:g}]'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\n axs[5*j+3].axvline(default_fdds[fdd_param_keys[j]],linewidth=1,color='g') # indicate fdd from vp_setup.dat\n# axs[5*j+3].margins(y=np.ptp(D_list),tight=False) # Include marging above and below the data to show default fdds\n axs[5*j+4] = axs[5*j+3].twinx()\n axs[5*j+4].plot(fdd_list,H_list,color='r',drawstyle=\"steps-mid\",zorder=1)\n axs[5*j+4].plot(default_fdds[fdd_param_keys[j]],ion_default[0],'ro',zorder=10,mew=0.0)\n axs[5*j+4].set_ylabel(r'N(H I)',color='r')\n axs[5*j+4].tick_params('y',colors='r')\n axs[5*j+4].ticklabel_format(useOffset=False,axis='y')\n # Third column of subplots (number of iterations)\n axs[5*j+5] = plt.subplot(len(fdd_param_keys),3,3*j+3)\n axs[5*j+5].plot(fdd_iter_list,n_iter_list,drawstyle=\"steps-mid\") # Plotting n_iter_list\n# axs[5*j+5].yaxis.tick_right()\n# axs[5*j+5].yaxis.set_label_position(\"right\")\n axs[5*j+5].set_ylabel('N iterations')\n axs[5*j+5].ticklabel_format(useOffset=False)\n axs[5*j+5].set_xscale('log')\n if fdd_param_keys[j] == 'fdbstep':\n axs[5*j+5].set_xlabel('{} [{:g}], km/s'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\n else:\n axs[5*j+5].set_xlabel('{} [{:g}]'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\n axs[5*j+5].axvline(default_fdds[fdd_param_keys[j]],linewidth=1,color='g') # indicate fdd from vp_setup.dat\n axs[5*j+5].axhline(0,linewidth=1,color='grey',ls=\":\") # indicate fdd from vp_setup.dat\n\n# plt.tight_layout()\n fig.subplots_adjust(hspace=0.3,wspace=0.9) # Set up spaces between subplots\n plt.savefig(\"fdd_plot.pdf\",bbox_inches='tight', pad_inches=0)\n plt.show()\n plt.close()\n print \" Plot is done!\"","def plotFittingResults(self):\n _listFitQ = [tmp.getValue() for tmp in self.getDataOutput().getScatteringFitQ()]\n _listFitValues = [tmp.getValue() for tmp in self.getDataOutput().getScatteringFitValues()]\n _listExpQ = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataQ()]\n _listExpValues = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataValues()]\n\n #_listExpStdDev = None\n #if self.getDataInput().getExperimentalDataStdDev():\n # _listExpStdDev = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataStdDev()]\n #if _listExpStdDev:\n # pylab.errorbar(_listExpQ, _listExpValues, yerr=_listExpStdDev, linestyle='None', marker='o', markersize=1, label=\"Experimental Data\")\n # pylab.gca().set_yscale(\"log\", nonposy='clip')\n #else: \n # pylab.semilogy(_listExpQ, _listExpValues, linestyle='None', marker='o', markersize=5, label=\"Experimental Data\")\n\n pylab.semilogy(_listExpQ, _listExpValues, linestyle='None', marker='o', markersize=5, label=\"Experimental Data\")\n pylab.semilogy(_listFitQ, _listFitValues, label=\"Fitting curve\")\n pylab.xlabel('q')\n pylab.ylabel('I(q)')\n pylab.suptitle(\"RMax : %3.2f. Fit quality : %1.3f\" % (self.getDataInput().getRMax().getValue(), self.getDataOutput().getFitQuality().getValue()))\n pylab.legend()\n pylab.savefig(os.path.join(self.getWorkingDirectory(), \"gnomFittingResults.png\"))\n pylab.clf()","def plot_results(\n data,\n xparam,\n yparam,\n pxrange=None,\n pyrange=None,\n data_comp=None,\n data_bohlin=None,\n figsize=None,\n alpha=0.25,\n):\n # set the plotting defaults\n set_params(lw=2, fontsize=22)\n\n fig, ax = plt.subplots(figsize=figsize)\n\n if data_bohlin is not None:\n if (xparam in data_bohlin.colnames) and (yparam in data_bohlin.colnames):\n xcol = data_bohlin[xparam]\n xcol_unc = get_unc(xparam, data_bohlin)\n ycol = data_bohlin[yparam]\n ycol_unc = get_unc(yparam, data_bohlin)\n ax.errorbar(\n xcol,\n ycol,\n xerr=xcol_unc,\n yerr=ycol_unc,\n fmt=\"ro\",\n label=\"Bohlin (1978)\",\n alpha=alpha,\n )\n if data_comp is not None:\n xcol = data_comp[xparam]\n xcol_unc = get_unc(xparam, data_comp)\n ycol = data_comp[yparam]\n ycol_unc = get_unc(yparam, data_comp)\n # ax.errorbar(xcol, ycol, xerr=xcol_unc, yerr=ycol_unc,\n # fmt='go', label='FUSE Comparisons', alpha=0.25)\n ax.plot(xcol, ycol, \"go\")\n # plot the error bars as ellipses illustrating the covariance\n corrs = get_corr(\n xparam,\n yparam,\n xcol,\n ycol,\n xcol_unc,\n ycol_unc,\n cterm=data_comp[\"AV\"].data,\n cterm_unc=data_comp[\"AV_unc\"].data,\n )\n plot_errorbar_corr(\n ax, xcol, ycol, xcol_unc, ycol_unc, corrs, alpha=alpha, pcol=\"g\"\n )\n\n xcol = data[xparam].data\n xcol_unc = get_unc(xparam, data)\n ycol = data[yparam].data\n ycol_unc = get_unc(yparam, data)\n # ax.errorbar(xcol, ycol, xerr=xcol_unc, yerr=ycol_unc,\n # fmt='bo', label='FUSE Reddened', alpha=0.25)\n ax.plot(xcol, ycol, \"bo\")\n\n # plot the error bars as ellipses illustrating the covariance\n if yparam[0:3] == \"CAV\":\n cparam = \"AV\"\n elif yparam[0:1] == \"C\":\n cparam = \"EBV\"\n else:\n cparam = \"AV\"\n\n corrs = get_corr(\n xparam,\n yparam,\n xcol,\n ycol,\n xcol_unc,\n ycol_unc,\n cterm=data[cparam].data,\n cterm_unc=data[cparam + \"_unc\"].data,\n )\n plot_errorbar_corr(\n ax, xcol, ycol, xcol_unc, ycol_unc, corrs, alpha=alpha, pcol=\"b\", pellipse=True\n )\n\n ax.set_xlabel(format_colname(xparam))\n ax.set_ylabel(format_colname(yparam))\n\n # fit a line\n # params = np.polyfit(xcol, ycol, 1) # , w=1.0/ycol_unc)\n # line_init = models.Polynomial1D(1)\n line_init = models.Linear1D()\n fit = fitting.LinearLSQFitter()\n # fitter with outlier rejection\n or_fit = fitting.FittingWithOutlierRemoval(fit, sigma_clip, niter=3, sigma=3.0)\n\n # fit the data w/o weights\n fitted_model = fit(line_init, xcol, ycol)\n print(fitted_model)\n\n # fit the data using the uncertainties as weights\n fitted_model_weights = fit(line_init, xcol, ycol, weights=1.0 / ycol_unc)\n\n # fit the data using the uncertainties as weights\n fitted_model_weights_sc, mask_sc = or_fit(line_init, xcol, ycol, weights=1.0 / ycol_unc)\n data_sc = np.ma.masked_array(ycol, mask=mask_sc)\n\n # print(\"linear fit params [slope, y-intercept]\")\n # print(params)\n xlim = ax.get_xlim()\n x_mod = np.linspace(xlim[0], xlim[1])\n # y_mod = params[1] + x_mod * params[0]\n # ax.plot(x_mod, y_mod, \"k--\")\n\n ax.plot(x_mod, fitted_model(x_mod), \"k-\")\n ax.plot(x_mod, fitted_model_weights(x_mod), \"k--\")\n ax.plot(x_mod, fitted_model_weights_sc(x_mod), \"k.\")\n\n ax.plot(xcol, data_sc, 'ko')\n print(data_sc)\n\n if pxrange is not None:\n ax.set_xlim(pxrange)\n if pyrange is not None:\n ax.set_ylim(pyrange)\n\n return fig","def P_AI_Rocky2(in_dict):\n # START\n fs = 16\n plt.rc('font', size=fs)\n fig = plt.figure(figsize=(8,12))\n ds = nc.Dataset(in_dict['fn'])\n\n # PLOT CODE\n aa = [-122.8, -122.54, 47.92, 48.22]\n # import cmocean\n # cmap = cmocean.cm.speed\n # cmap = 'RdYlBu_r'\n cmap = 'Spectral_r'\n\n from warnings import filterwarnings\n filterwarnings('ignore') # skip some warning messages\n \n # plot Code\n \n # calculate speed\n uu = ds['u'][0, -1, :, :]\n vv = ds['v'][0, -1, :, :]\n u = zfun.fillit(uu)\n v = zfun.fillit(vv)\n u[np.isnan(u)] = 0\n v[np.isnan(v)] = 0\n # interpolate to the clipped rho grid\n ur = (u[1:-1,1:] + u[1:-1,:-1])/2\n vr = (v[1:,1:-1] + v[:-1,1:-1])/2\n spd = np.sqrt(ur**2 + vr**2)\n spd[spd==0] = np.nan\n \n G = zrfun.get_basic_info(in_dict['fn'], only_G=True)\n \n # panel 1\n ax = fig.add_subplot(111)\n cs = plt.pcolormesh(G['lon_psi'], G['lat_psi'], spd, cmap=cmap,\n vmin=0, vmax=1.5)\n tstr = (r'Admiralty Inlet Surface Speed ($m\\ s^{-1}$)')\n #pfun.add_bathy_contours(ax, ds, txt=True)\n pfun.add_coast(ax)\n ax.axis(aa)\n pfun.dar(ax)\n ax.set_xlabel('Longitude')\n ax.set_ylabel('Latitude')\n ax.set_title(tstr)\n pfun.add_info(ax, in_dict['fn'])\n ax.set_xticks([-122.8, -122.7, -122.6])\n ax.set_yticks([48, 48.1, 48.2])\n \n # Inset colorbar\n from mpl_toolkits.axes_grid1.inset_locator import inset_axes\n cbaxes = inset_axes(ax, width=\"4%\", height=\"30%\", loc='upper right', borderpad=3)\n fig.colorbar(cs, cax=cbaxes, orientation='vertical')\n \n #pfun.add_bathy_contours(ax, ds)\n pfun.add_coast(ax)\n ax.axis(aa)\n pfun.dar(ax)\n ax.set_xlabel('Longitude')\n ax.set_title(tstr)\n \n pfun.add_velocity_vectors(ax, ds, in_dict['fn'], v_scl=100, v_leglen=1,\n nngrid=80, zlev='top', center=(.1,.05))\n \n fig.tight_layout()\n # FINISH\n ds.close()\n if len(in_dict['fn_out']) > 0:\n plt.savefig(in_dict['fn_out'])\n plt.close()\n else:\n plt.show()\n plt.rcdefaults()","def plot_run_basic():\n # Define files prefix, model variables to plot and title\n str_learning_rate = ['lr_', 'learning_rate', 'Learning rate', 'LR']\n str_f_number = ['f_', 'F', 'Filter number', 'F']\n str_regular = ['reg_param_', 'reg_par', 'Regularization', 'RP']\n\n fig = plt.figure(figsize=(16,12))\n # Plot learning rate\n acc_span, acc_tot, setting_val = CNN.get_acc_run_basic(str_learning_rate[0], str_learning_rate[1])\n CNN.subplot_run_basic(acc_span, acc_tot, setting_val, str_learning_rate[2], str_learning_rate[3], [2,2,1])\n # Plot F number\n acc_span, acc_tot, setting_val = CNN.get_acc_run_basic(str_f_number[0], str_f_number[1])\n CNN.subplot_run_basic(acc_span, acc_tot, setting_val, str_f_number[2], str_f_number[3], [2,2,2])\n # Plot Regularization\n acc_span, acc_tot, setting_val = CNN.get_acc_run_basic(str_regular[0], str_regular[1])\n CNN.subplot_run_basic(acc_span, acc_tot, setting_val, str_regular[2], str_regular[3], [2,2,3])\n plt.suptitle('Validation accuracy - Sweep parameters', fontsize=20)\n plt.show();\n \n # Save as PDF file if wanted\n if DataLoader.SAVE_FIGURE:\n DataLoader.save_plot(fig, 'sweep_parameters_CNN.pdf')","def plotResults(times, result, args, calculate_nT = True, order_SD = False, nSkipp = 1, showProgress = False):\n t1 = time.time()\n times = times[::nSkipp]\n\n if 'omegaArgs' in args:\n wList = args['omega'](times, args['omegaArgs'])\n fList = args['f0']/wList**2 - args['f0']/args['omegaArgs'][0]**2\n else:\n wList = args['omega'](times, args)\n fList = args['f0']/wList**2 - args['f0']/args['w0']**2\n\n masterList = [[],[],[],[]]\n nStates = len(result.states[::nSkipp])\n progress = 0\n for psi in result.states[::nSkipp]:\n alpha, xi, nBar, nT = getParams(psi, calculate_nT = calculate_nT, order_SD = order_SD)\n masterList[0].append(np.abs(alpha))\n masterList[1].append(np.abs(xi))\n masterList[2].append(nBar)\n masterList[3].append(nT)\n if showProgress:\n progress += 1\n print('\\r', \"Progress:\", round(100*progress/nStates), \"%, processing time:\", round(time.time() - t1), \"s\", end = '')\n\n fig, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(5)\n fig.set_size_inches(15.5, 7.5, forward=True)\n ax1.plot(times, masterList[0], label = r'$|\\alpha |$')\n ax1.legend()\n ax2.plot(times, masterList[1], label = \"r\")\n ax2.legend()\n ax3.plot(times, masterList[2], label = \"nBar\")\n if calculate_nT:\n ax3.plot(times, masterList[3], label = \"nT\")\n ax3.legend()\n ax4.plot(times, wList, label = \"w(t)\")\n ax4.legend()\n ax5.plot(times, fList, label = r'$10^{-15} F/\\hbar$ in N/(Js)')\n ax5.legend()\n plt.show()\n return(0)","def plot_morphism_output(data, outdir):\n\n # show the distributions for each variable separately\n for col in data.columns:\n ProfilePlotter._plot_1d(data[col], outfile = os.path.join(outdir, col + \".pdf\"))\n\n # later, maybe also show 2d plots etc.","def plot_brute_leastsquares_results(result, best_vals=True, varlabels=None,\r\n output=None, leastsq_fit_result=None):\r\n from matplotlib.colors import LogNorm\r\n import matplotlib.cm as cm\r\n \r\n npars = len(result.var_names)\r\n _fig, axes = plt.subplots(npars, npars)\r\n\r\n if not varlabels:\r\n varlabels = result.var_names\r\n if best_vals and isinstance(best_vals, bool):\r\n best_vals = result.params\r\n if leastsq_fit_result is not None:\r\n best_vals_leastsq = leastsq_fit_result.params\r\n\r\n for i, par1 in enumerate(result.var_names):\r\n for j, par2 in enumerate(result.var_names):\r\n\r\n # parameter vs chi2 in case of only one parameter\r\n if npars == 1:\r\n axes.plot(result.brute_grid, result.brute_Jout, 'o', ms=3)\r\n axes.set_ylabel(r'$\\chi^{2}$')\r\n axes.set_xlabel(varlabels[i])\r\n if best_vals:\r\n axes.axvline(best_vals[par1].value, ls='dashed', color='b')\r\n if best_vals_leastsq:\r\n axes.axvline(best_vals_leastsq[par1].value, ls='dashed', color='r')\r\n\r\n # parameter vs chi2 profile on top\r\n elif i == j and j < npars-1:\r\n if i == 0:\r\n axes[0, 0].axis('off')\r\n ax = axes[i, j+1]\r\n red_axis = tuple([a for a in range(npars) if a != i])\r\n ax.plot(np.unique(result.brute_grid[i]),\r\n np.minimum.reduce(result.brute_Jout, axis=red_axis),\r\n 'o', ms=3)\r\n ax.set_ylabel(r'$\\chi^{2}$')\r\n ax.yaxis.set_label_position(\"right\")\r\n ax.yaxis.set_ticks_position('right')\r\n ax.set_xticks([])\r\n if best_vals:\r\n ax.axvline(best_vals[par1].value, ls='dashed', color='b')\r\n if best_vals_leastsq:\r\n ax.axvline(best_vals_leastsq[par1].value, ls='dashed', color='r')\r\n # parameter vs chi2 profile on the left\r\n elif j == 0 and i > 0:\r\n ax = axes[i, j]\r\n red_axis = tuple([a for a in range(npars) if a != i])\r\n ax.plot(np.minimum.reduce(result.brute_Jout, axis=red_axis),\r\n np.unique(result.brute_grid[i]), 'o', ms=3)\r\n ax.invert_xaxis()\r\n ax.set_ylabel(varlabels[i])\r\n if i != npars-1:\r\n ax.set_xticks([])\r\n else:\r\n ax.set_xlabel(r'$\\chi^{2}$')\r\n if best_vals:\r\n ax.axhline(best_vals[par1].value, ls='dashed', color='b')\r\n if best_vals_leastsq:\r\n ax.axhline(best_vals_leastsq[par1].value, ls='dashed', color='r')\r\n\r\n # contour plots for all combinations of two parameters\r\n elif j > i:\r\n ax = axes[j, i+1]\r\n red_axis = tuple([a for a in range(npars) if a not in (i, j)])\r\n X, Y = np.meshgrid(np.unique(result.brute_grid[i]),\r\n np.unique(result.brute_grid[j]))\r\n lvls1 = np.linspace(result.brute_Jout.min(),\r\n np.median(result.brute_Jout)/2.0, 20, dtype='int')\r\n lvls2 = np.linspace(np.median(result.brute_Jout)/2.0,\r\n np.median(result.brute_Jout), 20, dtype='int')\r\n \r\n lvls = np.unique(np.concatenate((lvls1, lvls2)))\r\n \r\n ax.contourf(X.T, Y.T, np.minimum.reduce(result.brute_Jout, axis=red_axis),\r\n lvls, norm=LogNorm(),\r\n cmap=cm.nipy_spectral)\r\n ax.set_yticks([])\r\n if best_vals:\r\n ax.axvline(best_vals[par1].value, ls='dashed', color='b')\r\n ax.axhline(best_vals[par2].value, ls='dashed', color='b')\r\n ax.plot(best_vals[par1].value, best_vals[par2].value, 'bs', ms=3)\r\n if best_vals_leastsq:\r\n ax.axvline(best_vals_leastsq[par1].value, ls='dashed', color='r')\r\n ax.axhline(best_vals_leastsq[par2].value, ls='dashed', color='r')\r\n ax.plot(best_vals_leastsq[par1].value, best_vals_leastsq[par2].value, 'rs', ms=3)\r\n if j != npars-1:\r\n ax.set_xticks([])\r\n else:\r\n ax.set_xlabel(varlabels[i])\r\n if j - i >= 2:\r\n axes[i, j].axis('off')\r\n\r\n if output is not None:\r\n plt.savefig(output)\r\n else: \r\n plt.tight_layout()\r\n plt.show()","def visualize_cross_validation_results(cross_val_results, plots_filepath):\n\n pair_model_scores, pair_model_stds, \\\n siamese_model_scores_2, siamese_model_stds_2, \\\n siamese_model_scores_10, siamese_model_stds_10 = cross_val_results\n param_names = (\"NBCH1\", \"NBCH2\", \"NBFCH\", \"BATCH_NORM\", \"SKIP_CON\", \"LR\")\n\n def aggregate_results(scores, stds):\n \"\"\"\n Helper function to aggregate score means and standard deviations for a model across parameter values\n\n :param scores: dictionary of score means {param_combo: score_mean}\n :param stds: dictionary of score stds {param_combo: score_std}\n\n :returns: list of tuples of pandas.Dataframe objects containing aggregated mean and std data\n \"\"\"\n\n scores = pd.DataFrame(scores.values(),\n index=scores.keys(),\n columns=[\"SCORE MEAN\", ])\n stds = pd.DataFrame(stds.values(),\n index=stds.keys(),\n columns=[\"SCORE STD\", ])\n scores.index.name = param_names\n stds.index.name = param_names\n data = []\n for param_gropby_levels in ((0,), (1,), (2,), (3, 4), (5,)):\n aggregate_scores = scores.groupby(level=param_gropby_levels).mean()\n aggregate_stds = scores.groupby(level=param_gropby_levels).std()\n data.append((aggregate_scores, aggregate_stds))\n return data\n\n pair_model_data = aggregate_results(pair_model_scores, pair_model_stds)\n siamese_model_2_data = aggregate_results(siamese_model_scores_2, siamese_model_stds_2)\n siamese_model_10_data = aggregate_results(siamese_model_scores_10, siamese_model_stds_10)\n\n # Group results for all models\n model_names = (\"Pair\", \"Siamese 2\", \"Siamese 10\")\n grouped_data = []\n for pair_model_group_data, siamese_model_2_group_data, siamese_model_10_group_data in zip(pair_model_data,\n siamese_model_2_data,\n siamese_model_10_data):\n score_means = (pair_model_group_data[0], siamese_model_2_group_data[0], siamese_model_10_group_data[0])\n score_mean_data = pd.concat(score_means, axis=1)\n score_mean_data.columns = model_names\n\n score_stds = (pair_model_group_data[1], siamese_model_2_group_data[1], siamese_model_10_group_data[1])\n score_std_data = pd.concat(score_stds, axis=1)\n score_std_data.columns = model_names\n\n grouped_data.append((score_mean_data, score_std_data))\n\n plots_param_names = (\"nbch1\", \"nbch2\", \"nbfch\", \"batch_norm+skip_con\", \"lr\")\n for i, (plot_param_names, (score_mean_data, score_std_data)) in enumerate(zip(plots_param_names, grouped_data)):\n plt.figure(figsize=(10, 5))\n score_mean_data.plot(kind=\"line\" if plot_param_names == \"lr\" else \"bar\",\n yerr=score_std_data,\n capsize=5,\n ylim=(0.4, 1.1),\n colormap=colormap_brg_darker)\n plt.title(\"Cross validation results for parameters:\\n{}\".format(plot_param_names), fontsize=18)\n plt.xlabel(\"Parameter value\", fontsize=14)\n plt.ylabel(\"Average accuracy\", fontsize=14)\n plt.xticks(fontsize=12, rotation=30)\n plt.yticks(fontsize=12)\n plt.legend(title=\"Model\", title_fontsize=10)\n plt.tight_layout()\n plt.savefig(fname=plots_filepath + \"cross_validation_{}.eps\".format(plot_param_names),\n dpi=\"figure\", format=\"eps\")\n plt.close()","def plot_dataset(\n self,\n out_dir: str = None,\n therm_frac: int = 0.,\n num_chains: int = None,\n ridgeplots: bool = True,\n profile: bool = False,\n ):\n tdict = {}\n dataset = self.get_dataset(therm_frac)\n for key, val in dataset.data_vars.items():\n t0 = time.time()\n if np.std(val.values.flatten()) < 1e-2:\n continue\n\n if len(val.shape) == 2: # shape: (chain, draw)\n val = val[:num_chains, :]\n\n if len(val.shape) == 3: # shape: (chain, leapfrogs, draw)\n val = val[:num_chains, :, :]\n\n fig, ax = plt.subplots(constrained_layout=True, figsize=set_size())\n _ = val.plot(ax=ax)\n if out_dir is not None:\n io.check_else_make_dir(out_dir)\n out_file = os.path.join(out_dir, f'{key}_xrPlot.png')\n fig.savefig(out_file, dpi=400, bbox_inches='tight')\n plt.close('all')\n plt.clf()\n\n if profile:\n tdict[key] = time.time() - t0\n io.log(f'time spent plotting {key}: {tdict[key]}')\n\n if out_dir is not None:\n out_dir = os.path.join(out_dir, 'ridgeplots')\n io.check_else_make_dir(out_dir)\n\n if ridgeplots:\n make_ridgeplots(dataset, num_chains=num_chains, out_dir=out_dir)\n\n return tdict","def surface_plot(name: str = 'start_date_analysis1.pkl'):\n df = pd.read_pickle(name)\n\n # set up a figure twice as wide as it is tall\n fig = plt.figure(figsize=plt.figaspect(0.5))\n # ===============\n # First subplot\n # ===============\n # set up the axes for the first plot\n ax = fig.add_subplot(1, 2, 1, projection='3d')\n ax.set_title('Modifications per File')\n ax.set_xlabel('Date (Months)')\n ax.set_ylabel('Threshold Individual')\n for idx, row in enumerate(sorted(df['threshold_pairs'].unique())):\n data = df[df['threshold_pairs'] == row]\n label = 'Threshold pairs ' + str(row)\n # Plot the surface.\n surf = ax.plot_trisurf(data['date'], data['threshold'], data['mpf'], alpha=0.7,\n linewidth=0, antialiased=False, label=label)\n surf._facecolors2d = surf._facecolors3d\n surf._edgecolors2d = surf._edgecolors3d\n # ===============\n # Second subplot\n # ===============\n # set up the axes for the second plot\n ax = fig.add_subplot(1, 2, 2, projection='3d')\n ax.set_title('Transitions per Test')\n ax.set_xlabel('Date (Months)')\n ax.set_ylabel('Threshold Individual')\n for idx, row in enumerate(sorted(df['threshold_pairs'].unique())):\n data = df[df['threshold_pairs'] == row]\n label = 'Threshold pairs ' + str(row)\n # Plot the surface.\n\n surf = ax.plot_trisurf(data['date'], data['threshold'], data['tpt'], alpha=0.7,\n linewidth=0, antialiased=False, label=label)\n\n surf._facecolors2d = surf._facecolors3d\n surf._edgecolors2d = surf._edgecolors3d\n\n # cbar = fig.colorbar(surf)\n # cbar.locator = LinearLocator(numticks=10)\n # cbar.update_ticks()\n\n plt.suptitle('Threshold Start Date Analysis 3D', fontsize=14)\n plt.legend()\n plt.show()","def plot_modelparametercollections(plotname, parametercollection_SF, parametercollection_AGN,\n stat_SF, stat_AGN, AGNcol='blue',SFcol='red', constraintsstr=None,\n fluxratiodictionarylist=None, verbose=True):\n\n Nobj = len(parametercollection_SF)\n if verbose: print(' - Will generate plots of NEOGAL \"PDFs\" for all '+str(Nobj)+' objects in parameter collections')\n for oo in np.arange(Nobj):\n objid = parametercollection_SF[oo]['id']\n if verbose:\n infostr = ' plotting info for '+str(objid)+' ('+str(\"%.5d\" % (oo+1))+' / '+str(\"%.5d\" % Nobj)+') '\n sys.stdout.write(\"%s\\r\" % infostr)\n sys.stdout.flush()\n plotname_obj = plotname.replace('.pdf','_id'+str(objid)+'.pdf')\n # if verbose: print(' - Generating the figure '+plotname_obj)\n figuresize_x = 6\n figuresize_y = 5\n fig = plt.figure(figsize=(figuresize_x,figuresize_y))\n Fsize = 9\n LW = 2\n plt.rc('text', usetex=True) # enabling LaTex rendering of text\n plt.rc('font', family='serif',size=Fsize) # setting text font\n plt.rc('xtick', labelsize=Fsize)\n plt.rc('ytick', labelsize=Fsize)\n plt.clf()\n plt.ioff()\n\n left = 0.10 # the left side of the subplots of the figure\n right = 0.95 # the right side of the subplots of the figure\n bottom = 0.10 # the bottom of the subplots of the figure\n top = 0.90 # the top of the subplots of the figure\n wspace = 1.50 # the amount of width reserved for blank space between subplots\n hspace = 0.50 # the amount of height reserved for white space between subplots\n plt.subplots_adjust(left=left, bottom=bottom, right=right, top=top, wspace=wspace, hspace=hspace)\n\n Nrows, Ncols = 3, 6\n ylabel = 'Number of NEOGAL SF ('+str(SFcol)+') and AGN ('+str(AGNcol)+') models'\n\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n Nmodels_SF = float(len(parametercollection_SF[oo]['Zgas']))\n Nmodels_AGN = float(len(parametercollection_AGN[oo]['Zgas']))\n\n titlestr = 'Models satisfying ID='+str(objid)+' cuts: SF='+str(Nmodels_SF)+'; AGN='+str(Nmodels_AGN)\n if (Nmodels_AGN > 0) & (Nmodels_SF > 0):\n Nmodels_ratio = Nmodels_SF/Nmodels_AGN\n titlestr_addition = '; SF/AGN='+str(\"%.4f\" % Nmodels_ratio)\n titlestr = titlestr+titlestr_addition\n\n if fluxratiodictionarylist is not None:\n constraints = fluxratiodictionarylist[oo]\n constraintslist = [key+':['+str(\"%.2f\" % constraints[key][0])+','+str(\"%.2f\" % constraints[key][1])+']'\n for key in constraints.keys() if key not in ['id']]\n\n if len(constraintslist) < 4:\n constraintsstr = '; '.join(constraintslist)\n elif (len(constraintslist) > 3) & (len(constraintslist) < 7):\n constraintsstr = '; '.join(constraintslist[:3])+'\\n'+'; '.join(constraintslist[3:6])\n elif (len(constraintslist) > 6) & (len(constraintslist) < 10):\n constraintsstr = '; '.join(constraintslist[:3])+'\\n'+'; '.join(constraintslist[3:6])+\\\n '\\n'+'; '.join(constraintslist[6:])\n else:\n constraintsstr = '; '.join(constraintslist[:3])+'\\n'+'; '.join(constraintslist[3:6])+\\\n '\\n'+'; '.join(constraintslist[6:9])+'\\n'+'; '.join(constraintslist[9:])\n\n constraintsstr = constraintsstr.replace('10000000000.00','1e10')\n\n titlestr = titlestr+'\\n'+constraintsstr\n # titlestr = r'{\\fontsize{'+str(Fsize)+'pt}{3em}\\selectfont{}{'+titlestr+'\\r}{\\fontsize{'+str((Fsize-2.))+'pt}{3em}\\selectfont{}('+constraintsstr+'}'\n\n # plt.text(x=0.5, y=0.94, s=titlestr, fontsize=Fsize, ha=\"center\", transform=fig.transFigure)\n # plt.text(x=0.5, y=0.88, s=constraintsstr, fontsize=Fsize-2, ha=\"center\", transform=fig.transFigure)\n # fig.title(titlestr,fontsize=Fsize)\n fig.suptitle(titlestr,fontsize=Fsize-2)\n\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n # Zgas\n plt.subplot(Nrows, Ncols, (1,3))\n\n bindefs = np.array([0.0001, 0.0002, 0.0005, 0.001, 0.002, 0.004, 0.006, 0.008, 0.014,\n 0.017, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07])-0.00001\n\n plotkey = 'Zgas'\n nm.plot_modelparametercollections_addhist(parametercollection_SF[oo][plotkey],parametercollection_AGN[oo][plotkey],\n stat_SF[oo][plotkey],stat_AGN[oo][plotkey],\n SFcol,AGNcol,LW,bindefs=bindefs,Nbins=None)\n\n plt.xscale('log')\n plt.xlabel(nm.keylabels(plotkey))\n plt.xlim([0.00001,0.1])\n\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n # logUs\n plt.subplot(Nrows, Ncols, (4,6))\n\n bindefs = np.arange(-4.75, -0.25, 0.5)\n\n plotkey = 'logUs'\n nm.plot_modelparametercollections_addhist(parametercollection_SF[oo][plotkey],parametercollection_AGN[oo][plotkey],\n stat_SF[oo][plotkey],stat_AGN[oo][plotkey],\n SFcol,AGNcol,LW,bindefs=bindefs,Nbins=None)\n\n plt.xlabel(nm.keylabels(plotkey))\n plt.xlim([-5,-0.5])\n\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n # xid\n plt.subplot(Nrows, Ncols, (7,9))\n\n bindefs = np.array([0.0, 0.2, 0.4, 0.6])\n\n plotkey = 'xid'\n nm.plot_modelparametercollections_addhist(parametercollection_SF[oo][plotkey],parametercollection_AGN[oo][plotkey],\n stat_SF[oo][plotkey],stat_AGN[oo][plotkey],\n SFcol,AGNcol,LW,bindefs=bindefs,Nbins=None)\n\n plt.xlabel(nm.keylabels(plotkey))\n plt.xlim([-0.05,0.65])\n plt.ylabel(ylabel)\n\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n # nh\n plt.subplot(Nrows, Ncols, (10,12))\n\n bindefs = 10**np.array([1.5, 2.5, 3.5, 4.5])\n\n plotkey = 'nh'\n nm.plot_modelparametercollections_addhist(parametercollection_SF[oo][plotkey],parametercollection_AGN[oo][plotkey],\n stat_SF[oo][plotkey],stat_AGN[oo][plotkey],\n SFcol,AGNcol,LW,bindefs=bindefs,Nbins=None)\n plt.xscale('log')\n plt.xlabel(nm.keylabels(plotkey))\n plt.xlim([10,1e5])\n\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n # COCOsol\n plt.subplot(Nrows, Ncols, (13,14))\n\n #bindefs = np.array([0.10, 0.14, 0.20, 0.27, 0.38, 0.52, 0.72, 1.00, 1.40])\n bindefs = np.arange(0.05,1.5,0.06)\n\n plotkey = 'COCOsol'\n nm.plot_modelparametercollections_addhist(parametercollection_SF[oo][plotkey],None,\n stat_SF[oo][plotkey],None,\n SFcol,AGNcol,LW,bindefs=bindefs,Nbins=None)\n\n plt.xlabel(nm.keylabels(plotkey))\n plt.xlim([0.00,1.55])\n\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n # mup\n plt.subplot(Nrows, Ncols, (15,16))\n\n bindefs = np.array([0,200,400])\n\n plotkey = 'mup'\n nm.plot_modelparametercollections_addhist(parametercollection_SF[oo][plotkey],None,\n stat_SF[oo][plotkey],None,\n SFcol,AGNcol,LW,bindefs=bindefs,Nbins=None)\n\n plt.xlabel(nm.keylabels(plotkey))\n plt.xlim([-10,410])\n\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n # alpha\n plt.subplot(Nrows, Ncols, (17,18))\n\n bindefs = np.array([-2.15,-1.85,-1.55,-1.25,-0.95])\n\n plotkey = 'alpha'\n Nbins = 10\n nm.plot_modelparametercollections_addhist(None,parametercollection_AGN[oo][plotkey],\n None,stat_AGN[oo][plotkey],\n SFcol,AGNcol,LW,bindefs=None,Nbins=Nbins)\n\n plt.xlabel(nm.keylabels(plotkey))\n plt.xlim([-2.2,-0.9])\n\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n plt.savefig(plotname_obj)\n plt.clf()\n plt.close('all')\n # if verbose: print(' - Successfully saved figure to file')\n if verbose: print('\\n done...')","def plot_optimal_tau(results_for_exp, results_for_exp_inftau):\n values = sp.empty((results_for_exp.shape[0], results_for_exp.shape[1]))\n err = sp.empty((results_for_exp.shape[0], results_for_exp.shape[1], 2, 1))\n num_trials = results_for_exp.shape[3]\n for i, l4 in enumerate(cfg['l4_lengths']):\n for j, l2 in enumerate(cfg['l2_lengths']):\n r = [sp.mean(cfg['time_scales'][\n results_for_exp[i, j, :, t] == results_for_exp[i, j, :, t].max()])\n for t in xrange(num_trials)]\n values[i, j] = sp.mean(r)\n err[i, j, 0] = values[i, j] - min(r).magnitude\n err[i, j, 1] = max(r).magnitude - values[i, j]\n plot_param_per_l4_and_l2(values, err)\n plot_bool_indicator_per_l4_and_l2(\n sp.any(results_for_exp_inftau >= results_for_exp.max(axis=2), axis=2))","def result_plotting(n_images,epoch,dataset,result_path,labels,predictions,indices):\n \n coord,connectivity = [],[] # List of prediction and ground truth images\n for k in range(n_images):\n \n or_case = int(np.where(np.array(dataset.data.case)==indices[k])[0][0]) # Get index of case\n \n # Get the coordinate and connectivity data\n coord += [dataset[or_case].coord.numpy()] \n connectivity += [dataset[or_case].connectivity.numpy()]\n\n # Save npz array with the results of this iteration\n np.savez(join(result_path,'Temp.npz'),labels=n(labels),predictions=n(predictions)\n ,indices=n(indices),coord=n(coord),connectivity=n(connectivity))\n\n # Call mesh_plotter to create the figures\n subprocess.call(['python', 'mesh_plotter.py','-p',result_path,'-e',str(epoch),'-ni',str(n_images)])\n \n # Send image for visualization in W&B\n images = wandb.Image(join(result_path,'Result_'+str(epoch).zfill(3)+'.png'),caption = \"Epoch \"+str(epoch))\n wandb.log({\"Prediction\": images})","def magn_plot(names, values, data, model_key, plot_key=False):\n zpicks = data['zpicks']\n\n # Corrected absolute magnitude M of SN.\n M = values[0]\n\n dlpc, da, plot_var = zodesolve.zodesolve(names, values, zpicks, model_key, plot_key)\n\n # Calculating apparent magnitudes of supernovae at the simulated\n # luminosity distances using the distance modulus formula.\n mag = 5 * np.log10(dlpc/10) + M\n z = plot_var['z']\n if model_key == 'waterfall':\n plt.figure()\n plt.title(r'$\\bar \\Omega$ evolution in waterfall')\n plt.xlabel('redshift')\n plt.ylabel(r'$\\bar \\Omega$')\n plt.plot(z, plot_var['ombar_m'], label='ombar_m vs redshift')\n plt.plot(z, plot_var['ombar_r'], label='ombar_r vs redshift')\n plt.plot(z, plot_var['a_ombar'], label='a_ombar vs redshift')\n plt.plot(z, plot_var['b_ombar'], label='b_ombar vs redshift')\n plt.plot(z, plot_var['c_ombar'], label='c_ombar vs redshift')\n plt.plot(z, plot_var['ombar_de'], label='ombar_de vs redshift')\n plt.legend()\n\n sum_om = plot_var['ombar_m'] + plot_var['ombar_r'] + plot_var['a_ombar']+ plot_var['b_ombar'] + plot_var['c_ombar'] + plot_var['c_ombar'] +plot_var['ombar_de']\n om_m = plot_var['ombar_m']/sum_om\n om_r = plot_var['ombar_r']/sum_om\n om_a = plot_var['a_ombar']/sum_om\n om_b = plot_var['b_ombar']/sum_om\n om_c = plot_var['c_ombar']/sum_om\n om_de = plot_var['ombar_de']/sum_om\n\n plt.figure()\n plt.title(r'$\\Omega$ evolution in waterfall')\n plt.xlabel('redshift')\n plt.ylabel(r'$\\Omega$')\n plt.plot(z, om_m, label = 'om_m')\n plt.plot(z, om_r, label = 'om_r')\n plt.plot(z, om_a, label = 'om_a')\n plt.plot(z, om_b, label = 'om_b')\n plt.plot(z, om_c, label = 'om_c')\n plt.plot(z, om_de, label = 'om_de')\n plt.legend()\n plt.show()\n\n elif model_key == 'LCDM':\n plt.figure()\n plt.title(r'$\\bar \\Omega$ evolution in LCDM')\n plt.xlabel('redshift')\n plt.ylabel(r'$\\bar \\Omega$')\n plt.plot(z, plot_var['ombar_m'], label='ombar_m vs redshift')\n plt.plot(z, plot_var['ombar_de'], label='ombar_de vs redshift')\n plt.legend()\n\n sum_om = plot_var['ombar_m'] + plot_var['ombar_de']\n om_m = plot_var['ombar_m']/sum_om\n om_de = plot_var['ombar_de']/sum_om\n\n plt.figure()\n plt.title(r'$\\Omega$ evolution in LCDM')\n plt.xlabel('redshift')\n plt.ylabel(r'$\\Omega$')\n plt.plot(z, om_m, label = 'om_m')\n plt.plot(z, om_de, label = 'om_de')\n plt.legend()\n plt.show()\n\n elif model_key == 'exotic':\n plt.figure()\n plt.title(r'$\\bar \\Omega$ evolution in LCDM')\n plt.xlabel('redshift')\n plt.ylabel(r'$\\bar \\Omega$')\n plt.plot(z, plot_var['ombar_m'], label='ombar_m vs redshift')\n plt.plot(z, plot_var['ombar_r'], label='ombar_r vs redshift')\n plt.plot(z, plot_var['ombar_de'], label='ombar_de vs redshift')\n plt.legend()\n\n sum_om = plot_var['ombar_m'] + plot_var['ombar_r'] + plot_var['ombar_de']\n om_m = plot_var['ombar_m']/sum_om\n om_r = plot_var['ombar_r']/sum_om\n om_de = plot_var['ombar_de']/sum_om\n\n plt.figure()\n plt.title(r'$\\Omega$ evolution in LCDM')\n plt.xlabel('redshift')\n plt.ylabel(r'$\\Omega$')\n plt.plot(z, om_m, label = 'om_m')\n plt.plot(z, om_r, label = 'om_r')\n plt.plot(z, om_de, label = 'om_de')\n plt.legend()\n plt.show()\n\n if plot_key:\n # Plotting evolution of parameters in the model.\n import plots\n plots.modelcheck(mag, zpicks, plot_var, model_key)\n\n return mag","def plane_plots(xpv, ypv, dicti):\n xz = []\n yz = []\n\n for k in dicti:\n for i in range(len(dicti[k])):\n if dicti[k][i][1] == ypv:\n xz.append([dicti[k][i][0], dicti[k][i][2], dicti[k][i][3], dicti[k][i][5]])\n if dicti[k][i][0] == xpv:\n yz.append([dicti[k][i][1], dicti[k][i][2], dicti[k][i][4], dicti[k][i][5]])\n\n xzx, xzz, xzxv, xzzv = zip(*xz)\n yzy, yzz, yzyv, yzzv = zip(*yz)\n\n axv, exv= mean_vel(xzxv, xzz)\n ayv, eyv = mean_vel(yzyv, yzz)\n\n # Changes height values to distance from dermal denticles.\n dfdd = np.array(abs(exp_h_list) - np.amin(abs(exp_h_list)))\n xzz = np.array(abs(np.array(xzz)) - np.amin(abs(np.array(xzz))))\n yzz = np.array(abs(np.array(yzz)) - np.amin(abs(np.array(yzz))))\n\n f, axarr = plt.subplots(2,2, sharey=True)\n\n fig = axarr[0,0].quiver(xzx, xzz, xzxv, xzzv, yzyv)\n # Colour uses yzyv so that it matches the other plot\n axarr[0,0].set_xlabel(\"x\")\n axarr[0,0].set_ylabel(r\"Height from dd ($mm$)\")\n\n axarr[0,1].errorbar(100*axv, dfdd, xerr=100*exv, marker='o', color='g')\n axarr[0,1].plot([0.0, 0.0], [np.amin(dfdd), np.amax(dfdd)], 'k--')\n axarr[0,1].set_xlabel(r\"x-velocity ($\\times 10^{-2}ms^{-1}$)\")\n\n axarr[1,0].quiver(yzy, yzz, yzyv, yzzv, yzyv)\n axarr[1,0].set_xlabel(\"y\")\n axarr[1,0].set_ylabel(r\"Height from dd ($mm$)\")\n\n axarr[1,1].errorbar(100*ayv, dfdd, xerr=100*eyv, marker='o', color='b')\n axarr[1,1].plot([0.0, 0.0], [np.amin(dfdd), np.amax(dfdd)], 'k--')\n axarr[1,1].set_xlabel(r\"y-velocity ($\\times 10^{-2}ms^{-1}$)\")\n\n cax, kw = mpl.colorbar.make_axes([ax for ax in axarr.flat])\n f.colorbar(fig, cax=cax, **kw)\n cbar = mpl.colorbar.ColorbarBase(cax, norm=mpl.colors.Normalize(vmin=-0.1, vmax=0.1))\n cbar.set_clim(-0.1,0.1)\n f.suptitle(r\"$\\mu$-PIV for the %s (%s). Flow direction: %s\" %(shark_species, sample_area,\n flow_direction))\n plt.show()\n\n if w2f:\n write_mean_to_file(dfdd, axv, ayv)\n\n return","def _plot_decomposition(Result,\r\n title,\r\n savepath = False,\r\n savename = False,\r\n ylabel = \"Value\",\r\n xlabel = \"Date\",\r\n dates = False,\r\n test = False,\r\n ):\r\n \r\n fig1 = plt.figure(figsize=(9.3,9.3))\r\n \r\n plt.suptitle(title,fontsize=22,y=1)\r\n \r\n plt.subplot(4,1,1)\r\n plt.plot(Result.observed)\r\n plt.title('Observations',fontsize=18)\r\n if type(dates) != bool: \r\n for d in dates:\r\n plt.axvline(x=d,linestyle =\":\", color ='black')\r\n plt.ylabel(ylabel,fontsize=14)\r\n plt.xlabel(xlabel,fontsize=14)\r\n \r\n \r\n plt.subplot(4,1,2)\r\n plt.plot(Result.trend)\r\n plt.title('Trend',fontsize=18)\r\n if type(dates) != bool: \r\n for d in dates:\r\n plt.axvline(x=d,linestyle =\":\", color ='black')\r\n plt.ylabel(ylabel,fontsize=14)\r\n plt.xlabel(xlabel,fontsize=14)\r\n \r\n plt.subplot(4,1,3)\r\n plt.plot(Result.seasonal)\r\n if type(dates) != bool: \r\n for d in dates:\r\n plt.axvline(x=d,linestyle =\":\", color ='black')\r\n plt.title('Seasonal',fontsize=18)\r\n plt.ylabel(ylabel,fontsize=14)\r\n plt.xlabel(xlabel,fontsize=14)\r\n \r\n plt.subplot(4,1,4)\r\n plt.plot(Result.resid)\r\n if type(dates) != bool: \r\n for d in dates:\r\n plt.axvline(x=d,linestyle =\":\", color ='black')\r\n plt.title('Residuals',fontsize=18)\r\n plt.ylabel(ylabel,fontsize=14)\r\n plt.xlabel(xlabel,fontsize=14)\r\n \r\n fig1.tight_layout(pad=2)\r\n \r\n return fig1","def display(self):\r\n \r\n plt.rcParams['font.size'] = 14\r\n plt.rcParams['axes.linewidth'] = 1.2 # 1.2 for single plot, 0.5 for all 6\r\n plt.rcParams['lines.linewidth'] = 20.0 # Aah, this doesn't work because line width is changed later on\r\n\r\n cwd = os.getcwd() # Gets current working directory.\r\n cwd = cwd.replace('\\\\', '/')\r\n path = cwd + directory # This is the folder all the results are stored in.\r\n \r\n if type(array_element) == str:\r\n dataframes = [file + array_element] # This is to pass a single csv file\r\n else:\r\n dataframes = [file + i for i in array_element] # This is a list so you can pass multiple csv files to be overlayed on the same plot.\r\n\r\n colours = ['black', 'darkred', 'darkmagenta', 'darkturquoise', 'saddlebrown'] # Array of colours for the lines.\r\n\r\n dfE = pd.read_csv(cwd + \"/experimental_data.csv\") # Reads in the experimental data as a pandas dataframe.\r\n\r\n # Rescale the x-axis of the experimental data.\r\n ratio_of_capacities = 272.4 / 338.313338 # experimental maximum capacity / theoretical maximum capacity\r\n dfE[\"x_theo\"] = ratio_of_capacities * dfE[\"x\"]\r\n # 'x' is the experimental x and 'x_theo' is the theoretical x.\r\n\r\n # Second derivative of enthalpy for experimental data. One w/ respect to the experimental x and one w/ respect to theoretical x.\r\n secder_enthalpy_experimental_x = np.gradient(np.array(dfE['Enthalpy dH/dx']), np.array(dfE['x']))\r\n secder_enthalpy_experimental_x_theo = np.gradient(np.array(dfE['Enthalpy dH/dx']), np.array(dfE['x_theo']))\r\n dfE['secder enthalpy x'] = secder_enthalpy_experimental_x\r\n dfE['secder enthalpy x theo'] = secder_enthalpy_experimental_x_theo\r\n\r\n # vertical shift on p.m. entropy for vibrational effect\r\n vibrational_shift = 0.0108 # eV K this includes being multiplied by the ratio of capacities.\r\n dfE[\"Entropy dS/dx\"] = (dfE[\"Entropy dS/dx\"]) - vibrational_shift\r\n\r\n # Integrates the p.m. entropy\r\n entropy_list_experimental = integrate.cumtrapz(dfE['Entropy dS/dx'], dfE['x'],\r\n initial=0) # Contains the entropy values\r\n dfE['Entropy'] = entropy_list_experimental\r\n\r\n dfE['x_new'] = ((dfE['x_theo'] - dfE['x_theo'].iloc[0]) * dfE['x_theo'][73]) / (dfE['x_theo'][73] - dfE['x_theo'].iloc[0]) # Rescales the line so that the experimental data starts at 0.\r\n dfE['x'] = ((dfE['x'] - dfE['x'].iloc[0]) * dfE['x'][73]) / (dfE['x'][73] - dfE['x'].iloc[0]) # Same as above but for experimental x axis.\r\n\r\n # Calculates the analytical solution\r\n points = 1000\r\n x_pos = np.linspace(0, 1, points) # x for p.m. entropy\r\n y_pos = np.linspace(0, 1, points) # y for p.m. etropy\r\n s_x = np.linspace(0, 1, points) # x for entropy\r\n s_y = np.linspace(0, 1, points) # y for entropy\r\n l = 0.329217689 # This must be the same as what was used in the main script\r\n R = -0.0000862 # eV/K.Site\r\n T = 288 # K\r\n for index, x in enumerate(x_pos):\r\n if x < l:\r\n s_y[index] = (R * (x * np.log(x / l) - (x - l) * np.log((l - x) / l))) * T\r\n y_pos[index] = T * R * (np.log(x / l) - np.log((l - x) / l))\r\n else:\r\n s_y[index] = (R * l * (\r\n (x / l - 1) * np.log(x / l - 1) + (1 - x) / l * np.log((1 - x) / l) - (1 - l) / l * np.log(\r\n (1 - l) / l))) * T\r\n y_pos[index] = T * R * (np.log(x / l - 1) - np.log(1 / l - x / l))\r\n\r\n # Calculates the single solid state entropy\r\n x_ent = np.linspace(0, 1, points)\r\n y_ent = np.linspace(0, 1, points)\r\n for index, x in enumerate(x_ent):\r\n y_ent[index] = T * R * (x * np.log(x) + (1-x) * np.log(1-x))\r\n \r\n \"\"\"\r\n #\r\n #\r\n # Create plot and formats\r\n #\r\n #\r\n \"\"\"\r\n \r\n fig, axes = plt.subplots(nrows=num_row, ncols=num_col, constrained_layout=True, squeeze=False)\r\n # squeeze=False is needed to prevent errors when plotting a single subplot\r\n plt.rc('legend', fontsize=13, handlelength=1)\r\n plt.rc('tick')\r\n lw = 1.5 # Line width\r\n \r\n plt.tick_params(bottom=True, top=True, left=True, right=True)\r\n plt.tick_params(labelbottom=True, labeltop=False, labelleft=True, labelright=False)\r\n plt.tick_params(direction='in', width=1.2, length=4.5, pad=3) # For single plot\r\n # plt.tick_params(direction='in', width=1, length=4.5, pad=3) # For multiple plots\r\n\r\n marker_list = ['v', '^', 'p', 'o']\r\n mark_size = 3 #0.7 for 6 plots\r\n \r\n colours = ['#176ba0', '#af4bce', 'orangered', '#48a11b', '#3caea3'] #'#af4bce'\r\n common_legend = ['400 Averaging Steps', '800 Averaging Steps', '2000 Averaging Steps']\r\n \r\n if num_col==2 and num_row==3: # This will work when using the original axes dimensions (3 rows, 2 columns)\r\n placement = dict([\r\n ('voltage', axes[0, 0]),\r\n ('dS/dx', axes[0, 1]),\r\n ('dQ/dV', axes[1, 0]),\r\n ('dH/dx', axes[1, 1]),\r\n ('S', axes[2, 0]),\r\n ('d/dx(dH/dx)', axes[2, 1])\r\n ])\r\n else: # If axes dimensions are different, I'm probably trying to plot one graph\r\n \"\"\"\r\n If plotting more than one graph, the position on the plot in the subplot can be adjusted\r\n by appropriately altering the axes[] parameter. For the graphs that are not being plotted, \r\n leave their position as axes[0, 0].\r\n \"\"\"\r\n placement = dict([\r\n ('voltage', axes[0, 0]),\r\n ('dS/dx', axes[0, 0]),\r\n ('dQ/dV', axes[0, 0]),\r\n ('dH/dx', axes[0, 0]),\r\n ('S', axes[0, 0]),\r\n ('d/dx(dH/dx)', axes[0, 0])\r\n ])\r\n \r\n # Plots all of the experimental data\r\n if experimental_plot == True:\r\n if pick_plot['voltage'] == True:\r\n dfE.plot(linestyle='-', color='darkgreen', lw=lw, ax=placement['voltage'], x='x_new', y='OCV')\r\n dfE.plot(linestyle='-', color='darkblue', lw=lw, ax=placement['voltage'], x='x', y='OCV')\r\n \r\n if pick_plot['dS/dx'] == True:\r\n ax2 = dfE.plot(linestyle='-', color='darkgreen', lw=lw, ax=placement['dS/dx'], x='x_new', y='Entropy dS/dx')\r\n dfE.plot(linestyle='-', color='darkblue', lw=lw, ax=placement['dS/dx'], x='x', y='Entropy dS/dx')\r\n \r\n if pick_plot['dQ/dV'] == True:\r\n dfE.plot(linestyle='-', color='darkgreen', lw=lw, ax=placement['dQ/dV'], x='OCV', y='dQdV') \r\n \r\n if pick_plot['dH/dx'] == True:\r\n dfE.plot(linestyle='-', color='darkgreen', lw=lw, ax=placement['dH/dx'], x='x_new', y='Enthalpy dH/dx')\r\n dfE.plot(linestyle='-', color='darkblue', lw=lw, ax=placement['dH/dx'], x='x', y='Enthalpy dH/dx')\r\n \r\n if pick_plot['S'] == True:\r\n ax5 = dfE.plot(linestyle='-', color='darkgreen', lw=lw, ax=placement['S'], x='x_new', y='Entropy')\r\n \r\n if pick_plot['d/dx(dH/dx)'] == True:\r\n dfE.plot(linestyle='-', color='darkgreen', lw=lw, ax=placement['d/dx(dH/dx)'], x='x_new', y='secder enthalpy x theo')\r\n dfE.plot(linestyle='-', color='darkblue', lw=lw, ax=placement['d/dx(dH/dx)'], x='x', y='secder enthalpy x')\r\n\r\n # Iterate through all the data to be plotted\r\n if simulation_plot == True:\r\n for count, df in enumerate(dataframes):\r\n df1 = pd.read_csv(path + df) # reads file into a dataframe.\r\n \r\n df1 = df1.replace(0, np.nan).dropna(axis=0, how='all') # For the rows with all '0' entries they are replaced with 'nan' and then these rows are dropped.\r\n df1 = df1.replace(np.nan, 0) # As some legitimate 0 entries such as 0 volts we flip back the remaining from 'nan' to 0.\r\n \r\n # Integrates the p.m. entropy\r\n entropy_list = integrate.cumtrapz(df1['Partial molar entropy'], df1['Total mole fraction'],\r\n initial=0) # Contains the entropy values\r\n df1['Entropy'] = entropy_list\r\n \r\n # Rescale voltage profile and p.m. enthalpy by the chain rule.\r\n df1[\"adjusted voltage\"] = df1[\"Chemical potential\"] * ratio_of_capacities\r\n df1[\"adjusted enthalpy\"] = df1[\"Partial molar enthalpy\"] * ratio_of_capacities\r\n df1[\"adjusted entropy\"] = df1[\"Partial molar entropy\"] * ratio_of_capacities\r\n df1[\"adjusted dq/de\"] = df1[\"dq/de\"] * (1/ratio_of_capacities)**2\r\n \r\n # Differentiate the p.m. enthalpy to get the second derivative.\r\n pm_enthalpy = np.array(df1['adjusted enthalpy'])\r\n mole_fraction = np.array(df1['Total mole fraction'])\r\n secder_enthalpy = np.gradient(pm_enthalpy, mole_fraction)\r\n df1['secder enthalpy'] = secder_enthalpy\r\n \r\n if pick_plot['voltage'] == True:\r\n ax1 = df1.plot(linestyle='-', color=colours[count], lw=lw, marker=marker_list[count], markeredgecolor=colours[count],\r\n markersize=mark_size, ax=placement['voltage'], x='Total mole fraction', y='adjusted voltage')\r\n ax1.set_xlim([0, 1])\r\n ax1.set_xlabel('Na content $[x]$')\r\n ax1.set_ylabel('Voltage $[V]$')\r\n ax1.legend(common_legend) \r\n # ax1.legend(['Experimental data (Adjusted x)', 'Raw experimental data', 'Monte Carlo data'])\r\n \r\n if pick_plot['dS/dx'] == True:\r\n ax2 = df1.plot(linestyle='-', color=colours[count], lw=lw, marker=marker_list[count], markeredgecolor=colours[count],\r\n markersize=mark_size, ax=placement['dS/dx'], x='Total mole fraction', y='adjusted entropy')\r\n # ax2.plot(x_pos, y_pos, linewidth=lw, color='red') # Plots the ideal p.m. entropy\r\n ax2.set_xlim([0, 1])\r\n ax2.set_xlabel('Na content $[x]$')\r\n ax2.set_ylabel('$\\\\frac{dS}{dx}$ $[eV K/site]$')\r\n ax2.legend(common_legend) \r\n # ax2.legend(['Experimental data (Adjusted x)', 'Raw experimental data', 'Monte Carlo data', 'Analytical solution'])\r\n \r\n if pick_plot['dQ/dV'] == True:\r\n ax3 = df1.plot(linestyle='-', color=colours[count], lw=lw, marker=marker_list[count], markeredgecolor=colours[count],\r\n markersize=mark_size, ax=placement['dQ/dV'], x='Chemical potential', y='adjusted dq/de') \r\n ax3.set_xlim([-0.1, 1])\r\n ax3.set_xlabel('Voltage $[V]$')\r\n ax3.set_ylabel('$\\\\frac{dQ}{dV}$ [$\\mathregular{eV^{-1}}$]')\r\n ax3.legend(common_legend)\r\n # ax3.legend(['Experimental data', 'Monte Carlo Data'])\r\n \r\n if pick_plot['dH/dx'] == True:\r\n ax4 = df1.plot(linestyle='-', color=colours[count], lw=lw, marker=marker_list[count], markeredgecolor=colours[count],\r\n markersize=mark_size, ax=placement['dH/dx'], x='Total mole fraction', y='adjusted enthalpy')\r\n ax4.set_xlim([0, 1])\r\n ax4.set_xlabel('Na content $[x]$')\r\n ax4.set_ylabel('$\\\\frac{dH}{dx}$ $[eV/site]$')\r\n ax4.legend(common_legend) \r\n # ax4.legend(['Experimental data (Adjusted x)', 'Raw experimental data', 'Monte Carlo data'])\r\n \r\n if pick_plot['d/dx(dH/dx)'] == True:\r\n ax5 = df1.plot(linestyle='-', color=colours[count], lw=lw, marker=marker_list[count], markeredgecolor=colours[count],\r\n markersize=mark_size, ax=placement['d/dx(dH/dx)'], x='Total mole fraction', y='secder enthalpy')\r\n ax5.set_xlim([0, 1])\r\n ax5.set_ylim([0, 6])\r\n ax5.set_xlabel('Na content $[x]$')\r\n ax5.set_ylabel('$\\\\frac{d^2H}{dx^2}$ $[eV/site]$')\r\n ax5.legend(common_legend)\r\n \r\n # ax5.legend(['Experimental data (Adjusted x)', 'Raw experimental data', 'Monte Carlo data'])\r\n \r\n if pick_plot['S'] == True:\r\n ax6 = df1.plot(linestyle='-', color=colours[count], lw=lw, marker=marker_list[count], markeredgecolor=colours[count],\r\n markersize=mark_size, ax=placement['S'], x='Total mole fraction', y='Entropy')\r\n \r\n # ax6.plot(s_x, s_y, linewidth=lw, color='red') # Plots the entropy for l=0.32...\r\n # ax6.plot(x_ent, y_ent, linewidth=lw, color='grey') # Plots the entropy for solid state solution.\r\n ax6.set_xlim([0, 1])\r\n ax6.set_xlabel('Na content $[x]$')\r\n ax6.set_ylabel('S $[eV K/site]$')\r\n ax6.legend(common_legend)\r\n # ax6.legend(['Experimental data', 'Monte Carlo data', 'Analytical solution', 'Solid state solution'], loc='upper right', bbox_to_anchor=(0.75, 0.5))\r\n \r\n \r\n\r\n # parameter_file = open(path + \"/Input_arguments_\" + uid + \".txt\", \"w\")\r\n # parameter_file.write(str(self.args))\r\n # parameter_file.close()\r\n\r\n # manager = plt.get_current_fig_manager()\r\n # # manager.resize(*manager.window.maxsize())\r\n # # fig_path = cwd + \"/Na_plot_results.png\"\r\n # # plt.savefig(path + \"/Na_monte_carlo_plot_\" + uid + \".png\")\r\n # plt.show()\r\n \r\n plt.savefig(\"Varying sps Overlaid Plots - dQ_dV\", dpi = 300)\r\n\r\n plt.show()","def plot_data(\n self,\n out_dir: str = None,\n flags: AttrDict = None,\n therm_frac: float = 0.,\n params: AttrDict = None,\n ):\n plot_data(self.data, out_dir, flags,\n therm_frac=therm_frac, params=params)","def plotSpectrum(inp,xrng=[],yrng=[],xlabel='',ylabel='',xlog=False,ylog=False,grid=False,\n legend=[],legend_location='upper right',fontscale=1,legend_fontscale=1,title='',\n color='k',colormap=None,linestyle='-',linewidth=1.5,alpha=1.,\n show_noise=True,color_noise='k',linestyle_noise='-',linewidth_noise=1.5,alpha_noise=0.5,\n comparison=None,color_comparison='grey',linestyle_comparison='-',linewidth_comparison=1.5,alpha_comparison=1,\n residual=False,color_residual='m',linestyle_residual='-',linewidth_residual=1.5,alpha_residual=0.5,\n telluric=False,color_telluric='grey',linestyle_telluric='-',linewidth_telluric=1.5,alpha_telluric=0.2,\n features=[],mdwarf=False,ldwarf=False,tdwarf=False,young=False,binary=False,nsamples=100,\n band=[],band_color='k',band_alpha=0.2,band_label='',band_label_position='bottom',band_width=0.1,\n show_zero=True,stack=0.,zeropoint=0.,color_zero='k',linestyle_zero=':',linewidth_zero=1.5,alpha_zero=0.3,\n inset=False,inset_xrange=[],inset_yrange=[],inset_position=[0.65,0.60,0.20,0.20],inset_features=False,\n output='',multiplot=False,multipage=False,layout=[1,1],figsize=[],tight=True,\n interactive=False,**kwargs):\n\n# keyword parameters (for backward compatability)\n for k in ['showZero','showzero']: show_zero=kwargs.get(k,show_zero)\n for k in ['showNoise','noise','uncertainty','shownoise','showuncertainty','show_uncertainty']: show_noise=kwargs.get(k,show_noise)\n\n for k in ['line_style','lineStyle','ls','linestyles','line_styles']: linestyle=kwargs.get(k,linestyle)\n for k in ['line_width','lineWidth','width','lw','linewidths','line_widths']: linewidth=kwargs.get(k,linewidth)\n for k in ['colors','colour','colours']: color=kwargs.get(k,color)\n for k in ['colorScheme','color_scheme','colorscheme','colorMap','color_map']: colormap=kwargs.get(k,colormap)\n\n for k in ['colornoise','colorNoise','colorUnc','coloruncertainty','color_uncertainty','colorUncertainty']: color_noise=kwargs.get(k,color_noise)\n for k in ['linestylenoise','line_style_noise','linestyleNoise']: linestyle_noise=kwargs.get(k,linestyle_noise)\n for k in ['linewidthnoise','linewidthNoise','line_width_noise']: linewidth_noise=kwargs.get(k,linewidth_noise)\n for k in ['alphanoise','alphaNoise']: alpha_noise=kwargs.get(k,alpha_noise)\n\n for k in ['colorzero','colorZero']: color_zero=kwargs.get(k,color_zero)\n for k in ['linestylezero','line_style_zero','linestyleZero']: linestyle_zero=kwargs.get(k,linestyle_zero)\n for k in ['linewidthzero','linewidthZero','line_width_zero']: linewidth_zero=kwargs.get(k,linewidth_zero)\n for k in ['alphazero','alphaZero']: alpha_zero=kwargs.get(k,alpha_zero)\n\n for k in ['colorcomparison','colorComparison']: color_comparison=kwargs.get(k,color_comparison)\n for k in ['linestyleComparison','line_style_comparison','linestylecomparison']: linestyle_comparison=kwargs.get(k,linestyle_comparison)\n for k in ['linewidthcomparison','linewidthComparison','line_width_comparison']: linewidth_comparison=kwargs.get(k,linewidth_comparison)\n for k in ['alphacomparison','alphaComparison']: alpha_comparison=kwargs.get(k,alpha_comparison)\n\n for k in ['colorresidual','colorResidual']: color_residual=kwargs.get(k,color_residual)\n for k in ['linestyleresidual','line_style_residual','linestyleResidual']: linestyle_residual=kwargs.get(k,linestyle_residual)\n for k in ['linewidthresidual','linewidthResidual','line_width_residual']: linewidth_residual=kwargs.get(k,linewidth_residual)\n for k in ['alpharesidual','alphaResidual']: alpha_residual=kwargs.get(k,alpha_residual)\n\n for k in ['bands']: band=kwargs.get(k,band)\n if len(band) == 2 and isinstance(band[0],list) == False: band = [band]\n for k in ['bandcolors','bandcolor','band_colors']: band_color=kwargs.get(k,band_color)\n for k in ['bandalphas','band_alphas','bandalpha']: band_alpha=kwargs.get(k,band_alpha)\n for k in ['band_labels','bandlabel','bandlabels']: band_label=kwargs.get(k,band_label)\n for k in ['band_label_positions','bandlabelposition','bandlabelpositions']: band_label_position=kwargs.get(k,band_label_position)\n for k in ['bandwidth','bandwidths','band_widths']: band_width=kwargs.get(k,band_width)\n for par in [band_color,band_alpha,band_label,band_label_position,band_width]:\n if not isinstance(par,list): par = [par]*len(band)\n if len(par) < len(band): par.extend([par[-1] for x in range(len(band)-len(par))])\n\n for k in ['legends','label','labels']: legend=kwargs.get(k,legend)\n if not isinstance(legend,list): legend = [legend]\n for k in ['legendfontscale','legendFontscale']: legend_fontscale=kwargs.get(k,legend_fontscale)\n legend_fontscale=legend_fontscale*fontscale\n for k in ['legendLocation','legendlocation','labelLocation','labellocation','label_location']: legend_location=kwargs.get(k,legend_location)\n\n for k in ['xrange','x_range','wave_range','wrange','wrng']: xrng=kwargs.get(k,xrng)\n if not isinstance(xrng,list): xrng = [xrng]\n for k in ['yrange','y_range','flux_range','frange','frng']: yrng=kwargs.get(k,yrng)\n if not isinstance(yrng,list): yrng = [yrng]\n\n for k in ['multilayout','multiLayout','multi_layout']: layout=kwargs.get(k,layout)\n for k in ['file','filename']: output=kwargs.get(k,output)\n if not isinstance(output,str): output=''\n filetype = '.pdf'\n if output!='': filetype=output.split('.')[-1]\n\n if comparison != None and isinstance(comparison,splat.Spectrum) == False and isinstance(comparison,list) == False: \n print('plotSpectrum() Warning: comparison spectrum should be a splat Spectrum object, you passed {}'.format(comparison))\n comparison = None\n\n# some plotting constants\n xlabel_default = 'Wavelength'\n ylabel_deafult = 'Flux'\n\n# telluric bands in micron\n telluric_bands = [[1.1,1.2]*u.micron,[1.3,1.5]*u.micron,[1.75,2.0]*u.micron]\n\n# assign features by group\n if not isinstance(features,list): features = [features]\n if ldwarf==True or mdwarf==True: features.extend(['k','na','feh','tio','co','h2o','h2'])\n if tdwarf==True: features.extend(['k','ch4','h2o','h2'])\n if young==True: features.extend(['vo'])\n if binary==True: features.extend(['sb'])\n\n# clean repeats in features while maintaining order - set does not do this\n if len(features)>0:\n fea = []\n for i in features:\n if i not in fea: fea.append(i)\n features = fea\n\n\n# if a list is passed, use this list\n splist = copy.deepcopy(inp)\n if isinstance(splist,list) == False: splist = [splist]\n \n# set up for multiplot\n if len(splist) == 1: multiplot = False\n \n# array of lists => force multiplot\n elif len(splist) > 1 and isinstance(splist[0],list) == True: multiplot = True\n else: pass\n\n# reformat array of spectra of multiplot is used (i.e., user forgot to set)\n if multiplot == True and isinstance(splist[0],splat.Spectrum):\n splist = [[s] for s in splist]\n\n elif multiplot == False and isinstance(splist[0],splat.Spectrum):\n splist = [splist]\n \n# flatten array if multiplot is not set\n elif multiplot == False and isinstance(splist[0],list) and len(splist) > 1:\n splist = [[item for sublist in splist for item in sublist]] # flatten\n else: pass\n\n# total number of spectra - use to assign default legends\n allsps = [item for sublist in splist for item in sublist] # Total number of spectra\n if len(legend) == 0: legend=[sp.name for sp in allsps]\n if len(legend) < len(allsps):\n legend.extend([allsps[i].name for i in range(len(legend),len(allsps)-len(legend))])\n \n\n# now run a loop through the input subarrays\n plt.close('all')\n\n# set up here for multiple file output\n nplot = 1\n if multipage == True or multiplot == True:\n nplot = layout[0]*layout[1]\n numpages = int(len(splist) / nplot) + 1\n if (len(splist) % nplot == 0):\n numpages -= 1\n fig = []\n \n if multipage == True and filetype.lower() == 'pdf':\n pdf_pages = PdfPages(output)\n \n if multipage == False:\n if len(splist) > 1:\n filebase = output.replace('.{}'.format(filetype),'')\n files = [filebase+'{}.'.format(i+1)+filetype for i in numpy.arange(len(splist))]\n else:\n files = [output]\n\n pg_n = 0 # page counter\n plt_n = 0 # plot per page counter\n lg_n = 0 # legend per plot counter\n\n for plts,sp in enumerate(splist):\n# set specific plot parameters\n if not isinstance(sp[0],splat.Spectrum):\n raise ValueError('\\nInput to plotSpectrum has wrong format:\\n\\n{}\\n\\n'.format(sp[0]))\n\n# set up plotting defaults for the list of spectra - REPLACE THIS\n if not isinstance(zeropoint,list): zeropoint = [zeropoint]*len(sp)\n if len(zeropoint) < len(sp): zeropoint.extend([zeropoint[-1] for x in range(len(sp)-len(zeropoint))])\n if not isinstance(color,list): color = [color]*len(sp)\n if len(color) < len(sp): color.extend([color[-1] for x in range(len(sp)-len(color))])\n if not isinstance(linestyle,list): linestyle = [linestyle]*len(sp)\n if len(linestyle) < len(sp): linestyle.extend([linestyle[-1] for x in range(len(sp)-len(linestyle))])\n if not isinstance(linewidth,list): linewidth = [linewidth]*len(sp)\n if len(linewidth) < len(sp): linewidth.extend([linewidth[-1] for x in range(len(sp)-len(linewidth))])\n if not isinstance(alpha,list): alpha = [alpha]*len(sp)\n if len(alpha) < len(sp): alpha.extend([alpha[-1] for x in range(len(sp)-len(alpha))])\n if not isinstance(color_noise,list): color_noise = [color_noise]*len(sp)\n if len(color_noise) < len(sp): color_noise.extend([color_noise[-1] for x in range(len(sp)-len(color_noise))])\n if not isinstance(linestyle_noise,list): linestyle_noise = [linestyle_noise]*len(sp)\n if len(linestyle_noise) < len(sp): linestyle_noise.extend([linestyle_noise[-1] for x in range(len(sp)-len(linestyle_noise))])\n if not isinstance(linewidth_noise,list): linewidth_noise = [linewidth_noise]*len(sp)\n if len(linewidth_noise) < len(sp): linewidth_noise.extend([linewidth_noise[-1] for x in range(len(sp)-len(linewidth_noise))])\n if not isinstance(alpha_noise,list): alpha_noise = [alpha_noise]*len(sp)\n if len(alpha_noise) < len(sp): alpha_noise.extend([alpha_noise[-1] for x in range(len(sp)-len(color_noise))])\n if not isinstance(color_comparison,list): color_comparison = [color_comparison]*len(sp)\n if len(color_comparison) < len(sp): color_comparison.extend([color_comparison[-1] for x in range(len(sp)-len(color_comparison))])\n if not isinstance(linestyle_comparison,list): linestyle_comparison = [linestyle_comparison]*len(sp)\n if len(linestyle_comparison) < len(sp): linestyle_comparison.extend([linestyle_comparison[-1] for x in range(len(sp)-len(linestyle_comparison))])\n if not isinstance(linewidth_comparison,list): linewidth_comparison = [linewidth_comparison]*len(sp)\n if len(linewidth_comparison) < len(sp): linewidth_comparison.extend([linewidth_comparison[-1] for x in range(len(sp)-len(linewidth_comparison))])\n if not isinstance(alpha_comparison,list): alpha_comparison = [alpha_comparison]*len(sp)\n if len(alpha_comparison) < len(sp): alpha_comparison.extend([alpha_comparison[-1] for x in range(len(sp)-len(alpha_comparison))])\n\n# settings that work if the spectrum was read in as legitmate Spectrum object\n try:\n xlabel = kwargs.get('xlabel','{} ({})'.format(sp[0].wave_label,sp[0].wave.unit))\n ylabel = kwargs.get('ylabel','{} ({})'.format(sp[0].flux_label,sp[0].flux.unit))\n except:\n xlabel = kwargs.get('xlabel',xlabel_default)\n ylabel = kwargs.get('ylabel',ylabel_default)\n# initial plot range\n bound = [numpy.nanmin(sp[0].wave.value),numpy.nanmax(sp[0].wave.value)]\n ymax = [numpy.nanquantile(s.flux.value,0.98) for s in sp]\n bound.extend(numpy.array([-0.02,1.3])*numpy.nanmax(ymax)+\\\n numpy.array([numpy.nanmin(zeropoint),numpy.nanmax(zeropoint)+stack*(len(sp)-1)]))\n\n# set colormap if provided\n if colormap != None:\n values = numpy.arange(len(sp))\n color_map = plt.get_cmap(colormap)\n norm = colmap.Normalize(vmin=0, vmax=1.0*values[-1])\n scalarMap = cm.ScalarMappable(norm=norm, cmap=color_map)\n for i in range(len(sp)): color[i] = scalarMap.to_rgba(values[i])\n\n# GENERATE PLOTS\n if multiplot == True or multipage == True:\n plt_n = plts % nplot\n if (plt_n == 0):\n fig.append(plt.figure())\n pg_n += 1\n ax = fig[pg_n-1].add_subplot(layout[0], layout[1], plt_n+1)\n \n# plotting a single plot with all spectra\n else:\n plt.close('all')\n plt_n = 0\n fig = []\n if len(figsize)>0: fig.append(plt.figure(figsize=figsize))\n else: fig.append(plt.figure())\n ax = fig[0].add_subplot(111)\n \n for ii, a in enumerate(sp):\n# zeropoint and stack\n flx = [i+zeropoint[ii] for i in a.flux.value]\n if stack > 0: flx = [f + (len(sp)-ii-1)*stack for f in flx]\n ax.plot(a.wave.value,flx,color=color[ii],linestyle=linestyle[ii], lw=linewidth[ii], alpha=alpha[ii], zorder = 10, label = legend[lg_n]) \n\n# add comparison\n if comparison != None:\n# zeropoint and stack\n cflx = [i+zeropoint[ii] for i in comparison.flux.value]\n if stack > 0: cflx = [f + (len(sp)-ii-1)*stack for f in cflx]\n ax.plot(comparison.wave.value,cflx,color=color_comparison[ii],linestyle=linestyle_comparison[ii], lw=linewidth_comparison[ii], alpha=alpha_comparison[ii], zorder = 10)\n \n# add residual\n if residual == True and len(sp) == 2:\n # Save flux values from first spectrum\n if ii == 0:\n flx0 = [f - (len(sp)-ii-1)*stack for f in flx]\n \n # Subtract fluxes and plot\n elif ii == 1:\n res = [flx0[f_n] - f for f_n, f in enumerate(flx)]\n ax.plot(a.wave.value, res, alpha = alpha_residual[ii], color = color_residual[ii], linsetyle=linestyle_residual[ii], lw=linewidth_residual[ii])\n \n # Fix bound[2] if residual goes below 0\n if numpy.nanmin(res) < bound[2]:\n b0 = numpy.argmin(a.wave.value[a.wave.value > bound[0]])\n b1 = numpy.argmax(a.wave.value[a.wave.value < bound[1]])\n bound[2] = numpy.nanmin(res[b0:b1])\n\n# noise\n if show_noise == True:\n ns = [i+zeropoint[ii] for i in a.noise.value]\n ax.plot(a.wave.value,ns,color=color_noise[ii],linestyle=linestyle_noise[ii],alpha=alpha_noise[ii], lw=linewidth_noise[ii], zorder = 10)\n\n# zeropoint\n if show_zero == True:\n ze = numpy.ones(len(a.flux))*zeropoint[ii]\n ax.plot(a.wave.value,ze,color=color[ii],linestyle=linestyle_zero,alpha=alpha_zero,lw=linewidth_zero, zorder = 10)\n\n# save maximum flux among all spectra for plotting\n# THIS IS VERY SLOW AND IT WOULD BE BETTER TO FIND AN ALTERNATE APPROACH\n if len(features)>0:\n f = interp1d(a.wave,flx,bounds_error=False,fill_value=0.)\n if ii == 0: \n wvmax = numpy.linspace(bound[0],bound[1],nsamples)\n flxmax = numpy.array(f(wvmax))\n else: flxmax = numpy.maximum(flxmax,numpy.array(f(wvmax)))\n\n# legend counter\n lg_n = lg_n + 1 # Increment legend\n\n\n# label features\n# THIS NEEDS TO BE FIXED WITH GRETEL'S STUFF\n if len(features) > 0:\n yoff = 0.02*(bound[3]-bound[2]) # label offset\n fontsize = int((10-numpy.nanmin([(layout[0]*layout[1]-1),6]))*fontscale)\n for ftr in features:\n ftr = ftr.lower()\n if ftr in FEATURE_LABELS:\n ftrc = checkDict(ftr,FEATURE_LABELS)\n if ftrc != False:\n for ii,waveRng in enumerate(FEATURE_LABELS[ftrc]['wavelengths']):\n wRng = waveRng.to(sp[0].wave.unit).value\n# features must be contained in plot range (may change this)\n if numpy.nanmin(wRng) > bound[0] and numpy.nanmax(wRng) < bound[1]:\n wfeature = numpy.where(numpy.logical_and(wvmax >= numpy.nanmin(wRng),wvmax <= numpy.nanmax(wRng)))\n if len(wvmax[wfeature]) == 0: wfeature = numpy.argmax(numpy.absolute(wvmax-numpy.nanmedian(wRng)))\n y = numpy.nanmax(flxmax[wfeature])+yoff\n flxmax[wfeature] = flxmax[wfeature]+3.*yoff\n\n if FEATURE_LABELS[ftrc]['type'] == 'band':\n ax.plot(wRng,[y+yoff]*2,color='k',linestyle='-')\n ax.plot([wRng[0]]*2,[y,y+yoff],color='k',linestyle='-')\n ax.text(numpy.mean(wRng),y+1.5*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=fontsize)\n else:\n for w in wRng: ax.plot([w]*2,[y,y+yoff],color='k',linestyle='-')\n ax.text(numpy.mean(wRng),y+1.5*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=fontsize)\n bound[3] = numpy.nanmax([numpy.nanmax(flxmax)+2.*yoff,bound[3]])\n\n# add grid\n if grid == True: ax.grid() \n\n# axis labels \n fontsize = (numpy.round(numpy.max([13./((layout[0]*layout[1])**0.33),5]))) * fontscale\n legend_fontsize = (13-numpy.min([(layout[0]*layout[1]-1),8])) * legend_fontscale\n ax.set_xlabel(xlabel, fontsize = fontsize)\n ax.set_ylabel(ylabel, fontsize = fontsize)\n ax.tick_params(axis='x', labelsize=fontsize)\n ax.tick_params(axis='y', labelsize=fontsize)\n\n# add title\n if title!='': ax.set_title(title)\n\n# log scale?\n if kwargs.get('xlog',False): ax.set_xscale('log',nonposx='clip')\n if kwargs.get('ylog',False): ax.set_yscale('log',nonposy='clip')\n\n# place legend\n if len(legend) > 0:\n if legend_location == 'outside':\n box = ax.get_position()\n ax.set_position([box.x0, box.y0 + box.height * 0.15, box.width * 0.7, box.height * 0.7])\n ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), prop={'size':legend_fontsize})\n else:\n ax.legend(loc=legend_location, prop={'size':legend_fontsize})\n bound[3] = bound[3]+0.1*(bound[3]-bound[2]) # extend axis for in-plot legends\n\n# overplot telluric absorption\n if telluric == True:\n yoff = 0.02*(bound[3]-bound[2]) # label offset\n for waveRng in telluric_bands:\n wR = waveRng.to(sp[0].wave.unit).value\n rect = patches.Rectangle((wR[0],bound[2]),wR[1]-wR[0],bound[3]-bound[2],facecolor=color_telluric,alpha=alpha_telluric,color=color_telluric)\n ax.add_patch(rect)\n ax.text(numpy.mean(wR),bound[2]+3*yoff,r'$\\oplus$',horizontalalignment='center',fontsize=fontsize)\n\n# overplot color swaths for pre-specified bands\n if len(band) > 0:\n for i,b in enumerate(band):\n if not isinstance(b,list): \n try: b = [float(b)-0.5*band_width,float(b)+0.5*band_width]\n except:\n print('\\nWarning: plotSpectrum bands variables should be array of 2-element arrays; you passed {}'.format(band))\n b = [0.,0.]\n rect = patches.Rectangle((b[0],bound[2]),b[1]-b[0],bound[3]-bound[2],facecolor=band_color[i],color=band_color[i],alpha=band_alpha[i])\n ax.add_patch(rect)\n if band_label_position[i].lower() == 'top':\n ax.text(numpy.mean(b),bound[3]-3*yoff,band_label[i],horizontalalignment='center',fontsize=fontsize)\n elif band_label_position[i].lower() == 'middle':\n ax.text(numpy.mean(b),0.5*(bound[2]+bound[3]),band_label[i],horizontalalignment='center',fontsize=fontsize)\n else:\n ax.text(numpy.mean(b),bound[2]+3*yoff,band_label[i],horizontalalignment='center',fontsize=fontsize)\n\n# place inset - RIGHT NOW ONLY SETTING LIMITS WITH FIRST SPECTRUM IN LIST\n if inset == True and len(inset_xrange) == 2:\n ax_inset = fig[pg_n-1].add_axes(inset_position) #, axisbg='white')\n bound2 = inset_xrange\n if len(inset_yrange) == 0:\n b0 = numpy.argmax(sp[0].wave.value > bound2[0])\n b1 = numpy.argmin(sp[0].wave.value < bound2[1])\n inset_yrange = [numpy.nanmin(sp[0].flux.value[b0:b1]),numpy.nanmax(sp[0].flux.value[b0:b1])]\n bound2.extend(inset_yrange)\n db = (bound2[3]-bound2[2])\n bound2[2] = bound2[2]-0.05*db\n bound2[3] = bound2[3]+0.05*db\n ax_inset.axis(bound2)\n inset_fontsize = fontsize*0.7\n\n for ii,a in enumerate(sp):\n flx = [i+zeropoint[ii] for i in a.flux.value]\n ax_inset.plot(a.wave.value,flx,color=colors[ii],linestyle=linestyle[ii],linewidth=linewidth[ii],alpha=alpha[ii]) \n ax_inset.set_xlabel('')\n ax_inset.set_ylabel('')\n ax_inset.tick_params(axis='x', labelsize=inset_fontsize)\n ax_inset.tick_params(axis='y', labelsize=inset_fontsize)\n# ax_inset.legend()\n\n# inset feature labels\n if len(inset_features) > 0:\n yoff = 0.05*(bound2[3]-bound2[2])\n for ftr in inset_features:\n ftrc = checkDict(ftr,FEATURE_LABELS)\n if ftrc != False:\n for ii,waveRng in enumerate(FEATURE_LABELS[ftrc]['wavelengths']):\n wRng = waveRng.to(sp[0].wave.unit).value\n if (numpy.min(wRng) > bound2[0] and numpy.max(wRng) < bound2[1]):\n wfeature = numpy.where(numpy.logical_and(wvmax >= numpy.nanmin(wRng),wvmax <= numpy.nanmax(wRng)))\n if len(wvmax[wfeature]) == 0: wfeature = numpy.argmax(numpy.absolute(wvmax-numpy.nanmedian(wRng)))\n y = numpy.nanmax(flxmax[wfeature])+yoff\n flxmax[wfeature] = flxmax[wfeature]+3.*yoff\n \n if FEATURE_LABELS[ftrc]['type'] == 'band':\n ax_inset.plot(wR,[y+yoff]*2,color='k',linestyle='-')\n ax_inset.plot([wR[0]]*2,[y,y+yoff],color='k',linestyle='-')\n ax_inset.text(numpy.mean(wR),y+2*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=inset_fontsize)\n else:\n for w in waveRng:\n ax_inset.plot([w]*2,[y,y+yoff],color='k',linestyle='-')\n ax_inset.text(numpy.mean(wR),y+2*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=inset_fontsize)\n waveRng = [wR[0]-0.02,wR[1]+0.02] # for overlap\n \n# update offset\n if len(inset_features) > 0: bound2[3] = numpy.nanmax([bound2[3],numpy.nanmax(flxmax)+5.*yoff])\n ax_inset.axis(bound2)\n\n# finalize bounding\n if len(xrng) > 0: bound[0:2] = xrng\n if len(yrng) > 0: bound[2:4] = yrng\n if isUnit(bound[0]): bound = [x.value for x in bound]\n ax.axis(bound)\n \n# save to file or display\n# ERROR HERE - CHECK WHAT FILES\n if multipage == False:\n if files[plts] != '' and (plts % nplot == 3 or plts == len(splist)-1):\n if kwargs.get('tight',True) == True: \n plt.savefig(files[plts], bbox_inches='tight')\n else:\n plt.savefig(files[plts])\n if output == '' and not kwargs.get('web',False):\n plt.show()\n if (kwargs.get('interactive',False) != False): plt.ion()\n else: plt.ioff()\n\n\n# save figures in multipage format and write off pdf file\n if multipage == True: \n for pg_n in numpy.arange(numpages):\n# fig[pg_n].text(0.5, 0.04, xlabel, ha = 'center', va = 'center')\n# fig[pg_n].text(0.06, 0.5, ylabel, ha = 'center', va = 'center', rotation = 'vertical')\n fig[pg_n].tight_layout\n fig[pg_n].suptitle(title, fontsize = int(14*fontsize), fontweight = 'bold')\n pdf_pages.savefig(fig[pg_n])\n if filetype.lower() == 'pdf':\n pdf_pages.close()\n\n plt.clf()\n return fig","def test4():\n\t\n\tprint('This takes a while to compute - be patient!')\n\t\n\td = np.linspace(-15000,15000,300)\n\t#Voigt\n\t#p_dict = {'Bfield':700,'rb85frac':1,'Btheta':90*np.pi/180,'lcell':75e-3,'T':84,'Dline':'D2','Elem':'Cs'}\n\tp_dict = {'Bfield':1000,'rb85frac':1,'Btheta':88*np.pi/180,'Bphi':00*np.pi/180,'lcell':75e-3,'T':93,'Dline':'D2','Elem':'Cs'}\n\tpol = np.array([1.0,0.0,0.0])\n\tTVx = get_spectra(d,pol,p_dict,outputs=['I_M45','I_P45','Ix','Iy','S0','Iz'])\n\t\n\tfig2 = plt.figure()\n\tax1a = fig2.add_subplot(411)\n\tax2a = fig2.add_subplot(412,sharex=ax1a)\n\tax3a = fig2.add_subplot(413,sharex=ax1a)\n\tax4a = fig2.add_subplot(414,sharex=ax1a)\n\t\n\tax1a.plot(d,TVx[0],'r',lw=2,label=r'$I_{-45}$')\n\tax2a.plot(d,TVx[1],'b',lw=2,label=r'$I_{+45}$')\n\tax3a.plot(d,TVx[2],'r',lw=2,label=r'$I_x$')\n\tax4a.plot(d,TVx[3],'b',lw=2,label=r'$I_y$')\n\tax4a.plot(d,TVx[0]+TVx[1],'r:',lw=3.5,label=r'$I_{+45}+I_{-45}$')\n\tax4a.plot(d,TVx[2]+TVx[3],'k:',lw=2.5,label=r'$I_x + I_y$')\n\tax4a.plot(d,TVx[4],'g--',lw=1.5,label='$S_0$')\n#\tax4a.plot(d,TVx[5],'c--',lw=2.5,label='$I_z$')\n\t\n\t\n\tax4a.set_xlabel('Detuning (MHz)')\n\tax1a.set_ylabel('I -45')\n\tax2a.set_ylabel('I +45')\n\tax3a.set_ylabel('Ix')\n\tax4a.set_ylabel('Iy')\n\t\n\tax4a.set_xlim(d[0],d[-1]+3000)\n\tax4a.legend(loc=0)\n\t\n\tplt.show()","def plot_multisite_rms(params, phot_data, mag_col, merr_col, qc_col, plot_filename, log):\n\n # Plot a multi-site initial RMS diagram for reference\n phot_statistics = np.zeros( (len(phot_data),4) )\n (phot_statistics[:,0],werror) = plot_rms.calc_weighted_mean_2D(phot_data, mag_col, merr_col, qc_col=qc_col)\n phot_statistics[:,1] = plot_rms.calc_weighted_rms(phot_data, phot_statistics[:,0], mag_col, merr_col, qc_col=qc_col)\n\n text_filename = plot_filename.replace('.png', '.txt')\n f = open(path.join(params['red_dir'],text_filename),'w')\n f.write('# Star_index wMean_mag RMS\\n')\n for j in range(0,len(phot_statistics),1):\n f.write(str(j)+' '+str(phot_statistics[j,0])+' '+str(phot_statistics[j,1])+'\\n')\n f.close()\n\n fig = plt.figure(3,(10,10))\n plt.rcParams.update({'font.size': 18})\n mask = np.logical_and(phot_statistics[:,0] > 0.0, phot_statistics[:,1] > 0.0)\n plt.plot(phot_statistics[mask,0], phot_statistics[mask,1], 'k.',\n markersize=0.5, label='Weighted RMS')\n plt.yscale('log')\n plt.xlabel('Weighted mean mag')\n plt.ylabel('RMS [mag]')\n plt.grid()\n l = plt.legend()\n plt.tight_layout()\n [xmin,xmax,ymin,ymax] = plt.axis()\n plt.axis([xmin,xmax,1e-3,5.0])\n plot_file = path.join(params['red_dir'],plot_filename)\n plt.savefig(plot_file)\n log.info('Output RMS plot to '+plot_filename)\n plt.close(3)","def plot_spectrum(spec, config):\n for v in config.getpars():\n plot.plot_projection(spec, v)","def plot_coefs(results):\n coefs_noisy = pd.concat([\n arr_to_df(results['obj_noisy'], n_arr, 'obj'),\n vec_to_df(results['dist_obj'], n_arr, 'obj'),\n arr_to_df(results['pos_noisy'], n_arr, 'pos'),\n vec_to_df(results['dist_pos'], n_arr, 'pos'),\n arr_to_df(results['neg_noisy'], n_arr, 'neg'),\n vec_to_df(results['dist_neg'], n_arr, 'neg')\n ])\n\n xlim = (min(n_arr), max(n_arr))\n ylim = (-1.1, 1.1)\n\n g = sns.FacetGrid(coefs_noisy, row = 'id', col = 'component', xlim = xlim,\n ylim = ylim)\n g.map(sns.pointplot, 'n', 'value', order = n_arr)\n g.set_xticklabels(rotation = 45)\n\n for i, val in enumerate(results['obj_true']):\n ax = g.axes[0, i]\n ax.hlines(val, *ax.get_xlim())\n for i, val in enumerate(results['pos_true']):\n ax = g.axes[1, i]\n ax.hlines(0, *ax.get_xlim(), linestyle = '--', color = 'red')\n ax.hlines(val, *ax.get_xlim())\n for i, val in enumerate(results['neg_true']):\n ax = g.axes[2, i]\n ax.hlines(0, *ax.get_xlim(), linestyle = '--', color = 'red')\n ax.hlines(val, *ax.get_xlim())","def main():\n parser = argparse.ArgumentParser(\n description=\"Generate bar plots comparing Matlab solvers to RLSO\"\n )\n parser.add_argument(\n \"--path\", type=str, default=None, help=\"the path to saved testing data for RLSO\"\n )\n parser.add_argument(\n \"--trials\",\n type=int,\n default=1000,\n help=\"Number of test problems to use defaults to 1000\",\n )\n parser.add_argument(\n \"--savestring\",\n type=str,\n default=None,\n help=\"Name to save our plot as. Defaults to random int .png\",\n )\n parser.add_argument(\n \"--titlestring\",\n type=str,\n default=None,\n help=\"String to append to our plot title. Defaults to None\",\n )\n parser.add_argument(\n \"--excludeinter\",\n type=bool,\n default=True,\n help=\"Exclude interior point method form testing. Reasons Convex only, and cannot set starting point. Default True\",\n )\n\n args = parser.parse_args()\n\n if args.path is None:\n print(\"Path to pickle data needed!\")\n return\n\n pickle_savepath = args.path\n with open(pickle_savepath, \"rb\") as pickle_file:\n pickle_tuple = pickle.load(pickle_file)\n\n complex_dic = pickle_tuple[4]\n lastbest = unravel_c_dic_lastbest(complex_dic)\n Abx0 = generate_Abx0(complex_dic, lastbest)\n\n if args.trials is None:\n trials = 1000\n else:\n trials = args.trials\n if args.savestring is None:\n save_string = str(np.random.randint(low=1e15, high=9e15)) + \".png\"\n else:\n save_string = args.savestring\n\n start = time.time()\n print(f\"start time {start}\")\n\n solutions = []\n for tuples in Abx0[:trials]:\n solutions.append(quad_solve(tuples, printout=False))\n end = time.time()\n print(f\"Matlab run time: {end - start}\")\n\n rlso = []\n active = []\n inter = []\n trust = []\n for [x, y, z, w] in solutions:\n rlso.append(x)\n active.append(y)\n inter.append(z)\n trust.append(w)\n title_string = args.titlestring\n plot_box(\n rlso,\n active,\n inter,\n trust,\n title_string,\n save_string,\n exclude_inter=args.excludeinter,\n )\n\n return"],"string":"[\n \"def plot_directory_profiles(path, outname=None, show=True, xscale=1, yscale=1,\\n xval='x', adjustRadial=True):\\n outdirs = np.sort(os.listdir(path))\\n plt.figure()\\n\\n #labels=['homogeneous','1D layering', '3D tomography'] #xscale=1e-3, yscale=1e2\\n for i,outdir in enumerate(outdirs):\\n pointsFile = os.path.join(path, outdir, 'points.h5')\\n #print(pointsFile)\\n #x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile, output='cyl',adjustRadial=adjustRadial)\\n #x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile)\\n #Load data\\n\\n x,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n #Y = uz / yscale\\n if xval == 'x':\\n X = x / xscale\\n Y1 = ux / yscale\\n elif xval == 'r':\\n X = np.hypot(x,y) / xscale\\n ur_fem = np.hypot(ux,uy)\\n Y1 = ur_fem / yscale\\n if adjustRadial: #fix sign from hypot square root\\n ur_fem = pu.radial2negative(Y1)\\n\\n x_fem = X #/ xscale #double scaling!\\n ur_fem = Y1 #/ yscale\\n uz_fem = uz / yscale\\n\\n #print(pointsFile)\\n print(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max())\\n\\n l, = plt.plot(x_fem,uz_fem,'.-',lw=3,label=outdir)\\n #l, = plt.plot(x_fem,uz_fem,'.-',lw=2,label=labels[i]) #for 3d heterogeneity example\\n plt.plot(x_fem,ur_fem,'.--',lw=3, mfc='w',color=l.get_color()) #mfc='none' transparent\\n\\n # Annotate\\n plt.axhline(color='k',lw=0.5)\\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\\n plt.legend()\\n\\n #NOTE: custom annotations for 3d heterogeneity\\n #plt.title('Elastic Heterogeneity Effects')\\n #plt.legend([l1,l2,l3],['homogeneous','1D layering', '3D tomography'])\\n\\n if outname: plt.savefig(outname)\\n if show: plt.show()\",\n \"def display_results(experiment, norms, nus, filename):\\n # plot the results of the experiment\\n fig, axes = plt.subplots(2,2, figsize=(15.0, 10.0))\\n\\n # plot large scale overview\\n _create_line_plot(experiment['a'], nus, norms, axes[0][0], 'slope')\\n _create_line_plot(experiment['b'], nus, norms, axes[0][1], 'intercept')\\n\\n # plot more detailed errors exluding OLS estimate\\n _create_bar_plot(experiment['a'], nus[1::2], norms, axes[1][0])\\n _create_bar_plot(experiment['b'], nus[1::2], norms, axes[1][1])\\n\\n # add title and save\\n plt.savefig(filename, dpi=300)\",\n \"def plot(model, results, filename):\\n\\n # c = model.compartments.get_one(id='c')\\n #\\n # rna_1 = model.species_types.get_one(id='rna_1').species.get_one(compartment=c)\\n # rna_2 = model.species_types.get_one(id='rna_2').species.get_one(compartment=c)\\n # rna_3 = model.species_types.get_one(id='rna_3').species.get_one(compartment=c)\\n #\\n pops = results.get('populations')\\n time = pops.index\\n pop_rna_1 = pops['rna_1[c]']\\n pop_rna_2 = pops['rna_2[c]']\\n pop_rna_3 = pops['rna_3[c]']\\n\\n pop_atp = pops['atp[c]']\\n pop_gtp = pops['gtp[c]']\\n pop_utp = pops['ctp[c]']\\n pop_ctp = pops['utp[c]']\\n\\n pop_amp = pops['amp[c]']\\n pop_gmp = pops['gmp[c]']\\n pop_ump = pops['cmp[c]']\\n pop_cmp = pops['ump[c]']\\n\\n print(pop_rna_1, pop_atp, pop_gtp, pop_utp, pop_ctp)\\n\\n fig1, axes1 = pyplot.subplots(nrows=3, ncols=1)\\n\\n axes1[0].plot(time / 3600, pop_rna_1)\\n axes1[0].plot(time / 3600, pop_rna_2)\\n axes1[0].plot(time / 3600, pop_rna_3)\\n axes1[0].set_xlim((time[0] / 3600, time[-1] / 3600))\\n axes1[0].set_ylim((0., 10.0))\\n axes1[0].legend(loc='upper right')\\n\\n axes1[1].plot(time / 3600, pop_atp)\\n axes1[1].plot(time / 3600, pop_gtp)\\n axes1[1].plot(time / 3600, pop_utp)\\n axes1[1].plot(time / 3600, pop_ctp)\\n axes1[1].set_xlim((time[0] / 3600, time[-1] / 3600))\\n # axes1[1].set_ylim((0., 10.0))\\n axes1[1].legend(loc='upper right')\\n\\n axes1[2].plot(time / 3600, pop_amp)\\n axes1[2].plot(time / 3600, pop_gmp)\\n axes1[2].plot(time / 3600, pop_ump)\\n axes1[2].plot(time / 3600, pop_cmp)\\n axes1[2].set_xlim((time[0] / 3600, time[-1] / 3600))\\n # axes1[2].set_ylim((0., 10.0))\\n axes1[2].legend(loc='upper right')\\n\\n fig1.savefig(filename.format('species'))\\n pyplot.close(fig1)\",\n \"def plot_it(self, ui=None, res_dir=None):\\r\\n print_it(\\\"plotting results\\\")\\r\\n plt_profile(self.sun, PltOpts.DD.value, res_dir, SubDir.profiles.value)\\r\\n plt_profile(self.sun, PltOpts.DDD.value, res_dir, SubDir.profiles.value)\\r\\n plt_profile(self.planet, PltOpts.DD.value, res_dir,\\r\\n SubDir.profiles.value)\\r\\n plt_profile(self.planet, PltOpts.DDD.value, res_dir,\\r\\n SubDir.profiles.value)\\r\\n plt_profile_approx(res_dir, SubDir.profiles.value)\\r\\n plt_contact(self.sun, self.planet, PltOpts.DD.value, res_dir,\\r\\n SubDir.contacts.value)\\r\\n plt_contact(self.sun, self.planet, PltOpts.DDD.value, res_dir,\\r\\n SubDir.contacts.value)\\r\\n\\r\\n plt_3d(self.sun.x_axis, self.sun.y_axis, self.sun.press,\\r\\n self.sun.x_label, self.sun.y_label, 'pressure in MPa',\\r\\n 'contact_pressure_sun', res_dir, SubDir.pressures.value,\\r\\n 'contact_pressure_sun')\\r\\n plt_2d_scatt_line(self.sun.x_axis, self.pv, self.sun.x_axis, self.pv,\\r\\n self.sun.x_label,\\r\\n 'pv_rel in {}'.format(Unit.pvrel.value), 'pv_rel',\\r\\n res_dir, SubDir.energy.value, 'pv_rel')\\r\\n plt_2d_scatt_line(self.sun.x_axis, self.sun.e_akin, self.sun.x_axis,\\r\\n self.sun.e_akin, self.sun.x_label,\\r\\n 'e_akin in {}'.format(Unit.eakin.value), 'e_akin',\\r\\n res_dir, SubDir.energy.value, 'sun.e_akin')\\r\\n plt_2d_scatt_line(self.planet.x_axis, self.planet.e_akin,\\r\\n self.planet.x_axis, self.planet.e_akin,\\r\\n self.planet.x_label,\\r\\n 'e_akin in {}'.format(Unit.eakin.value), 'e_akin',\\r\\n res_dir,\\r\\n SubDir.energy.value, 'planet.e_akin')\\r\\n plt_energy_ring_on_ring(self, res_dir, SubDir.energy.value,\\r\\n 'e-akin-vs-pv-rel')\",\n \"def xx_plot(epoch, model, features, filters, figname, fgal=0.5):\\n # fetch Stripe 82 data\\n X, Xcov = fetch_prepped_s82data(epoch, fgal, features, filters)\\n Xcoadd, Xcoaddcov = fetch_prepped_s82data(epoch, fgal, features,\\n filters, use_single=False)\\n N = 20000\\n X = X[:N]\\n Xcov = Xcov[:N]\\n Xcoadd = Xcoadd[:N]\\n Xcoaddcov = Xcoaddcov[:N]\\n\\n # unpickle the XD model\\n if type(model) == str: \\n f = open(model, 'rb')\\n model = cPickle.load(f)\\n f.close()\\n\\n # Calculate the posteriors, draw samples\\n a, m, v = model.posterior(X, Xcov)\\n posts = np.zeros_like(X)\\n for i in range(X.shape[0]):\\n posts[i] = model.sample(a[i], m[i], v[i], size=1)\\n\\n lo = [0.01, 0.02, 0.06]\\n hi = [0.99, 0.96, 0.98]\\n idx = [0, 1, 4]\\n bins = [100, 100, 300]\\n label = ['psfmag $r$', 'modelmag $u-g$', 'modelmag $i-z$']\\n N = len(idx)\\n fs = 5\\n lsize = 20\\n f = pl.figure(figsize=(N * fs, 2 * fs))\\n pl.subplots_adjust(wspace=0.3)\\n for i in range(N):\\n x = X[:, idx[i]]\\n y = Xcoadd[:, idx[i]]\\n p = posts[:, idx[i]]\\n ind = (y > -999) & (Xcoaddcov[:, idx[i]][:, idx[i]] < 10.)\\n x = x[ind]\\n y = y[ind]\\n p = p[ind]\\n ax = pl.subplot(2, N, i + 1)\\n v = np.sort(x)\\n mn, mx = v[np.int(lo[i] * x.shape[0])], v[np.int(hi[i] * x.shape[0])]\\n hist2d(x, y, ax=ax, bins=bins[i], plot_contours=True,\\n plot_datapoints=True)\\n pl.plot([mn, mx], [mn, mx], 'r', lw=2)\\n pl.ylabel('Coadd ' + label[i], fontsize=lsize)\\n pl.xlabel('Single Epoch ' + label[i], fontsize=lsize)\\n pl.xlim(mn, mx)\\n pl.ylim(mn, mx)\\n ax = pl.subplot(2, N, i + 4)\\n hist2d(p, y, ax=ax, bins=bins[i], plot_contours=True,\\n plot_datapoints=True)\\n pl.plot([mn, mx], [mn, mx], 'r', lw=2)\\n pl.xlim(mn, mx)\\n pl.ylim(mn, mx)\\n pl.ylabel('Coadd ' + label[i], fontsize=lsize)\\n pl.xlabel('XD Posterior ' + label[i], fontsize=lsize)\\n f.savefig(figname, bbox_inches='tight')\",\n \"def _plotModelResiduals(id='simulated800nmJoint1', folder='results/', out='Residual.pdf', individual=False):\\n #data\\n if individual:\\n data = pf.getdata(folder+id+'small.fits')\\n data[data < 1] = 1.\\n data = np.log10(data)\\n else:\\n data = pf.getdata(folder+id+'datafit.fits')\\n data[data < 1] = 1.\\n data = np.log10(data)\\n #model\\n model = pf.getdata(folder+id+'model.fits ')\\n model[model < 1] = 1.\\n model = np.log10(model)\\n #residual\\n residual = pf.getdata(folder+id+'residual.fits')\\n #squared residual\\n residualSQ = pf.getdata(folder+id+'residualSQ.fits')\\n\\n max = np.max((data.max(), model.max()))\\n\\n #figure\\n fig = plt.figure(figsize=(12, 12))\\n ax1 = fig.add_subplot(221)\\n ax2 = fig.add_subplot(222)\\n ax3 = fig.add_subplot(223)\\n ax4 = fig.add_subplot(224)\\n ax = [ax1, ax2, ax3, ax4]\\n fig.subplots_adjust(hspace=0.05, wspace=0.3, top=0.95, bottom=0.02, left=0.02, right=0.9)\\n ax1.set_title('Data')\\n ax2.set_title('Model')\\n ax3.set_title('Residual')\\n ax4.set_title('$L^{2}$ Residual')\\n\\n im1 = ax1.imshow(data, interpolation='none', vmax=max, origin='lower', vmin=0.1)\\n im2 = ax2.imshow(model, interpolation='none', vmax=max, origin='lower', vmin=0.1)\\n im3 = ax3.imshow(residual, interpolation='none', origin='lower', vmin=-100, vmax=100)\\n im4 = ax4.imshow(residualSQ, interpolation='none', origin='lower', vmin=0., vmax=10)\\n\\n divider = make_axes_locatable(ax1)\\n cax1 = divider.append_axes(\\\"right\\\", size=\\\"5%\\\", pad=0.05)\\n divider = make_axes_locatable(ax2)\\n cax2 = divider.append_axes(\\\"right\\\", size=\\\"5%\\\", pad=0.05)\\n divider = make_axes_locatable(ax3)\\n cax3 = divider.append_axes(\\\"right\\\", size=\\\"5%\\\", pad=0.05)\\n divider = make_axes_locatable(ax4)\\n cax4 = divider.append_axes(\\\"right\\\", size=\\\"5%\\\", pad=0.05)\\n cbar1 = plt.colorbar(im1, cax=cax1)\\n cbar1.set_label(r'$\\\\log_{10}(D_{i, j} \\\\quad [e^{-}]$)')\\n cbar2 = plt.colorbar(im2, cax=cax2)\\n cbar2.set_label(r'$\\\\log_{10}(M_{i, j} \\\\quad [e^{-}]$)')\\n cbar3 = plt.colorbar(im3, cax=cax3)\\n cbar3.set_label(r'$M_{i, j} - D_{i, j} \\\\quad [e^{-}]$')\\n cbar4 = plt.colorbar(im4, cax=cax4)\\n cbar4.set_label(r'$\\\\frac{(M_{i, j} - D_{i, j})^{2}}{\\\\sigma_{CCD}^{2}}$')\\n\\n for tmp in ax:\\n plt.sca(tmp)\\n plt.xticks(visible=False)\\n plt.yticks(visible=False)\\n\\n plt.savefig(out)\\n plt.close()\",\n \"def plot_directory_surface_rmse(path, vals, param='Vp'):\\n\\n unw = '/home/scott/data/insar/cvz/t2282/geo/geo_stack282_8rlks.unw'\\n incidence = '/home/scott/data/insar/cvz/t2282/aux_files/geo_incidence_8rlks.unw'\\n dem = '/home/scott/data/dems/cgiar/uturuncu_1000_1000.tif'\\n #surface = '/home/scott/research/models/pylith/3d/uturuncu_layered/output/step01/surface.h5'\\n #geosurface = '/home/scott/research/models/pylith/scripts/geo_fem_Uz.tif'\\n\\n plt.figure()\\n outdirs = np.sort(os.listdir(path))\\n\\n # Calculate rmse\\n rmse = np.zeros_like(vals)\\n for i,outdir in enumerate(outdirs):\\n surface = os.path.join(path,outdir,'surface.h5')\\n los,fem_los,residual = pu.los2pylith(surface, dem, unw, incidence)\\n rmse[i] = rms_flat(residual[np.isfinite(residual)])\\n\\n plt.plot(vals,rmse,'b.-')\\n\\n # Annotate\\n #plt.title(param)\\n plt.xlabel('{} [km]'.format(param))\\n plt.ylabel('RMSE [cm]')\\n plt.legend()\\n plt.show()\",\n \"def plot_results_traj_3d(p_x, p_y, p_z, xmin, xmax, ymin, ymax, zmin, zmax):\\n fig, ax = plt.subplots(2 , 2, figsize = (10, 10))\\n \\n for p in np.arange(0, p_x.shape[0], step = 1): \\n for t in np.arange(0, p_x.shape[1], step = 1): \\n ax[0,0].plot(t, p_x[p, t], 'rx') \\n ax[0,1].plot(t, p_y[p, t], 'gx') \\n ax[1,0].plot(t, p_z[p, t], 'bx') \\n ax[1,1].plot(t, p_x[p, t], 'rx') \\n ax[1,1].plot(t, p_y[p, t], 'gx') \\n ax[1,1].plot(t, p_z[p, t], 'bx') \\n for a in ax.flat: \\n a.set(xlabel = 'Time steps', ylabel = 'Position')\\n ax[0,0].set_title('X (pix)') \\n ax[0,0].set_ylim([xmin, xmax]) \\n ax[0,1].set_title('Y (pix)') \\n ax[0,1].set_ylim([ymin, ymax]) \\n ax[1,0].set_title('Z (pix)') \\n ax[1,0].set_ylim([zmin, zmax])\\n ax[1,1].set_title('Positions combined') \\n ax[1,1].set_ylim([np.array([xmin, ymin, zmin]).min(), np.array([xmax, ymax, zmax]).max()])\",\n \"def plot_results(model):\\n\\n # Is is a system of equation\\n is_system = max(model.n_input, model.n_output) > 1\\n\\n # Choose the plotting function depending on the type of training data\\n if model.dimension == 1 and not (is_system):\\n plot_1d_results(model)\\n\\n elif model.dimension == 1 and is_system:\\n plot_1d_systems(model)\\n\\n elif model.dimension > 1 and not (is_system):\\n plot_2d_results(model)\\n\\n else:\\n # Plot and save slices of the Green's matrix\\n for i in range(1, 5):\\n plot_2d_systems(model, Green_slice=i)\",\n \"def plot(self, **kwargs):\\n\\n # get colors\\n colors = kwargs.get(\\\"colors\\\", GW_OBSERVATORY_COLORS)\\n\\n # get Result samples\\n self._samples = {\\n label: value.posterior\\n for label, value in self.results.items()\\n if isinstance(value, Result)\\n }\\n\\n # get Grid posteriors\\n self._grids = {\\n label: [value, value.ln_evidence] # store grid and log evidence\\n for label, value in self.results.items()\\n if isinstance(value, Grid)\\n }\\n\\n # apply offsets for slightly nicer plots axes\\n self.parameter_offsets = {parameter: 0.0 for parameter in self.parameters}\\n if len(self._grids) == 0 and len(self._samples) == 1:\\n for label in self._samples:\\n for parameter in self.parameters:\\n srange = [\\n np.min(self._samples[label][parameter]),\\n np.max(self._samples[label][parameter]),\\n ]\\n label_suffix = \\\"\\\"\\n\\n # offset values\\n median = np.median(self._samples[label][parameter])\\n relwidth = np.abs((srange[1] - srange[0]) / median)\\n\\n if relwidth < 1e-4:\\n offsetstr = f\\\"{median:.4e}\\\"\\n a, b = offsetstr.split(\\\"e\\\")\\n\\n if np.abs(int(b)) < 3:\\n offsetstr = f\\\"{median:.4f}\\\"\\n offset = float(offsetstr)\\n else:\\n offset = float(offsetstr)\\n offsetstr = a + rf\\\"\\\\!\\\\times\\\\!10^{{{int(b)}}}\\\"\\n\\n self.parameter_offsets[parameter] = offset\\n\\n self._samples[label][parameter] -= offset\\n label_suffix = rf\\\" [${{\\\\scriptstyle {offsetstr}}}$]\\\"\\n\\n self.latex_labels[parameter] += label_suffix\\n\\n colordicts = []\\n for j, res in enumerate([self._samples, self._grids]):\\n colordicts.append({})\\n for i, key in enumerate(res):\\n if key in colors:\\n colordicts[-1][key] = colors[key]\\n elif key.lower() == \\\"joint\\\":\\n # if using \\\"Joint\\\" as the multi-detector analysis key, set the color to black\\n colordicts[-1][key] = \\\"k\\\"\\n else:\\n # use PESummary color cycle\\n colordicts[-1][key] = list(colorcycle)[\\n (j * 2 + i) % len(colorcycle)\\n ]\\n\\n # store original keywords arguments\\n origkwargs = kwargs.copy()\\n\\n # plot samples\\n fig = None\\n if len(self._samples) > 0:\\n kwargs[\\\"colors\\\"] = list(colordicts[0].values())\\n if self._num_parameters == 1:\\n fig = self._1d_plot_samples(**kwargs)\\n elif self._num_parameters == 2 and self.plottype != \\\"corner\\\":\\n fig = self._2d_plot_samples(**kwargs)\\n else:\\n fig = self._nd_plot_samples(**kwargs)\\n\\n # restore keywords\\n kwargs = origkwargs\\n\\n if len(self._grids) > 0:\\n kwargs[\\\"colors\\\"] = list(colordicts[1].values())\\n if fig is not None and \\\"fig\\\" not in kwargs:\\n kwargs[\\\"fig\\\"] = fig\\n if self._num_parameters == 1:\\n fig = self._1d_plot_grid(**kwargs)\\n elif self._num_parameters == 2 and self.plottype != \\\"corner\\\":\\n fig = self._2d_plot_grid(**kwargs)\\n else:\\n fig = self._nd_plot_grid(**kwargs)\\n\\n # add further figure information\\n if self._num_parameters == 1:\\n ax = fig.gca()\\n\\n # set figure bounds if outside defaults\\n if self.parameters[0] in DEFAULT_BOUNDS:\\n _set_axes_limits(ax, self.parameters[0], axis=\\\"x\\\")\\n\\n # add injection values\\n if self.injection_parameters is not None:\\n if self.injection_parameters[self.parameters[0]] is not None:\\n ax.axvline(\\n (\\n self.injection_parameters[self.parameters[0]]\\n - self.parameter_offsets[self.parameters[0]]\\n ),\\n color=kwargs.get(\\\"injection_color\\\", \\\"k\\\"),\\n linewidth=1,\\n )\\n elif self._num_parameters == 2:\\n if \\\"triangle\\\" in self.plottype:\\n a1, a2, a3 = fig[1:]\\n order = [\\\"x\\\", \\\"y\\\"] if self.plottype == \\\"triangle\\\" else [\\\"y\\\", \\\"x\\\"]\\n params = (\\n self.parameters[:2]\\n if self.plottype == \\\"triangle\\\"\\n else self.parameters[1::-1]\\n )\\n\\n # set figure bounds if outside defaults\\n for param, axes, axis in zip(params, [[a1, a2], [a2, a3]], order):\\n for ax in axes:\\n _set_axes_limits(ax, param, axis=axis)\\n\\n self.fig = fig\\n return self.fig\",\n \"def plot_potential_profile(rims_object):\\r\\n if not os.path.exists(rims_object.path_for_output):\\r\\n os.makedirs(rims_object.path_for_output)\\r\\n number_of_profiles = rims_object.potential_profile_mat.shape[0]\\r\\n x = [dx * pow(10, 4) for dx in rims_object.x_space_vec]\\r\\n fig, axs = plt.subplots(number_of_profiles)\\r\\n plt.suptitle('RIMS: Ratchet potential profiles', fontsize=14, fontweight='bold')\\r\\n\\r\\n for i_profile in range(number_of_profiles):\\r\\n y = [dy for dy in rims_object.potential_profile_mat[i_profile]]\\r\\n axs[i_profile].plot(x, y, color=YELLOW, label=\\\"V(x) potential profile\\\")\\r\\n axs[i_profile].tick_params(axis='y', labelcolor=YELLOW)\\r\\n ax2 = axs[i_profile].twinx()\\r\\n y = [dy * pow(10, -4) for dy in rims_object.electric_field_mat[i_profile]]\\r\\n ax2.plot(x, y, color=PURPLE, label=r\\\"E(x) electric field = -$\\\\nabla $V\\\")\\r\\n ax2.tick_params(axis='y', labelcolor=PURPLE)\\r\\n text_kwargs = dict(fontsize=10, color=YELLOW, fontweight='bold')\\r\\n fig.text(0.1, 0.91, 'V(x) potential profile [v]', text_kwargs)\\r\\n text_kwargs = dict(fontsize=10, color=PURPLE, fontweight='bold')\\r\\n fig.text(0.5, 0.91, r\\\"E(x) electric field = -$\\\\nabla $V [v/$\\\\mu $m]\\\", text_kwargs)\\r\\n axs[number_of_profiles-1].set_xlabel(r\\\"X [$\\\\mu $m]\\\")\\r\\n\\r\\n if number_of_profiles < 4:\\r\\n fig.tight_layout()\\r\\n plt.savefig(rims_object.path_for_output + 'Ratchet potential profiles.jpeg')\\r\\n plt.close()\\r\\n write_to_log(rims_object, \\\"potential profile plot saved\\\")\\r\\n return\",\n \"def plot_optima(cfg, results, results_inftau):\\n\\n def subplot_args(experiment_idx, row):\\n return 4, len(cfg['experiments']), \\\\\\n row * len(cfg['experiments']) + experiment_idx + 1\\n\\n for e, experiment in enumerate(cfg['experiments']):\\n def set_rowlabels(rowname):\\n if e <= 0:\\n plt.ylabel(rowname)\\n else:\\n plt.yticks([])\\n\\n plt.subplot(*subplot_args(e, 0))\\n\\n plt.title(experiment['name'])\\n plt.xlabel(\\\"time / ms\\\")\\n plt.ylim(0, 210)\\n if e > 0:\\n plt.yticks([])\\n plot_stparams(\\n [cfg['l1_length'], cfg['l2_lengths'][1], cfg['l3_length'],\\n cfg['l4_lengths'][1]], experiment['rates_a'], 'm')\\n plot_stparams(\\n [cfg['l1_length'], cfg['l2_lengths'][1], cfg['l3_length'],\\n cfg['l4_lengths'][1]], experiment['rates_b'], 'k')\\n\\n plt.subplot(*subplot_args(e, 1))\\n set_rowlabels(r\\\"$\\\\langle I^* \\\\rangle$\\\")\\n plt.xticks([])\\n plt.xlim(\\n 0,\\n (len(cfg['l4_lengths']) + 0.5) * (len(cfg['l2_lengths']) + 2))\\n plot_optimal_uncertainty_reduction(results[e], results_inftau[e])\\n\\n plt.subplot(*subplot_args(e, 2))\\n plt.ylim([10 * cfg['time_scales'][0], 3 * cfg['time_scales'][-1]])\\n plt.semilogy()\\n set_rowlabels(r\\\"$\\\\langle \\\\tau^* \\\\rangle$\\\")\\n plt.xticks([])\\n plt.xlim(\\n 0,\\n (len(cfg['l4_lengths']) + 0.5) * (len(cfg['l2_lengths']) + 2))\\n plot_optimal_tau(results[e], results_inftau[e])\\n\\n plt.subplot(*subplot_args(e, 3))\\n plt.ylim([10 * cfg['time_scales'][0], 3 * cfg['time_scales'][-1]])\\n plt.semilogy()\\n set_rowlabels(r\\\"$\\\\tau^*_{\\\\langle I \\\\rangle}$\\\")\\n plt.xlim(\\n 0,\\n (len(cfg['l4_lengths']) + 0.5) * (len(cfg['l2_lengths']) + 2))\\n plot_optimal_tau_for_mean_uncertainty_reduction(\\n results[e], results_inftau[e])\\n\\n plt.xticks(\\n (sp.arange(len(cfg['l4_lengths'])) + 0.5) *\\n (len(cfg['l2_lengths']) + 2),\\n ['%s' % l for l in cfg['l4_lengths']])\",\n \"def plot_results(models,\\n data,\\n batch_size=128,\\n model_name=None):\\n\\n encoder, decoder = models\\n x_test, y_test = data\\n # display a 2D plot of the digit classes in the latent space\\n z_mean = encoder(x_test)\\n plt.figure(figsize=(12, 10))\\n plt.scatter(z_mean[:, 0], z_mean[:, 1], c=y_test)\\n plt.colorbar()\\n plt.xlabel(\\\"z[0]\\\")\\n plt.ylabel(\\\"z[1]\\\")\\n \\n plt.show()\\n if not model_name is None:\\n os.makedirs(model_name, exist_ok=True)\\n filename = os.path.join(model_name, \\\"vae_mean.png\\\")\\n plt.savefig(filename)\\n filename = os.path.join(model_name, \\\"digits_over_latent.png\\\")\\n # display a 30x30 2D manifold of digits\\n n = 30\\n digit_size = 28\\n figure = np.zeros((digit_size * n, digit_size * n))\\n # linearly spaced coordinates corresponding to the 2D plot\\n # of digit classes in the latent space\\n grid_x = np.linspace(-4, 4, n)\\n grid_y = np.linspace(-4, 4, n)[::-1]\\n\\n for i, yi in enumerate(grid_y):\\n for j, xi in enumerate(grid_x):\\n z_sample = np.array([[xi, yi]])\\n x_decoded = decoder(z_sample)\\n digit = x_decoded[0].reshape(digit_size, digit_size)\\n figure[i * digit_size: (i + 1) * digit_size,\\n j * digit_size: (j + 1) * digit_size] = digit\\n\\n plt.figure(figsize=(10, 10))\\n start_range = digit_size // 2\\n end_range = n * digit_size + start_range + 1\\n pixel_range = np.arange(start_range, end_range, digit_size)\\n sample_range_x = np.round(grid_x, 1)\\n sample_range_y = np.round(grid_y, 1)\\n plt.xticks(pixel_range, sample_range_x)\\n plt.yticks(pixel_range, sample_range_y)\\n plt.xlabel(\\\"z[0]\\\")\\n plt.ylabel(\\\"z[1]\\\")\\n plt.imshow(figure, cmap='Greys_r')\\n if not model_name is None:\\n plt.savefig(filename)\\n plt.show()\",\n \"def find_best(results, show_plot=True):\\n max_point = max(results)\\n print(\\\"Maximum achieved at d={} and class prior={}. Accuracy of {}%.\\\".format(max_point[1],max_point[2],max_point[0]))\\n if show_plot:\\n import matplotlib.pyplot as plt\\n from matplotlib import cm\\n from mpl_toolkits.mplot3d import Axes3D\\n z,x,y = zip(*results)\\n fig = plt.figure()\\n ax = fig.gca(projection='3d')\\n ax.plot_trisurf(x, y, z, cmap=cm.jet, linewidth=0.2)\\n ax.text(max_point[1],max_point[2],max_point[0]+2, \\\"MAX\\\")\\n plt.title('Parameter Tuning Results')\\n plt.xlabel('d value')\\n plt.ylabel('class prior')\\n ax.set_zlabel('Accuracy')\\n plt.show()\",\n \"def plot_results(param_names, param_options, results, params):\\n\\n\\t# circuit/run_num where run_num is one before the existing one\\n\\tdirectory = params.circuit\\n\\tif not os.path.isdir(directory):\\n\\t\\tos.mkdir(directory)\\n\\truns = immediate_subdir(directory)\\n\\tlatest_run = 0\\n\\tif runs:\\n\\t\\tnatural_sort(runs)\\n\\t\\tlatest_run = get_trailing_num(runs[-1])\\n\\tdirectory = os.path.join(directory, \\\"run\\\" + str(latest_run+1))\\n\\n\\tprint(directory)\\n\\tif not os.path.isdir(directory):\\n\\t\\tos.mkdir(directory)\\n\\n\\twith Chdir(directory):\\n\\n\\t\\texport_results_to_csv(param_names, results, params)\\n\\n\\t\\tx = results.keys()\\n\\t\\ty = []\\n\\t\\tnext_figure = True\\n\\n\\t\\tp = 0\\n\\t\\tplt.figure()\\n\\t\\twhile p < len(param_names):\\n\\t\\t\\tprint(param_names[p])\\n\\n\\t\\t\\tif param_options[p]:\\n\\t\\t\\t\\tnf = True\\n\\t\\t\\t\\tfor option in param_options[p].split():\\n\\t\\t\\t\\t\\t# stopping has veto power (must all be True to pass)\\n\\t\\t\\t\\t\\tnf = nf and plot_options(option)\\n\\t\\t\\t\\tnext_figure = nf\\n\\n\\t\\t\\tif not next_figure:\\n\\t\\t\\t\\t# y becomes list of lists (for use with stackable plots)\\n\\t\\t\\t\\ty.append([result[p] for result in results.values()])\\n\\t\\t\\t\\tp += 1\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\telif not y:\\n\\t\\t\\t\\ty = [result[p] for result in results.values()]\\n\\n\\t\\t\\tlx = x[-1]\\n\\t\\t\\tly = y[-1]\\n\\t\\t\\tplot_method(x,y)\\n\\t\\t\\tplt.xlabel('iteration')\\n\\t\\t\\tplt.xlim(xmin=0)\\n\\t\\t\\t\\n\\t\\t\\tplt.ylabel(param_names[p])\\n\\n\\t\\t\\t# annotate the last value\\n\\t\\t\\tannotate_last(lx,ly)\\n\\n\\t\\t\\tif next_figure:\\n\\t\\t\\t\\tplt.savefig(param_names[p])\\n\\t\\t\\t\\tplt.figure()\\n\\n\\t\\t\\tp += 1\\n\\t\\t# in case the last figure hasn't been shuffled onto file yet\\n\\t\\tif not next_figure:\\n\\t\\t\\tplot_method(x,y)\\n\\t\\t\\tplt.savefig(param_names[-1])\",\n \"def plot_a_run(run, ax):\\n npz = np.load(run['npz_fname'])\\n ckg = npz['nums']\\n y_var = run['y_variable']\\n full_y = ckg[y_var]\\n x_var = run['x_variable']\\n full_x = ckg[x_var]\\n ### each run is a plot, but it could have multiple lines.\\n # this requires some magic, in seperating our data by the second var.\\n ## I ASSUME, and this is important, that only two variables change\\n x_to_plot = full_x\\n x_to_calc = full_x\\n y_to_plot = full_y\\n ckg_fc = ckg\\n if 'second_var' in run: \\n ckg_fc = ckg[:,0]\\n x_to_calc = full_x[:,0]\\n elif ('average_over' in run):#### always do log average\\n #y_to_plot = np.average(full_y, axis=1)\\n y_to_plot = np.exp(np.average(np.log(full_y), axis=1))\\n \\n ckg_fc = ckg[:,0]\\n x_to_plot = x_to_calc = full_x[:,0]\\n #pdb.set_trace()\\n ax.plot(x_to_plot, y_to_plot,\\\".\\\")\\n plot_localization_length(ax, ckg_fc['c'],ckg_fc['k'], ckg_fc['dis_param'], ckg_fc['number_of_points'] , x_to_calc)\\n ax.set_xlabel(x_var)\\n ax.set_ylabel(y_var)\",\n \"def plot_mode(params, filename_x=None, filename_z=None, z_range=None):\\r\\n kz_list = params['kz_list']\\r\\n layer_bottom_list = params['layer_bottom_list']\\r\\n N = len(kz_list)\\r\\n # Choose a range of z to plot:\\r\\n if z_range is not None:\\r\\n z_min = z_range[0]\\r\\n z_max = z_range[1]\\r\\n else:\\r\\n if N == 2:\\r\\n # For 2 layers, put the boundary in the middle, and show the wave\\r\\n # decaying on both sides\\r\\n z_max = min(4 / abs(kz.imag) for kz in kz_list)\\r\\n z_min = -z_max\\r\\n else:\\r\\n # For >= 3 layers, the layers should take up central half of plot\\r\\n z_max = 1.5 * layer_bottom_list[-1]\\r\\n z_min = -0.5 * layer_bottom_list[-1]\\r\\n # Calculate the data\\r\\n zs = np.linspace(z_min, z_max, num=200)\\r\\n Exs = np.array([Ex(z, params) for z in zs])\\r\\n Ezs = np.array([Ez(z, params) for z in zs])\\r\\n # Normalize the E-fields to max 1\\r\\n max_E = max(abs(Exs).max(), abs(Ezs).max())\\r\\n Exs = Exs / max_E\\r\\n Ezs = Ezs / max_E\\r\\n \\r\\n plt.figure()\\r\\n plt.plot(zs / nu.nm, Exs.real, zs / nu.nm, Exs.imag)\\r\\n for i in range(1,N):\\r\\n plt.axvline(x=layer_bottom_list[i] / nu.nm, color='k')\\r\\n plt.title('Ex profile at time 0 and 1/4 cycle later')\\r\\n plt.xlabel('z position (nm)')\\r\\n plt.ylabel('E-field (arbitrary units)')\\r\\n if filename_x is not None:\\r\\n plt.savefig(filename_x)\\r\\n \\r\\n plt.figure()\\r\\n plt.plot(zs / nu.nm, Ezs.real, zs / nu.nm, Ezs.imag)\\r\\n for i in range(1,N):\\r\\n plt.axvline(x=layer_bottom_list[i] / nu.nm, color='k')\\r\\n plt.title('Ez profile at time 0 and 1/4 cycle later')\\r\\n plt.xlabel('z position (nm)')\\r\\n plt.ylabel('E-field (arbitrary units)')\\r\\n if filename_z is not None:\\r\\n plt.savefig(filename_z)\",\n \"def residual_plots(test_data, mods, station=None, squared=False):\\r\\n import config\\r\\n learning_var = config.learning_var\\r\\n data = test_data.get_miniOD()\\r\\n mods.models[0].mod.load()\\r\\n pred = mods.models[0].mod.predict(test_data)\\r\\n test_data.miniOD = None\\r\\n if squared:\\r\\n data[test_data.get_stations_col(2015)] = (data[test_data.get_stations_col(2015)] - pred) ** 2 # /pred\\r\\n else:\\r\\n data[test_data.get_stations_col(2015)] = data[test_data.get_stations_col(2015)] - pred\\r\\n ind = data[data['Annee'] == 0].index\\r\\n data.drop(ind, inplace=True)\\r\\n print(data.columns.values)\\r\\n i = 0\\r\\n if station is None:\\r\\n ch_an = test_data.get_stations_col(2015)\\r\\n else:\\r\\n ch_an = 'End date ' + str(station)\\r\\n for ch in learning_var:\\r\\n if not (ch[0] == 'h') and not (ch in ['LV', 'MMJ', 'SD', 'poudrerie', 'verglas']):\\r\\n # data.boxplot(ch_an, by=ch)\\r\\n # if ch != 'Heure':\\r\\n plt.figure(i // 9)\\r\\n # plt.title('squared error / expectation')\\r\\n fig = plt.subplot(3, 3, (i % 9) + 1)\\r\\n i += 1\\r\\n # fig = plt.figure().add_subplot(111)\\r\\n fig.set_xlabel(ch)\\r\\n if squared:\\r\\n fig.set_ylabel('error²')\\r\\n else:\\r\\n fig.set_ylabel('error')\\r\\n l = []\\r\\n xaxis = np.unique(data[ch])\\r\\n print(ch, xaxis.shape)\\r\\n if xaxis.shape[0] < 20 or ch == 'Heure':\\r\\n for u in xaxis:\\r\\n l.append(data[ch_an][data[ch] == u])\\r\\n else:\\r\\n m = np.min(data[ch])\\r\\n M = np.max(data[ch])\\r\\n step = (M - m) / 20\\r\\n xaxis = np.arange(m, M, step)\\r\\n for u in xaxis:\\r\\n l.append(data[ch_an][(data[ch] >= u) * (data[ch] < u + step)])\\r\\n xaxis = xaxis.astype(int)\\r\\n # fig = plt.boxplot(ch_an, by=ch)\\r\\n # g = data.groupby(ch).mean()[ch_an]\\r\\n # v = data.groupby(ch).std()[ch_an]\\r\\n plt.boxplot(l, labels=xaxis)\\r\\n if squared:\\r\\n plt.ylim((0, 12))\\r\\n else:\\r\\n plt.ylim((-5, 5))\\r\\n # plt.plot(g, '-r')\\r\\n # plt.plot(g + v, ':r')\\r\\n # plt.plot(g - v, ':r')\\r\\n plt.show()\",\n \"def results_plot_fuel_reactor(self):\\n \\n import matplotlib.pyplot as plt \\n\\n # Total pressure profile\\n P = []\\n for z in self.MB_fuel.z:\\n P.append(value(self.MB_fuel.P[z]))\\n fig_P = plt.figure(1)\\n plt.plot(self.MB_fuel.z, P)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Total Pressure [bar]\\\") \\n\\n # Temperature profile\\n Tg = []\\n Ts = []\\n# Tw = []\\n for z in self.MB_fuel.z:\\n Tg.append(value(self.MB_fuel.Tg[z] - 273.15))\\n Ts.append(value(self.MB_fuel.Ts[z] - 273.15))\\n# Tw.append(value(self.MB_fuel.Tw[z]))\\n fig_T = plt.figure(2)\\n plt.plot(self.MB_fuel.z, Tg, label='Tg')\\n plt.plot(self.MB_fuel.z, Ts, label='Ts')\\n# plt.plot(self.MB_fuel.z, Tw, label='Tw')\\n plt.legend(loc=0,ncol=2)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Temperature [C]\\\") \\n \\n # Superficial gas velocity and minimum fluidization velocity\\n vg = []\\n umf = []\\n for z in self.MB_fuel.z:\\n vg.append(value(self.MB_fuel.vg[z]))\\n umf.append(value(self.MB_fuel.umf[z]))\\n fig_vg = plt.figure(3)\\n plt.plot(self.MB_fuel.z, vg, label='vg')\\n plt.plot(self.MB_fuel.z, umf, label='umf')\\n plt.legend(loc=0,ncol=2)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Superficial gas velocity [m/s]\\\")\\n \\n # Gas components molar flow rate\\n for j in self.MB_fuel.GasList:\\n F = []\\n for z in self.MB_fuel.z:\\n F.append(value(self.MB_fuel.F[z,j]))\\n fig_F = plt.figure(4)\\n plt.plot(self.MB_fuel.z, F, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Gas component molar flow rate, F [mol/s]\\\") \\n \\n # Bulk gas phase total molar flow rate\\n Ftotal = []\\n for z in self.MB_fuel.z:\\n Ftotal.append(value(self.MB_fuel.Ftotal[z]))\\n fig_Ftotal = plt.figure(5)\\n plt.plot(self.MB_fuel.z, Ftotal)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Total molar gas flow rate [mol/s]\\\") \\n\\n # Solid components mass flow rate\\n for j in self.MB_fuel.SolidList:\\n M = []\\n for z in self.MB_fuel.z:\\n M.append(value(self.MB_fuel.Solid_M[z,j]))\\n fig_M = plt.figure(6)\\n plt.plot(self.MB_fuel.z, M, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Solid components mass flow rate [kg/s]\\\")\\n \\n # Bulk solid phase total molar flow rate\\n Mtotal = []\\n for z in self.MB_fuel.z:\\n Mtotal.append(value(self.MB_fuel.Solid_M_total[z]))\\n fig_Mtotal = plt.figure(7)\\n plt.plot(self.MB_fuel.z, Mtotal)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Solid total mass flow rate [kg/s]\\\") \\n \\n # Gas phase concentrations\\n for j in self.MB_fuel.GasList:\\n Cg = []\\n for z in self.MB_fuel.z:\\n Cg.append(value(self.MB_fuel.Cg[z,j]))\\n fig_Cg = plt.figure(8)\\n plt.plot(self.MB_fuel.z, Cg, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Concentration [mol/m3]\\\") \\n \\n # Gas phase mole fractions\\n for j in self.MB_fuel.GasList:\\n y = []\\n for z in self.MB_fuel.z:\\n y.append(value(self.MB_fuel.y[z,j]))\\n fig_y = plt.figure(9)\\n plt.plot(self.MB_fuel.z, y, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"y [-]\\\") \\n \\n # Solid phase mass fractions\\n for j in self.MB_fuel.SolidList:\\n x = []\\n for z in self.MB_fuel.z:\\n x.append(value(self.MB_fuel.x[z,j]))\\n fig_x = plt.figure(10)\\n plt.plot(self.MB_fuel.z, x, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"x [-]\\\") \\n\\n # Total mass fraction\\n xtot = []\\n for z in self.MB_fuel.z:\\n xtot.append(value(self.MB_fuel.xtot[z]))\\n fig_xtot = plt.figure(11)\\n plt.plot(self.MB_fuel.z, xtot)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Total mass fraction [-]\\\") \\n \\n # # Gas mix density\\n # rhog = []\\n # for z in self.MB_fuel.z:\\n # rhog.append(value(self.MB_fuel.rho_vap[z]))\\n # fig_rhog = plt.figure(23)\\n # plt.plot(self.MB_fuel.z, rhog)\\n # plt.grid()\\n # plt.xlabel(\\\"Bed height [-]\\\")\\n # plt.ylabel(\\\"Gas mix density [kg/m3]\\\") \\n \\n # Fe conversion\\n X_Fe = []\\n for z in self.MB_fuel.z:\\n X_Fe.append(value(self.MB_fuel.X[z])*100)\\n fig_X_Fe = plt.figure(13)\\n plt.plot(self.MB_fuel.z, X_Fe)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Fraction of metal oxide converted [%]\\\")\",\n \"def plot_visualization(path_results, x_data, y_data, variant_mode, nb_classes, signal_test, args):\\n\\n\\t#path_tsne = path_results + \\\"/Visualization/train/\\\" + str(args.step) + \\\"_2d.csv\\\"\\n\\t#data_frame = pd.read_csv(path_tsne)\\n\\t\\n\\tpath_maping = path_results + \\\"/Maping/\\\" + str(args.subject).split(\\\".txt\\\")[0] + \\\"/\\\"\\n\\tfilename = path_maping + \\\"maping_\\\" + str(args.step) + \\\"_\\\" + str(args.subject).split(\\\".txt\\\")[0] + \\\"_stick\\\" + str(args.stick) + \\\".png\\\"\\n\\n\\tprint(\\\"path_save maping\\\", path_maping)\\n\\n\\tif not os.path.exists(path_maping):\\n\\t\\tos.makedirs(path_maping)\\n\\n\\t#print(\\\"path_tsne\\\", path_tsne)\\n\\n\\tlabel_maping = np.array([10])\\n\\n\\tx_data = np.concatenate((x_data,signal_test),axis=0)\\n\\ty_data = np.concatenate((y_data,label_maping),axis=0)\\n\\n\\tprint(\\\"x_data concatenate\\\",x_data.shape)\\n\\tprint(\\\"y_data concatenate\\\",y_data.shape)\\n\\n\\tdata_frame = tsne_2d(x_data, y_data)\\n\\n\\t\\n\\t\\n\\tgroups = data_frame.groupby('label')\\n\\n\\tcluster_names, cluster_colors = get_target_names_dr(nb_classes, args.mode, args, variant_mode)\\n\\n\\tfig = plt.figure(figsize=(20, 10))\\n\\tax = fig.add_subplot(111)\\n\\tax.margins(0.05) # Optional, just adds 5% padding to the autoscaling\\n\\tfor name, group in groups:\\n\\t\\t\\n\\t\\tif cluster_names[name] == str(args.subject):\\n\\t\\t\\tax.scatter(group.x, group.y, marker='D', s=150, edgecolors = 'face',label=cluster_names[name], color=cluster_colors[name])\\n\\t\\telse:\\n\\t\\t\\tax.scatter(group.x, group.y, marker='o', label=cluster_names[name], color=cluster_colors[name])\\n\\n\\tax.legend(numpoints=1) #show legend with only 1 point\\n\\tplt.savefig(filename) #save the plot\",\n \"def comp2profile(output):\\n\\n # Load components\\n data = '/home/scott/data/insar/cvz/los2xyz/components.txt_backup'\\n lon,lat,x,ur,uz = np.loadtxt(data,unpack=True)\\n\\n # Load FEM output\\n points = '/home/scott/research/models/pylith/3d/fialko2012/model3_agu/output_points.txt'\\n pointsh5 = '/home/scott/research/models/pylith/3d/fialko2012/model3_agu/output/elastic/apmb/points.h5'\\n x_fem, ur_fem, uz_fem = pu.extract_points(pointsh5)\\n #NOTE: in this case need radial distance b/c not on x-axis\\n #x = np.sqrt(2)*1e3*np.loadtxt(points,usecols=[0])\\n # NOTE: cludge fix for negative radial displacements in dipole model\\n ur_fem[x_fem >= 40000] = -ur_fem[x_fem >= 40000]\\n #ur_fem = np.abs(ur_fem)\\n\\n #Convert to cm units for plotting\\n x_fem = x_fem/1000\\n ur_fem = ur_fem * 100.0\\n uz_fem = uz_fem * 100.0\\n\\n #NOTE: must interpolate either insar data or FEM to compare at values at same radial distance\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n plt.plot(x, uz, 'b.-', lw=2, label='data')\\n plt.plot(x, ur, 'g.-', lw=2)\\n plt.plot(x_fem, uz_fem, marker='o', ls='None', lw=2, mec='b', mfc='None',label='FEM')\\n plt.plot(x_fem, ur_fem, marker='o', ls='None', lw=2, mec='g', mfc='None')\\n plt.axhline(color='k')\\n plt.title('FEM vs. Data')\\n plt.xlabel('Radial distance [km]')\\n plt.ylabel('Displacement [cm]')\\n plt.grid(True)\\n plt.xlim(0,150) #only show out to 150km\\n plt.legend()\",\n \"def plot_data(data, par, par_names, par_fixed, output_dir='./'):\\n\\n datasets = dict()\\n\\n for data_point in data:\\n experiment_name = data_point.par['experiment_name']\\n datasets.setdefault(experiment_name, list()).append(data_point)\\n\\n for experiment_name, dataset in datasets.items():\\n\\n # ##### Matplotlib ######\\n\\n name_pdf = ''.join([experiment_name, '.pdf'])\\n name_pdf = os.path.join(output_dir, name_pdf)\\n\\n name_txt = ''.join([experiment_name, '.fit'])\\n name_txt = os.path.join(output_dir, name_txt)\\n\\n print(\\\" * {} [.fit]\\\".format(name_pdf))\\n\\n # #######################\\n\\n data_grouped = group_data(dataset)\\n profiles, r2_min, r2_max = compute_profiles(data_grouped)\\n ymin, ymax = set_lim([r2_min, r2_max], 0.10)\\n\\n with PdfPages(name_pdf) as file_pdf, open(name_txt, 'w') as file_txt:\\n\\n for (_index, id_), profile in sorted(profiles.items()):\\n write_profile(id_, profile, file_txt)\\n\\n ###### Matplotlib ######\\n\\n fig = plt.figure(1, frameon=True)\\n ax = fig.add_subplot(111)\\n\\n ax.axhline(0, color='black', alpha=0.87)\\n\\n ########################\\n\\n frq, r2_cal, r2_exp, r2_erd, r2_eru = profile[0]\\n\\n ax.plot(\\n frq,\\n r2_cal,\\n linestyle='-',\\n color=red200,\\n zorder=2,\\n )\\n\\n ax.errorbar(\\n frq,\\n r2_exp,\\n yerr=[r2_erd, r2_eru],\\n fmt='o',\\n color=red500,\\n zorder=3,\\n )\\n\\n xmin, xmax = set_lim(frq, 0.10)\\n\\n ax.set_xlim(xmin, xmax)\\n ax.set_ylim(ymin, ymax)\\n\\n ax.xaxis.set_major_locator(MaxNLocator(6))\\n ax.yaxis.set_major_locator(MaxNLocator(6))\\n\\n ax.set_xlabel(r'$\\\\mathregular{\\\\nu_{CPMG} \\\\ (Hz)}$')\\n ax.set_ylabel(\\n r'$\\\\mathregular{R_{2,eff} \\\\ (s^{-1})}$')\\n\\n ax.set_title('{:s}'.format(id_.upper()))\\n\\n fig.tight_layout()\\n\\n ########################\\n\\n file_pdf.savefig()\\n plt.close()\\n\\n ########################\\n\\n return\",\n \"def parameter_plots(result_file, fitted_params, resultType, planet,\\n plotPublished = False, publishedDataFile = None,\\n saveplot=True, foldext='', eclipse = False):\\n\\n inputData = np.genfromtxt(result_file, dtype=None, delimiter=', ', comments='#', encoding = None)\\n\\n # Find out the indices of the type of average and the error\\n if 't0' in str(inputData[0]):\\n values = [s for i, s in enumerate(inputData[0]) if 't0' in s]\\n indices = [i for i, s in enumerate(inputData[0]) if 't0' in s]\\n Nvalues = len(indices)\\n Nbefore = indices[0]\\n\\n if resultType == 'Mean':\\n k = values.index('t0_mu') + Nbefore\\n e = values.index('t0_std') + Nbefore\\n\\n elif resultType == 'Median':\\n k = values.index('t0_med') + Nbefore\\n e = values.index('t0_poserr') + Nbefore\\n\\n elif resultType == 'LSQ':\\n k = values.index('t0_lqs') + Nbefore\\n e = values.index('t0_std') + Nbefore\\n\\n else:\\n raise ValueError(\\\"Result type not recognised, please chose Mean, Median or LSQ.\\\")\\n\\n elif 't_secondary' in str(inputData[0]):\\n values = [s for i, s in enumerate(inputData[0]) if 't_secondary' in s]\\n indices = [i for i, s in enumerate(inputData[0]) if 't_secondary' in s]\\n Nvalues = len(indices)\\n Nbefore = indices[0]\\n\\n if resultType == 'Mean':\\n k = values.index('t_secondary_mu') + Nbefore\\n e = values.index('t_secondary_std') + Nbefore\\n\\n elif resultType == 'Median':\\n k = values.index('t_secondary_med') + Nbefore\\n e = values.index('t_secondary_poserr') + Nbefore\\n\\n elif resultType == 'LSQ':\\n k = values.index('t_secondary_lqs') + Nbefore\\n e = values.index('t_secondary_std') + Nbefore\\n\\n else:\\n raise ValueError(\\\"Result type not recognised, please chose Mean, Median or LSQ.\\\")\\n\\n elif 'rp' in str(inputData[0]):\\n values = [s for i, s in enumerate(inputData[0]) if 'rp' in s]\\n indices = [i for i, s in enumerate(inputData[0]) if 'rp' in s]\\n Nvalues = len(indices)\\n Nbefore = indices[0]\\n\\n if resultType == 'Mean':\\n k = values.index('rp_mu') + Nbefore\\n e = values.index('rp_std') + Nbefore\\n\\n elif resultType == 'Median':\\n k = values.index('rp_med') + Nbefore\\n e = values.index('rp_poserr') + Nbefore\\n\\n elif resultType == 'LSQ':\\n k = values.index('rp_lqs') + Nbefore\\n e = values.index('rp_std') + Nbefore\\n\\n else:\\n raise ValueError(\\\"Result type not recognised, please chose Mean, Median or LSQ.\\\")\\n else:\\n raise ValueError(\\\"Not implemented indices selection if we have not fit for t0 or t_secondary or rp\\\")\\n\\n # If we have some published values, create a table of the Nsigma difference\\n if plotPublished:\\n print \\\"\\\\nOpening file for writing nsigma from published...\\\"\\n f = open(\\\"{2}/PhD/SpitzerTransits/{0}{1}/{0}_NsigmaFromPublished.txt\\\".format(planet, foldext, os.getenv('HOME')), 'w')\\n print >> f, (\\\"Param\\\\tAOR\\\\tChannel\\\\tMethod\\\\tPub_val\\\\tPub_err\\\\tMy_val\\\\tMy_err\\\\tSigma\\\\tNsigdiff\\\")\\n print >> f, (\\\"==============================================================================================\\\")\\n\\n f2 = open(\\\"{2}/PhD/SpitzerTransits/{0}{1}/{0}_NsigmaBetweenChannels.txt\\\".format(planet, foldext, os.getenv('HOME')), 'w')\\n print >> f2, (\\\"Param\\\\tMethod\\\\tch1_val\\\\tch1_err\\\\tch2_val\\\\tch2_err\\\\tSigma\\\\tNsigdiff\\\")\\n print >> f2, (\\\"==============================================================================================\\\")\\n\\n for p in range(len(fitted_params)):\\n\\n # Figure out which parameter we are looking at\\n param = fitted_params[p]\\n\\n # Get the AOR labels for poly and PLD and check that they are the same for channel 1\\n ch1polyAORs = [line[0] for line in inputData if 'ch1' in line and 'poly' in line]\\n ch1PLDAORs = [line[0] for line in inputData if 'ch1' in line and 'PLD' in line]\\n\\n if ch1polyAORs != ch1PLDAORs:\\n warnings.warn(\\\"The PLD and poly AORs for channel 1 are not the same, plotted labels might be wrong!\\\")\\n\\n # Get the Mean and stddev of poly and PLD for the parameter that we are looking at for channel 1\\n ch1polyMean = [float(line[k+p*Nvalues]) for line in inputData if 'ch1' in line and 'poly' in line]\\n ch1PLDMean = [float(line[k+p*Nvalues]) for line in inputData if 'ch1' in line and 'PLD' in line]\\n if resultType == 'Mean' or resultType == 'LSQ':\\n ch1polyStds = np.array([float(line[e+p*Nvalues]) for line in inputData if 'ch1' in line and 'poly' in line])\\n ch1PLDStds = np.array([float(line[e+p*Nvalues]) for line in inputData if 'ch1' in line and 'PLD' in line])\\n elif resultType == 'Median':\\n # asymetric errors\\n ch1polyStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData if 'ch1' in line and 'poly' in line]).T\\n ch1PLDStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData if 'ch1' in line and 'PLD' in line]).T\\n\\n # Get the AOR labels for poly and PLD and check that they are the same for channel 2\\n ch2polyAORs = [line[0] for line in inputData if 'ch2' in line and 'poly' in line]\\n ch2PLDAORs = [line[0] for line in inputData if 'ch2' in line and 'PLD' in line]\\n\\n if ch2polyAORs != ch2PLDAORs:\\n warnings.warn(\\\"The PLD and poly AORs for channel 2 are not the same, plotted labels might be wrong!\\\")\\n\\n # Get the Mean and stddev of poly and PLD for the parameter that we are looking at for channel 2\\n ch2polyMean = [float(line[k+p*Nvalues]) for line in inputData if 'ch2' in line and 'poly' in line]\\n ch2PLDMean = [float(line[k+p*Nvalues]) for line in inputData if 'ch2' in line and 'PLD' in line]\\n if resultType == 'Mean' or resultType == 'LSQ':\\n ch2polyStds = np.array([float(line[e+p*Nvalues]) for line in inputData if 'ch2' in line and 'poly' in line])\\n ch2PLDStds = np.array([float(line[e+p*Nvalues]) for line in inputData if 'ch2' in line and 'PLD' in line])\\n elif resultType == 'Median':\\n # asymmetric errors\\n ch2polyStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData if 'ch2' in line and 'poly' in line]).T\\n ch2PLDStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData if 'ch2' in line and 'PLD' in line]).T\\n\\n # Calculate the weighted means...\\n if len(ch1polyMean) > 1. and param != 't0':\\n WMch1poly, TSch1poly = weightedMean(np.array(ch1polyMean), np.array(ch1polyStds))\\n WMch1PLD, TSch1PLD = weightedMean(np.array(ch1PLDMean).flatten(), np.array(ch1PLDStds))\\n WMch2poly, TSch2poly = weightedMean(np.array(ch2polyMean), np.array(ch2polyStds))\\n WMch2PLD, TSch2PLD = weightedMean(np.array(ch2PLDMean), np.array(ch2PLDStds))\\n\\n # Initialise plotting the parameters\\n fig = plt.figure(figsize=(8,5))\\n ax1 = fig.add_axes([0.1, 0.1, 0.4, 0.8])\\n ax2 = fig.add_axes([0.5, 0.1, 0.4, 0.8])\\n ax1.set_title(r'Ch1 ($3.6\\\\mu m$)')\\n ax2.set_title(r'Ch2 ($4.5\\\\mu m$)')\\n ax1.set_ylabel(param)\\n\\n # Channel 1\\n # polynomial\\n ax1.errorbar(np.array(range(len(ch1polyMean)))-0.05, ch1polyMean, yerr = ch1polyStds, marker = 'o', linestyle='', color ='b', label = 'Poly')\\n # PLD\\n ax1.errorbar(np.array(range(len(ch1PLDMean)))+0.05, ch1PLDMean, yerr = ch1PLDStds, marker = 'o', linestyle='', color = 'r', label = 'PLD')\\n # labels\\n ax1.set_xticks(range(len(ch1PLDMean)))\\n ax1.set_xticklabels(ch1polyAORs, rotation='vertical')\\n\\n\\n # Channel2\\n # polynomial\\n ax2.errorbar(np.array(range(len(ch2polyMean )))-0.05, ch2polyMean, yerr = ch2polyStds, marker = 'o', linestyle='', color ='b')\\n # PLD\\n ax2.errorbar(np.array(range(len(ch2PLDMean )))+0.05, ch2PLDMean, yerr = ch2PLDStds, marker = 'o', linestyle='', color = 'r')\\n # labels\\n ax2.set_xticks(range(len(ch2PLDMean)))\\n ax2.set_xticklabels(ch2polyAORs, rotation='vertical')\\n\\n # Plot the weighted means\\n if len(ch1polyMean) > 1. and param != 't0':\\n ax1.axhline(WMch1poly, color = 'b')\\n ax1.axhspan(WMch1poly - TSch1poly,\\n WMch1poly + TSch1poly,\\n alpha = 0.3, color='b', label='Weighted Mean')\\n ax1.axhline(WMch1PLD, color = 'r')\\n ax1.axhspan(WMch1PLD - TSch1PLD,\\n WMch1PLD + TSch1PLD,\\n alpha = 0.3, color='r',label='Weighted Mean')\\n\\n ax2.axhline(WMch2poly, color = 'b')\\n ax2.axhspan(WMch2poly - TSch2poly,\\n WMch2poly + TSch2poly,\\n alpha = 0.3, color='b')\\n ax2.axhline(WMch2PLD, color = 'r')\\n ax2.axhspan(WMch2PLD - TSch2PLD,\\n WMch2PLD + TSch2PLD,\\n alpha = 0.3, color='r')\\n\\n if plotPublished:\\n # Plot the published values if they they are given\\n # and calculate Nsigma from published and save to a file\\n data = np.genfromtxt(publishedDataFile, dtype=None, delimiter=', ', encoding = None)\\n\\n if param in data.T[0].tolist():\\n\\n pIdx = data.T[0].tolist().index(param)\\n ax1.axhline(float(data[pIdx][1]), color = 'k', linestyle = 'dashed')\\n ax1.axhspan(float(data[pIdx][1]) - float(data[pIdx][2]),\\n float(data[pIdx][1]) + float(data[pIdx][2]),\\n alpha = 0.3, color='k',label='Literature')\\n\\n ax2.axhline(float(data[pIdx][3]),color = 'k', linestyle = 'dashed')\\n ax2.axhspan(float(data[pIdx][3]) - float(data[pIdx][4]),\\n float(data[pIdx][3]) + float(data[pIdx][4]),\\n alpha = 0.3, color='k',label='Literature')\\n\\n # Save the number of sigma to a file\\n # Deal with polynomial first\\n for i in range(len(ch1polyAORs)):\\n print >> f, ('{0:}\\\\t{1:}\\\\t{2:}\\\\t{3:}\\\\t{4:.4f}\\\\t{5:.4f}\\\\t{6:.4f}\\\\t{7:.4f}\\\\t{8:.4f}\\\\t{9:.4f}'.format(\\n param, ch1polyAORs[i], 'ch1', 'poly',\\n float(data[pIdx][1]), float(data[pIdx][2]), #channel 1\\n float(ch1polyMean[i]), float(ch1polyStds.T[i].max()), # choose the biggest error\\n *nsigma(float(data[pIdx][1]), float(data[pIdx][2]),float(ch1polyMean[i]), float(ch1polyStds.T[i].max()))))\\n\\n for i in range(len(ch2polyAORs)):\\n print >> f, ('{0:}\\\\t{1:}\\\\t{2:}\\\\t{3:}\\\\t{4:.4f}\\\\t{5:.4f}\\\\t{6:.4f}\\\\t{7:.4f}\\\\t{8:.4f}\\\\t{9:.4f}'.format(\\n param, ch2polyAORs[i], 'ch2', 'poly',\\n float(data[pIdx][3]), float(data[pIdx][4]), #channel 2\\n float(ch2polyMean[i]), float(ch2polyStds.T[i].max()), # choose the biggest error\\n *nsigma(float(data[pIdx][3]), float(data[pIdx][4]),float(ch2polyMean[i]), float(ch2polyStds.T[i].max()))))\\n\\n # PLD\\n for i in range(len(ch1PLDAORs)):\\n print >> f, ('{0:}\\\\t{1:}\\\\t{2:}\\\\t{3:}\\\\t{4:.4f}\\\\t{5:.4f}\\\\t{6:.4f}\\\\t{7:.4f}\\\\t{8:.4f}\\\\t{9:.4f}'.format(\\n param, ch1PLDAORs[i], 'ch1', 'PLD',\\n float(data[pIdx][1]), float(data[pIdx][2]), #channel 1\\n float(ch1PLDMean[i]), float(ch1PLDStds.T[i].max()), # choose the biggest error\\n *nsigma(float(data[pIdx][1]), float(data[pIdx][2]),float(ch1PLDMean[i]), float(ch1PLDStds.T[i].max()))))\\n\\n for i in range(len(ch2PLDAORs)):\\n print >> f, ('{0:}\\\\t{1:}\\\\t{2:}\\\\t{3:}\\\\t{4:.4f}\\\\t{5:.4f}\\\\t{6:.4f}\\\\t{7:.4f}\\\\t{8:.4f}\\\\t{9:.4f}'.format(\\n param, ch2PLDAORs[i], 'ch2', 'PLD',\\n float(data[pIdx][3]), float(data[pIdx][4]), #channel 2\\n float(ch2PLDMean[i]), float(ch2PLDStds.T[i].max()), # choose the biggest error\\n *nsigma(float(data[pIdx][3]), float(data[pIdx][4]),float(ch2PLDMean[i]), float(ch2PLDStds.T[i].max()))))\\n else:\\n pass\\n\\n # Write the difference between the two channels to a text file\\n if param != 't0' and param != 'rp':\\n if len(ch1polyMean) > 1.:\\n # polynomial\\n for i in range(len(ch1polyAORs)):\\n print >> f2, ('{0:}\\\\t{1:}\\\\t{2:.4f}\\\\t{3:.4f}\\\\t{4:.4f}\\\\t{5:.4f}\\\\t{6:.4f}\\\\t{7:.4f}'.format(\\n param, 'poly',\\n float(WMch1poly[i]), float(TSch1poly.T[i].max()), #channel 1\\n float(WMch2poly[i]), float(TSch2poly.T[i].max()), # choose the biggest error\\n *nsigma(float(WMch1poly[i]), float(TSch1poly.T[i].max()),\\n float(WMch2poly[i]), float(TSch2poly.T[i].max()))))\\n\\n # PLD\\n for i in range(len(ch1polyAORs)):\\n print >> f2, ('{0:}\\\\t{1:}\\\\t{2:.4f}\\\\t{3:.4f}\\\\t{4:.4f}\\\\t{5:.4f}\\\\t{6:.4f}\\\\t{7:.4f}'.format(\\n param, 'PLD',\\n float(WMch1PLD[i]), float(TSch1PLD.T[i].max()), #channel 1\\n float(WMch2PLD[i]), float(TSch2PLD.T[i].max()), # choose the biggest error\\n *nsigma(float(WMch1PLD[i]), float(TSch1PLD.T[i].max()),\\n float(WMch2PLD[i]), float(TSch2PLD.T[i].max()))))\\n else:\\n # polynomial\\n for i in range(len(ch1polyAORs)):\\n print >> f2, ('{0:}\\\\t{1:}\\\\t{2:.4f}\\\\t{3:.4f}\\\\t{4:.4f}\\\\t{5:.4f}\\\\t{6:.4f}\\\\t{7:.4f}'.format(\\n param, 'poly',\\n float(ch1polyMean[i]), float(ch1polyStds.T[i].max()), #channel 1\\n float(ch2polyMean[i]), float(ch2polyStds.T[i].max()), # choose the biggest error\\n *nsigma(float(ch1polyMean[i]), float(ch1polyStds.T[i].max()),\\n float(ch2polyMean[i]), float(ch2polyStds.T[i].max()))))\\n\\n # PLD\\n for i in range(len(ch1polyAORs)):\\n print >> f2, ('{0:}\\\\t{1:}\\\\t{2:.4f}\\\\t{3:.4f}\\\\t{4:.4f}\\\\t{5:.4f}\\\\t{6:.4f}\\\\t{7:.4f}'.format(\\n param, 'PLD',\\n float(ch1PLDMean[i]), float(ch1PLDStds.T[i].max()), #channel 1\\n float(ch2PLDMean[i]), float(ch2PLDStds.T[i].max()), # choose the biggest error\\n *nsigma(float(ch1PLDMean[i]), float(ch1PLDStds.T[i].max()),\\n float(ch2PLDMean[i]), float(ch2PLDStds.T[i].max()))))\\n else:\\n pass\\n\\n\\n # Set the y limits of both plots to be the same sacle and to include both ch1 and ch2 points\\n axis1ylim = ax1.get_ylim()\\n axis2ylim = ax2.get_ylim()\\n if ax1.get_ylim()[0] < ax2.get_ylim()[0]:\\n ymin = ax1.get_ylim()[0]\\n else:\\n ymin = ax2.get_ylim()[0]\\n if ax1.get_ylim()[1] < ax2.get_ylim()[1]:\\n ymax = ax2.get_ylim()[1]\\n else:\\n ymax = ax1.get_ylim()[1]\\n ax1.set_ylim(ymin,ymax)\\n ax2.set_ylim(ax1.get_ylim())\\n ax2.get_yaxis().set_visible(False)\\n\\n ax1.legend(loc = 'best')\\n\\n\\n # Save if required\\n if saveplot:\\n plt.savefig(\\\"{3}/PhD/SpitzerTransits/{0}{1}/{0}_{2}.png\\\".format(planet,foldext,param,os.getenv('HOME')),bbox_inches='tight')\\n plt.close()\\n if plotPublished:\\n f.close()\\n else:\\n pass\\n f2.close()\",\n \"def plot_recovery_results(\\n recovery_results, variable_parameter, limits=None, ticks=None\\n):\\n\\n fig, axs = plt.subplots(3, 3, figsize=cm2inch(9, 9), sharex=True, sharey=True)\\n\\n parameter_names = [\\\"alpha_pos\\\", \\\"alpha_neg\\\", \\\"beta\\\"]\\n parameter_labels = {\\n \\\"alpha_pos\\\": r\\\"$\\\\alpha^{+}$\\\",\\n \\\"alpha_neg\\\": r\\\"$\\\\alpha^{-}$\\\",\\n \\\"beta\\\": r\\\"$\\\\beta$\\\",\\n }\\n\\n others = [p for p in parameter_names if p != variable_parameter]\\n\\n df = recovery_results.loc[recovery_results[\\\"variable\\\"] == variable_parameter]\\n\\n for i, other0_val in enumerate([\\\"low\\\", \\\"medium\\\", \\\"high\\\"]):\\n for j, other1_val in enumerate([\\\"low\\\", \\\"medium\\\", \\\"high\\\"]):\\n label = (\\n parameter_labels[others[0]]\\n + f\\\": {other0_val}\\\"\\n + \\\"\\\\n\\\"\\n + parameter_labels[others[1]]\\n + f\\\": {other1_val}\\\"\\n )\\n\\n ax = axs[i, j]\\n ax.set_title(label)\\n\\n df_ij = df.loc[\\n (df[f\\\"{others[0]}_level\\\"] == other0_val)\\n & (df[f\\\"{others[1]}_level\\\"] == other1_val)\\n ]\\n\\n # Scatter plot of generating and recovered parameters\\n ax.plot(\\n df_ij[f\\\"{variable_parameter}\\\"],\\n df_ij[f\\\"{variable_parameter}_hat\\\"],\\n \\\"o\\\",\\n markeredgewidth=0.25,\\n )\\n\\n # Set ticks and boundaries\\n if ticks is not None:\\n ax.set_xticks(ticks)\\n ax.set_yticks(ticks)\\n\\n if limits is None:\\n limits = [\\n df_ij[\\n [variable_parameter, f\\\"{variable_parameter}_hat\\\"]\\n ].values.min(),\\n df_ij[\\n [variable_parameter, f\\\"{variable_parameter}_hat\\\"]\\n ].values.max(),\\n ]\\n ax.set_xlim(limits)\\n ax.set_ylim(limits)\\n\\n # Run robust linear regression and Spearman correlation\\n gen = df_ij[variable_parameter].values\\n rec = df_ij[f\\\"{variable_parameter}_hat\\\"].values\\n r, p = spearmanr(gen, rec)\\n endog = rec\\n exog = sm.add_constant(gen)\\n model = sm.RLM(endog=endog, exog=exog)\\n results = model.fit()\\n\\n # Plot regression line\\n intercept, beta = results.params\\n x = np.linspace(*ax.get_xlim(), 100)\\n ax.plot(x, intercept + beta * x, color=\\\"C0\\\", alpha=0.7, zorder=0)\\n\\n # Annotate regression statistics\\n pstring = make_pstring(p)\\n annotation = (\\n f\\\"r = {r:.2f}, \\\"\\n + pstring\\n + f\\\"\\\\nIntercept = {intercept:.2f}\\\\nSlope = {beta:.2f}\\\"\\n )\\n ax.annotate(\\n annotation,\\n (0.95, 0.05),\\n xycoords=\\\"axes fraction\\\",\\n ha=\\\"right\\\",\\n va=\\\"bottom\\\",\\n fontsize=3,\\n )\\n\\n # Plot diagonal line\\n ax.plot(\\n ax.get_xlim(),\\n ax.get_ylim(),\\n \\\"-\\\",\\n linewidth=0.5,\\n color=\\\"lightgray\\\",\\n zorder=-1,\\n )\\n\\n for ij in range(3):\\n axs[-1, ij].set_xlabel(\\\"Gen.\\\")\\n axs[ij, 0].set_ylabel(\\\"Rec.\\\")\\n\\n fig.tight_layout()\\n fig.suptitle(\\n r\\\"$\\\\bf{\\\" + parameter_labels[variable_parameter][1:-1] + \\\"}$\\\",\\n y=1.05,\\n fontweight=\\\"bold\\\",\\n )\\n\\n return fig, axs\",\n \"def P_AI_Rocky(in_dict):\\n # START\\n fs = 16\\n plt.rc('font', size=fs)\\n fig = plt.figure(figsize=(14,12))\\n ds = nc.Dataset(in_dict['fn'])\\n\\n # PLOT CODE\\n aa = [-122.8, -122.54, 47.92, 48.22]\\n import cmocean\\n cmap = cmocean.cm.balance\\n # cmap = 'RdYlBu_r'\\n\\n from warnings import filterwarnings\\n filterwarnings('ignore') # skip some warning messages\\n \\n # plot Code\\n \\n # calculate divergence and vorticity\\n uu = ds['u'][0, -1, :, :]\\n vv = ds['v'][0, -1, :, :]\\n u = zfun.fillit(uu)\\n v = zfun.fillit(vv)\\n u[np.isnan(u)] = 0\\n v[np.isnan(v)] = 0\\n \\n G = zrfun.get_basic_info(in_dict['fn'], only_G=True)\\n \\n dive = ((np.diff(u, axis=1)/G['DX'][:, 1:-1])[1:-1, :]\\n + (np.diff(v, axis = 0)/G['DY'][1:-1, :])[:, 1:-1])\\n #dive[G['mask_rho'][1:-1,1:-1]==False] = np.nan\\n \\n vort = np.diff(v, axis=1)/G['DX'][1:,1:] - np.diff(u, axis=0)/G['DY'][1:,1:]\\n #vort[G['mask_rho'][1:,1:]==False] = np.nan\\n \\n scl = 2e-3\\n \\n # panel 1\\n ax = fig.add_subplot(121)\\n # cs = plt.pcolormesh(G['lon_psi'], G['lat_psi'], dive/scl, cmap=cmap,\\n # vmin=-1, vmax=1)\\n cs = plt.pcolormesh(G['lon_rho'][1:-1,1:-1], G['lat_rho'][1:-1,1:-1], dive/scl, cmap=cmap,\\n vmin=-1, vmax=1, shading='gouraud')\\n tstr = (r'Surface Divergence (%0.1e $s^{-1}$)' % (scl))\\n #pfun.add_bathy_contours(ax, ds, txt=True)\\n pfun.add_coast(ax)\\n ax.axis(aa)\\n pfun.dar(ax)\\n ax.set_xlabel('Longitude')\\n ax.set_ylabel('Latitude')\\n ax.set_title(tstr)\\n pfun.add_info(ax, in_dict['fn'])\\n ax.set_xticks([-122.8, -122.7, -122.6])\\n ax.set_yticks([48, 48.1, 48.2])\\n #\\n # panel 2\\n ax = fig.add_subplot(122)\\n # cs = plt.pcolormesh(G['lon_rho'], G['lat_rho'], vort/scl, cmap=cmap,\\n # vmin=-1, vmax=1)\\n cs = plt.pcolormesh(G['lon_psi'], G['lat_psi'], vort/scl, cmap=cmap,\\n vmin=-1, vmax=1, shading='gouraud')\\n tstr = (r'Surface Vorticity (%0.1e $s^{-1}$)' % (scl))\\n ax.set_xticks([-122.8, -122.7, -122.6])\\n ax.set_yticks([])\\n #fig.colorbar(cs)\\n \\n # Inset colorbar\\n from mpl_toolkits.axes_grid1.inset_locator import inset_axes\\n cbaxes = inset_axes(ax, width=\\\"4%\\\", height=\\\"40%\\\", loc='lower left')\\n fig.colorbar(cs, cax=cbaxes, orientation='vertical')\\n \\n #pfun.add_bathy_contours(ax, ds)\\n pfun.add_coast(ax)\\n ax.axis(aa)\\n pfun.dar(ax)\\n ax.set_xlabel('Longitude')\\n ax.set_title(tstr) \\n \\n #fig.tight_layout()\\n # FINISH\\n ds.close()\\n if len(in_dict['fn_out']) > 0:\\n plt.savefig(in_dict['fn_out'])\\n plt.close()\\n else:\\n plt.show()\\n plt.rcdefaults()\",\n \"def plot_profile(outdir, xval='x', xscale=1, yscale=1, comp2los=False, adjustRadial=False,\\n fig=True):\\n #Load data\\n path = os.path.join(outdir,'points.h5')\\n x,y,z,ux,uy,uz = pu.extract_points(path)\\n\\n Y = uz / yscale\\n if xval == 'x':\\n X = x / xscale\\n Y1 = ux / yscale\\n elif xval == 'r':\\n X = np.hypot(x,y) / xscale\\n ur = np.hypot(ux,uy)\\n Y1 = ur / yscale\\n if adjustRadial: #fix sign from hypot square root\\n ur = pu.radial2negative(Y1)\\n\\n if fig:\\n plt.figure()\\n # otherwise profile added to active plot\\n\\n #plt.plot(X,uy/yscale,'r.-',label='Uy') #should be zero along EW axis\\n de = 90e3 / xscale #eastern data extent\\n if comp2los != False:\\n data_extents = (X<=de)\\n if comp2los == 'west': #switch sign of radial profile\\n #ux = -ux #move to comp2los function\\n X = -X\\n Y1 = -Y1\\n de = -de\\n data_extents = (X>=de)\\n\\n los = pu.comp2los(x,ux,uy,uz,track=comp2los)\\n plt.plot(X, los/yscale, 'k-', lw=2, label='Ulos_' + comp2los)\\n plt.fill_between(X,los/yscale, where=data_extents, color='gray',alpha=0.5)\\n\\n plt.plot(X, Y, 'b-', lw=2, label='Uz')\\n plt.plot(X, Y1, 'b--',lw=2, mfc='None',label='U{0}'.format(xval))\\n\\n # Annotate\\n plt.title(outdir)\\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n plt.ylabel('Uz [{}]'.format(get_unit(yscale)))\\n plt.axhline(color='k')\\n plt.axvline(de,color='k', linestyle='dashed', label='EW data extent') #EW extent of InSAR coverage\\n plt.legend(loc='best')\\n plt.grid(True)\\n plt.show()\",\n \"def plot_residuals(result_file,output_fig=None,fig=None,**kwargs):\\n \\n \\n #### Read file\\n \\n dic_result=file2dic(result_file)\\n\\n ### Get xbin range\\n \\n rms_val=np.append(dic_result['RMS_P'],dic_result['RMS_S'])\\n x_bins=np.linspace(np.min(rms_val),np.max(rms_val),100)\\n \\n ### Plots\\n \\n if fig is None:\\n fig, (ax1, ax2) = plt.subplots(2, sharex=True)\\n else: \\n (ax1,ax2)=fig.get_axes()\\n \\n ax1.hist(dic_result['RMS_P'],x_bins,edgecolor='black',**kwargs)\\n ax1.set_title('RMS for %i models tested'%(len(dic_result['RMS_P'])))\\n ax1.set_ylabel('P')\\n ax1.tick_params('x',direction='in')\\n ax2.hist(dic_result['RMS_S'],x_bins,edgecolor='black',**kwargs)\\n ax2.invert_yaxis()\\n ax2.set_xlabel('RMS [s]')\\n ax2.set_ylabel('S')\\n \\n fig.subplots_adjust(hspace=0)\\n plt.setp([a.get_xticklabels() for a in fig.axes[:-1]], visible=False)\\n \\n if output_fig:\\n plt.savefig(output_fig)\\n \\n \\n return fig\",\n \"def SH_surface_plots(n_max=6,figsize=(15,15),fs=15,saveA=True,show=False,dpi=400,vis_type='real'):\\n\\n N = 100j\\n\\n for n in range(n_max+1):\\n for m in range(n+1):\\n plt.close('all')\\n print(\\\"working on Y_%s^%s\\\" % (n,m) )\\n\\n PHI,THETA = np.mgrid[0:2*np.pi:N*2, 0:np.pi:N]\\n if vis_type == 'real':\\n R = sp.sph_harm(m,n,PHI,THETA).real\\n if vis_type == 'modulus':\\n r = sp.sph_harm(m,n,PHI,THETA)\\n R = r * r.conjugate()\\n if vis_type == 'unit':\\n R = sp.sph_harm(m,n,PHI,THETA).real + 1\\n\\n X = np.abs(R) * np.sin(THETA) * np.cos(PHI)\\n Y = np.abs(R) * np.sin(THETA) * np.sin(PHI)\\n Z = np.abs(R) * np.cos(THETA)\\n\\n norm = colors.Normalize()\\n fig, ax = plt.subplots(subplot_kw=dict(projection='3d'), figsize=(14,10))\\n sm = cm.ScalarMappable(cmap=cm.seismic)\\n ax.plot_surface(X, Y, Z, rstride=1, cstride=1, facecolors=cm.seismic(norm(R)))\\n ax.set_title('real$(Y^%s_%s)$' % (m,n), fontsize=fs)\\n ax.set_aspect(1)\\n sm.set_array(R)\\n fig.colorbar(sm, shrink=0.8)\\n\\n if saveA:\\n fig.savefig('images/%s/%s_%s.png' % (vis_type,n,m), dpi=dpi)\\n if show:\\n plt.show()\\n\\n # print(\\\"\\\\n only +m values are used.\\\")\\n # for n in range(n_max+1):\\n # for m in range(n+1):\\n # plt.close('all')\\n # print(\\\"\\\\n n,m = %s,%s\\\" % (n,m) )\\n #\\n # R,X,Y,Z = harmonics(m,n)\\n #\\n # fig = plt.figure(figsize=figsize)\\n # ax = plt.subplot(projection='3d')\\n # ax.set_aspect(1)\\n # ax.set_title(\\\"n: %s m: %s\\\" % (n,m), fontsize=fs+2)\\n # ax.plot_surface(X,Y,Z,\\\\\\n # cmap = cm.seismic,\\n # norm = colors.Normalize( vmin=np.min(R),vmax=np.max(R) )\\\\\\n # )\\n #\\n # if saveA:\\n # fig.savefig('images/%s_%s.png' % (n,m), dpi=dpi)\\n # if show:\\n # plt.show()\",\n \"def psfminusmodel_plot(epoch, model, features, filters, figname, fgal=0.5,\\n idx=-1):\\n # fetch Stripe 82 data\\n X, Xcov = fetch_prepped_s82data(epoch, fgal, features, filters)\\n Xcoadd, Xcoaddcov = fetch_prepped_s82data(epoch, fgal, features,\\n filters, use_single=False)\\n\\n # unpickle the XD model\\n if type(model) == str: \\n f = open(model, 'rb')\\n model = cPickle.load(f)\\n f.close()\\n\\n fs = 5\\n Nbins = [50, 50, 50]\\n lsize = 20\\n mags = [19.5, 20.5, 21.5]\\n dlt = [0.15, 0.15, 0.15]\\n f = pl.figure(figsize=(3 * fs, fs))\\n pl.subplots_adjust(wspace=0.3)\\n for i in range(len(mags)):\\n ind = (Xcoadd[:, idx] < 0.03) & (Xcoadd[:, 0] > mags[i] - dlt[i])\\n ind = ind & (Xcoadd[:, 0] <= mags[i] + dlt[i])\\n\\n x = X[ind]\\n xc = Xcov[ind]\\n\\n a, m, v = model.posterior(x, xc)\\n posts = np.zeros_like(x)\\n for j in range(x.shape[0]):\\n posts[j] = np.median(model.sample(a[j], m[j], v[j], size=1000),\\n axis=0)\\n\\n ax = pl.subplot(1, 3, i + 1)\\n h, b = np.histogram(x[:, idx], Nbins[i])\\n d = (b[1] - b[0]) / 2.\\n b = np.append([b[0] - d], b[:-1] + d)\\n h = np.append([1.0], h)\\n pl.plot(b, h, drawstyle='steps-mid', linestyle='dotted',\\n color='k', lw=2)\\n h, b = np.histogram(posts[:, idx], Nbins[i])\\n d = (b[1] - b[0]) / 2.\\n b = np.append([b[0] - d], b[:-1] + d)\\n h = np.append([1.0], h)\\n pl.plot(b, h, drawstyle='steps-mid', color='k', lw=2)\\n pl.xlabel('psfmag - modelmag $r$', fontsize=lsize)\\n pl.ylabel('counts', fontsize=lsize)\\n ax.text(0.95, 0.95, '$r=%0.1f$' % mags[i], fontsize=lsize, ha='right',\\n va='top', transform=ax.transAxes)\\n pl.xlim(-0.1, 0.2)\\n f.savefig(figname, bbox_inches='tight')\",\n \"def plot_multiLyapunov(systems, mode=2, savefig=True, figname=None):\\n if mode == 2:\\n print(systems)\\n# divnorm = colors.DivergingNorm(vmin=max([np.nanmin(np.nanmax(np.nanmax(system.lyapunov_2, axis=0), axis=0)) for system in systems]), vcenter=0, vmax=max[np.nanmax(system.lyapunov_2) for system in systems])\\n if figname == None:\\n figname = 'sum_of_first_2_lyapunov'\\n \\n fig, ax = plt.subplots()\\n for system in systems:\\n\\n lyapunov_2 = system.lyapunov_2\\n x = system.x\\n y = system.y\\n l = system.l\\n a = system.a\\n\\n\\n\\n plt.contourf(a[0,0,:,:],l[0,0,:,:],np.nanmax(np.nanmax(lyapunov_2, axis=0), axis=0), levels = 100, cmap = 'RdBu_r')\\n# , norm=divnorm)\\n for i in range(lyapunov_2.shape[0]):\\n for j in range(lyapunov_2.shape[1]):\\n plt.contour(a[0,0,:,:],l[0,0,:,:],lyapunov_2[i,j], levels = [0,], colors=('k',),alpha=0.1)\\n lyap_sum = plt.contour(a[0,0,:,:],l[0,0,:,:],lyapunov_2.max(axis=0).max(axis=0), levels = [0,], colors=('blue',),alpha=1)\\n\\n# cbar = plt.colorbar()\\n plt.plot(wild_chaos[:,0],wild_chaos[:,1],'--r',lw=3)\\n plt.title('Sum of the first 2 Lyapunov exponents ')\\n plt.ylabel('$\\\\lambda$')\\n plt.xlabel('a')\\n# cbar.ax.set_ylabel('Sum of the first 2 Lyapunov exponents')\\n\\n ax.set_ylim([l.min(),l.max()])\\n ax.set_xlim([a.min(),a.max()])\\n if savefig:\\n plt.savefig(f'images/{figname}.pdf')\\n plt.show()\",\n \"def make_summary_plot(run_lists, file_descriptor, attr='sipm1.threeSampleAmpl'):\\n biases = []\\n gains = []\\n pes = []\\n currs = []\\n gainerrs = []\\n quad_terms = []\\n quad_errs = []\\n for row in sorted(run_lists):\\n biases.append(row[0])\\n gain_out = fit_gain(row[1], attr=attr)\\n out_tuple = gain_out[0]\\n gains.append(out_tuple[0])\\n gainerrs.append(out_tuple[3])\\n smeans = sorted(gain_out[1])\\n currs.append(0.5*(smeans[-1] + smeans[-2]))\\n pes.append(currs[-1]/gains[-1])\\n quad_terms.append(out_tuple[1])\\n quad_errs.append(out_tuple[4])\\n\\n maxgain = max(gains)\\n gains = np.array(gains)/maxgain\\n gainerrs = np.array(gainerrs)/maxgain\\n # gainerrs = 0.1*gains\\n\\n currs = np.array(currs)/max(currs)\\n pes = np.array(pes)\\n pe_errs = gainerrs/gains*pes\\n maxpe = max(pes)\\n fig, ax1 = plt.subplots()\\n\\n coeffs, V = np.polyfit(biases, gains, 1, w=1.0/gainerrs, cov=True)\\n breakdown = -1*coeffs[1]/coeffs[0]\\n\\n breakdown_sigma = sigma_from_cov(coeffs, V)\\n\\n # calculate sigmas throughout range\\n vals, vecs = np.linalg.eig(V)\\n U = np.transpose(vecs)\\n xs_for_error = np.arange(breakdown - 0.1, max(biases) + 0.1, 0.01)\\n gain_sigmas = sig_from_diag(xs_for_error, U, vals)\\n error_band_ys = np.array([i*coeffs[0] + coeffs[1] for i in xs_for_error])\\n ax1.fill_between(xs_for_error, error_band_ys + gain_sigmas,\\n error_band_ys - gain_sigmas, facecolor='red', alpha=0.5)\\n\\n fitline = [i*coeffs[0] + coeffs[1] for i in biases] + [0]\\n fitbiases = biases + [breakdown]\\n\\n ax1.set_title('bias scan %s' % file_descriptor)\\n fitplot = ax1.plot(fitbiases, fitline, 'r-')\\n gainplot = ax1.errorbar(\\n biases, gains, yerr=gainerrs, fmt='ro', markersize=10)\\n currplot = ax1.plot(biases, currs, 'g*', markersize=15)\\n ax1.set_ylim(0, 1.105)\\n ax1.set_xlim([breakdown - 0.1, max(biases) + 0.1])\\n ax1.set_xlabel('bias voltage [V]')\\n ax1.set_ylabel('relative gain, charge [a.u.]')\\n\\n ticks = [breakdown]\\n ticks.extend([bias for bias in biases[::2]])\\n tick_labels = ['%.1f $\\\\pm$ %.1f' % (breakdown, breakdown_sigma)]\\n tick_labels.extend([str(bias) for bias in biases[::2]])\\n ax1.set_xticks(ticks)\\n ax1.set_xticklabels(tick_labels)\\n ax1.grid()\\n ax1.get_xticklabels()[0].set_color('r')\\n\\n ax2 = ax1.twinx()\\n peplot = ax2.errorbar(biases, pes, yerr=pe_errs, fmt='b^', markersize=10)\\n ax2.set_ylabel('pe', color='b')\\n ax2.set_ylim(0, maxpe*1.105)\\n ax2.set_xlim([breakdown - 0.1, max(biases) + 0.1])\\n for tick in ax2.get_yticklabels():\\n tick.set_color('b')\\n ax1.legend([gainplot[0]]+currplot+[peplot[0]]+fitplot,\\n ['gain', 'charge', 'pes', 'gain fit'],\\n loc='best', numpoints=1)\\n\\n plt.savefig('pdfs/breakdownPlot%s.pdf' % file_descriptor)\\n plt.show()\\n\\n quadploterrs = 0.5/np.sqrt(quad_terms)*quad_errs\\n plt.errorbar(biases, np.sqrt(quad_terms)*100, yerr=quadploterrs*100, fmt='ko')\\n plt.xlim(min(biases) - 0.1, max(biases) + 0.1)\\n plt.xlabel('bias [V]')\\n plt.ylabel('sqrt(quadratic term) [%]')\\n plt.title('quadratic terms %s' % file_descriptor)\\n\\n plt.savefig('pdfs/quadraticTerms%s.pdf' % file_descriptor)\\n plt.show()\",\n \"def plot_trust_region_results():\\n RESULTS_DIR = \\\"trust_region_experiments\\\"\\n ENV = \\\"DangerousPath-HalfMines-len25-dim5-v0\\\"\\n DIR_TEMPLATE = \\\"{env}_lr_{learning_rate}\\\"\\n STDOUT_TEMPLATE = \\\"{method}_repetition_{repetition}.txt\\\"\\n REWARD_PATTERN = r\\\"ep_rew_mean[ ]*\\\\| ([0-9\\\\.\\\\-]*)\\\"\\n TIMESTEP_PATTERN = r\\\"total_timesteps[ ]*\\\\| ([0-9]*)\\\"\\n\\n NUM_REPETITIONS = 50\\n # Forcing to high learning rate to force out the \\\"constraint\\\"\\n LEARNING_RATES = [\\\"1e-3\\\"]\\n\\n METHODS = {\\n \\\"No Constraint\\\": [\\\"NoConstraint\\\"],\\n #\\\"ClipPPO\\\": [\\\"ClipPPO\\\"],\\n \\\"Max Action TV\\\": [\\\"PiMaxTV_{}\\\".format(kl) for kl in [0.001, 0.005, 0.01, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5]],\\n \\\"Gaussian\\\": [\\\"Gaussian_{}\\\".format(kl) for kl in [0.5, 1.0, 2.0, 3.0, 5.0, 10.0, 15.0, 20.0]],\\n \\\"Supervector\\\": [\\\"Supervector_{}\\\".format(kl) for kl in [0.01, 0.05, 0.1, 0.15, 0.2, 0.3, 0.4, 0.5]],\\n }\\n\\n # Match with novelty search\\n COLORS = [\\n \\\"C0\\\",\\n \\\"C1\\\",\\n \\\"C2\\\",\\n \\\"C3\\\",\\n ]\\n\\n fig = pyplot.figure(figsize=[4.8, 4.8])\\n path_to_log_template = os.path.join(RESULTS_DIR, DIR_TEMPLATE, STDOUT_TEMPLATE)\\n\\n for (legend_name, experiment_names), color in zip(METHODS.items(), COLORS):\\n # For each method, find the best learning curve (based on AUC)\\n # and plot it\\n best_x = None\\n best_y = None\\n best_y_upper = None\\n best_y_lower = None\\n best_std = None\\n best_auc = None\\n best_description = \\\"\\\"\\n\\n for learning_rate in LEARNING_RATES:\\n for experiment_name in experiment_names:\\n # Construct learning curves\\n xs = []\\n ys = []\\n for repetition in range(NUM_REPETITIONS):\\n path_to_log = path_to_log_template.format(env=ENV, learning_rate=learning_rate, method=experiment_name, repetition=repetition)\\n log = open(path_to_log).read()\\n timesteps = list(map(float, re.findall(TIMESTEP_PATTERN, log)))\\n rewards = list(map(float, re.findall(REWARD_PATTERN, log)))\\n assert len(timesteps) == len(rewards)\\n xs.append(np.array(timesteps))\\n ys.append(np.array(rewards))\\n\\n average_x, average_y, std_y, lower_y, upper_y = interpolate_and_average(xs, ys, confidence_interval=True)\\n # Uniformly spaced plotting points so can just take mean over ys\\n auc = average_y.mean()\\n if best_auc is None or auc > best_auc:\\n best_x = average_x\\n best_y = average_y\\n best_y_upper = upper_y\\n best_y_lower = lower_y\\n best_std = std_y\\n best_auc = auc\\n best_description = \\\"{}. lr: {}\\\".format(experiment_name, learning_rate)\\n print(\\\"Best result for {}: {}\\\".format(legend_name, best_description))\\n pyplot.plot(best_x, best_y, label=legend_name, c=color)\\n pyplot.fill_between(\\n best_x,\\n best_y_lower,\\n best_y_upper,\\n alpha=0.2,\\n color=color,\\n linewidth=0.0\\n )\\n pyplot.tick_params(axis='both', which='both', labelsize=\\\"x-large\\\")\\n pyplot.grid(alpha=0.2)\\n pyplot.xlabel(\\\"Environment steps\\\", fontsize=\\\"x-large\\\")\\n pyplot.ylabel(\\\"Average return\\\", fontsize=\\\"x-large\\\")\\n pyplot.legend(prop={\\\"size\\\": \\\"large\\\"})\\n pyplot.tight_layout()\\n pyplot.savefig(\\\"figures/trust_region_results.pdf\\\", bbox_inches=\\\"tight\\\", pad_inches=0.0)\",\n \"def plot_envs_overall():\\n AUC = []\\n R_iter = []\\n for i in range(len(envs)):\\n env = envs[i]\\n print(env)\\n bestmodels, R_cum, aucurve = plot_rwds(envs_labels, cdict=color_dict,\\n fdir=fdir + envs[i] + '-v1/',\\n model_paths=model_paths, BEST=BEST, MAX_LEN=MAX_LEN(envs[i]),\\n STEP=STEP, MAX_TRIALS=MAX_TRIALS,\\n title=envs[i] + ' $R_{iter}$ ', step=max_lims[envs[i]][1],\\n shape_dict=shape_dict,\\n kfold=max_lims[envs[i]][1] * MAX_TRIALS)\\n print('done print')\\n R_iter.append(bestmodels)\\n R = np.asarray(aucurve, dtype=float)\\n AUC.extend(zip(np.mean(R, axis=1), np.std(R, axis=1) / np.sqrt(R.shape[1])))\\n print('done. Computing AUC')\\n for j in [1, 2]:\\n for m in range(len(envs_labels) - 1):\\n print_ttest(envs_labels, R, m, j)\\n print('\\\\n')\\n\\n # Swimmer\\n # t-test ( FM RPSP-VRPG )= [ -0.676586869332 , 0.507653821772 ]\\n # t-test ( GRU RPSP-VRPG )= [ -11.4782215848 , 9.9484555701e-07 ]\\n # t-test ( RPSP-Alt RPSP-VRPG )= [ -3.10454361915 , 0.00933872173406 ]\\n # t-test ( FM RPSP-Alt )= [ 1.73508240067 , 0.111134237192 ]\\n # t-test ( GRU RPSP-Alt )= [ -20.2985459977 , 2.4045809148e-09 ]\\n # Hopper\\n # t-test ( FM RPSP-VRPG )= [ -1.97496384693 , 0.0638921448438 ]\\n # t-test ( GRU RPSP-VRPG )= [ -2.98367426585 , 0.0121047687853 ]\\n # t-test ( RPSP-Alt RPSP-VRPG )= [ 2.25405603636 , 0.0382107798284 ]\\n # t-test ( FM RPSP-Alt )= [ -3.92498523554 , 0.00123896806466 ]\\n # t-test ( GRU RPSP-Alt )= [ -4.909161505 , 0.000577310309778 ]\\n # Walker2d\\n # t-test ( FM RPSP-VRPG )= [ -0.0793340586349 , 0.937667000948 ]\\n # t-test ( GRU RPSP-VRPG )= [ -2.9657440937 , 0.00870691843556 ]\\n # t-test ( RPSP-Alt RPSP-VRPG )= [ 2.23688724131 , 0.0412540309747 ]\\n # t-test ( FM RPSP-Alt )= [ -2.05494189388 , 0.0601025184967 ]\\n # t-test ( GRU RPSP-Alt )= [ -6.51606587482 , 5.3677973935e-06 ]\\n # CartPole\\n # t-test ( FM RPSP-VRPG )= [ -4.49013758712 , 0.00103201257316 ]\\n # t-test ( GRU RPSP-VRPG )= [ 1.23597901022 , 0.232353991956 ]\\n # t-test ( RPSP-Alt RPSP-VRPG )= [ -0.358340067592 , 0.726097854222 ]\\n # t-test ( FM RPSP-Alt )= [ -8.06880999537 , 6.44596048562e-07 ]\\n # t-test ( GRU RPSP-Alt )= [ 1.95090137725 , 0.0740240842398 ]\\n # print (np.round(np.asarray(AUC)[[0, 1, 2, 3, 5, 9], :] / 1000.0, decimals=1))\\n # print (reg_labels, filter_labels)\\n return R_iter, AUC\",\n \"def plot_results(epochs: int = 20, segments: int = 5, plot: bool = True):\\n \\\"\\\"\\\"\\n plt.figure(0)\\n plot_approximation(\\\"product\\\", modelSetProd, 1, epochs, gpus=0)\\n \\\"\\\"\\\"\\n\\n data = [\\n {\\n \\\"title\\\": \\\"Piecewise Discontinuous Function Approximation\\\",\\n \\\"layer\\\": \\\"discontinuous\\\",\\n \\\"model_set\\\": modelSetD,\\n },\\n {\\n \\\"title\\\": \\\"Piecewise Continuous Function Approximation\\\",\\n \\\"layer\\\": \\\"continuous\\\",\\n \\\"model_set\\\": modelSetC,\\n },\\n {\\n \\\"title\\\": \\\"Polynomial function approximation\\\",\\n \\\"layer\\\": \\\"polynomial\\\",\\n \\\"model_set\\\": modelSetP,\\n },\\n {\\n \\\"title\\\": \\\"Fourier function approximation\\\",\\n \\\"layer\\\": \\\"fourier\\\",\\n \\\"model_set\\\": modelSetF,\\n },\\n ]\\n\\n for index, element in enumerate(data):\\n if plot is True:\\n plt.figure(index)\\n plot_approximation(\\n element[\\\"layer\\\"],\\n element[\\\"model_set\\\"],\\n 5,\\n epochs,\\n accelerator=\\\"cpu\\\",\\n periodicity=2,\\n )\\n\\n if plot is True:\\n plt.title(\\\"Piecewise Discontinuous Function Approximation\\\")\\n\\n if plot is True:\\n plt.show()\",\n \"def plot_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2014/output',\\n\\t\\t\\t\\tsteps=['step01','step02'],\\n\\t\\t\\t\\t#labels='',\\n\\t\\t\\t\\tshow=True,\\n\\t\\t\\t\\txscale=1e3,\\n\\t\\t\\t\\tyscale=1e-2):\\n\\tplt.figure()\\n\\t#path = '/Users/scott/Desktop/elastic'\\n\\n\\t# Deep source\\n\\t#labels = ['no APMB', 'APMB']\\n\\t#if labels == '':\\n\\tlabels = steps\\n\\tdeep = {}\\n\\t#uzmax = 0.824873455364\\n\\t# NOT sure why hardcoded...\\n\\tuzmax = 1\\n\\tfor i,outdir in enumerate(steps):\\n\\t\\tpointsFile = os.path.join(path, outdir, 'points.h5')\\n\\t\\tprint(pointsFile)\\n\\t\\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n\\n\\t\\tX = x / xscale\\n\\t\\tY1 = ux / yscale\\n\\n\\t\\tx_fem = X #/ xscale #double scaling!\\n\\t\\tur_fem = Y1 #/ yscale\\n\\t\\tuz_fem = uz / yscale\\n\\n\\t\\t#print(pointsFile)\\n\\t\\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\\n\\n\\t\\t#normalize\\n\\t\\tuz_fem = uz_fem / uzmax\\n\\t\\tur_fem = ur_fem / uzmax\\n\\t\\tx_fem = x_fem / 30.0\\n\\n\\t\\tl, = plt.plot(x_fem,uz_fem,'o-',ms=4,lw=4,label=labels[i])\\n\\t\\tplt.plot(x_fem,ur_fem,'o--',ms=4,lw=4,color=l.get_color()) #mfc='none' transparent\\n\\t\\tdeep[outdir] = uz_fem/uz_fem\\n\\n\\t'''\\n\\t# Shallow Source\\n\\tshallow = {}\\n\\tuzmax = 0.949652827795\\n\\tfor i,outdir in enumerate(['step11','step12']):\\n\\t\\tpointsFile = os.path.join(path, outdir, 'points.h5')\\n\\n\\t\\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n\\n\\t\\tX = x / xscale\\n\\t\\tY1 = ux / yscale\\n\\n\\t\\tx_fem = X #/ xscale #double scaling!\\n\\t\\tur_fem = Y1 #/ yscale\\n\\t\\tuz_fem = uz / yscale\\n\\n\\t\\t#print(pointsFile)\\n\\t\\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\\n\\n\\t#normalize\\n\\tuz_fem = uz_fem / uzmax\\n\\tur_fem = ur_fem / uzmax\\n\\tx_fem = x_fem / 20.0\\n\\n\\t\\tl, = plt.plot(x_fem,uz_fem,'.-', mfc='w', lw=4,label=labels[i])\\n\\t\\tplt.plot(x_fem,ur_fem,'.--',lw=4, mfc='w',color=l.get_color()) #mfc='none' transparent\\n\\n\\t\\tshallow[outdir] = uz_fem/ur_fem\\n\\t'''\\n\\n\\t# Annotate\\n\\tplt.axhline(color='k',lw=0.5)\\n\\t#plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n\\t#plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\\n\\tplt.legend()\\n\\tplt.grid()\\n\\t#plt.ylim(-0.5, 3.5)\\n\\t#plt.savefig('deep.png',bbox_inches='tight')\\n\\t#plt.savefig('shallow.png',bbox_inches='tight')\\n\\n\\t# normalized\\n\\tplt.ylim(-0.5, 4)\\n\\tplt.xlim(0,10)\\n\\tplt.xlabel('Normalized Radial Distance [R / D]')\\n\\tplt.ylabel('Normalized Displacement [U / Uz_max]')\\n\\t#plt.savefig('normalized_deep.png',bbox_inches='tight')\\n\\tplt.savefig('normalized_shallow.png',bbox_inches='tight')\\n\\n\\n\\t# Plot ratios of uz versus NOTE: this plot is confusing,,, just keep ratio of uz_max to ur_max\\n\\t'''\\n\\tplt.figure()\\n\\tplt.plot(x_fem, deep['step01'], label='Deep no APMB')\\n\\tplt.plot(x_fem, deep['step02'], label='Deep w/ APMB')\\n\\tplt.plot(x_fem, shallow['step11'], label='Shallow no APMB')\\n\\tplt.plot(x_fem, shallow['step12'], label='Shallow w/ APMB')\\n\\tplt.xlabel('Distance [km]') #NOTE: maybe plot normailzed X-axis (R-d)\\n\\t#plt.xlabel('Normalized Distance [R/d]')\\n\\tplt.ylabel('Ratio [Uz/Ur]')\\n\\tplt.title('Ratio of vertical to radial displacement')\\n\\tplt.legend()\\n\\tplt.show()\\n\\t'''\",\n \"def plot_spatial_res(data_obj, test_num):\\n\\n #---------------------------------------------------------------------------------------------#\\n # Go through each file [image] and plot the spatial resolution ROI images and MTF data graphs #\\n #---------------------------------------------------------------------------------------------#\\n for i in range(len(data_obj.files)):\\n\\n fig = new_pdf_page(data_obj.pdf_obj) #Create a new pdf page\\n plt.axis('off')\\n\\n # Create and plot the (centered) title of the page - that also states the MTF20 values\\n str1 = 'Test ' + str(test_num) + ': Spatial Resolution \\\\n' + \\\\\\n 'MTF20x = ' + \\\"{0:.2f}\\\".format(data_obj.MTF_data.MTF20_x) + \\\\\\n '\\\\n MTF20y = ' + \\\"{0:.2f}\\\".format(data_obj.MTF_data.MTF20_y)\\n plt.suptitle(str1)\\n\\n #-----------------------------------------------#\\n # Plot the main image in the middle of the page #\\n #-----------------------------------------------#\\n ax1 = fig.add_subplot(312)\\n plt.imshow(data_obj.img_data[i].lead_foil_ROI.img) #Display the ROI image of the lead foil\\n\\n # Display the title of the ROI image - the orientation\\n plt.title('Orientation ' + str(data_obj.img_data[i].orientation))\\n plt.xticks([]) # labels\\n plt.yticks([])\\n ax = plt.gca()\\n ax.xaxis.set_ticks_position('none') # tick markers\\n ax.yaxis.set_ticks_position('none')\\n\\n if data_obj.img_data[i].orientation % 2 == 1:\\n plt.xlabel('x axis')\\n plt.ylabel('y axis')\\n else:\\n plt.xlabel('y axis')\\n plt.ylabel('x axis')\\n\\n #-----------------------------#\\n # Display the Horizontal plot #\\n #-----------------------------#\\n ax2 = fig.add_subplot(325)\\n plt.ylabel('MTFx')\\n plt.xlabel('Spatial frequency (cycles/mm)')\\n plt.plot(data_obj.img_data[i].MTF_obj.MTF_x_f, data_obj.img_data[i].MTF_obj.MTF_x)\\n text = 'MTF20x = ' + \\\"{0:.2f}\\\".format(data_obj.img_data[i].MTF_obj.MTF20_x)\\n\\n ax2.annotate(text,\\n xy=(data_obj.img_data[i].MTF_obj.MTF20_x, 0.2),\\n xytext=(np.max(data_obj.img_data[i].MTF_obj.MTF_x_f), 0.7),\\n arrowprops=dict(facecolor='black', shrink=0.05, width=0.5, headwidth=4),\\n horizontalalignment='right')\\n\\n #---------------#\\n # Vertical plot #\\n #---------------#\\n ax3 = fig.add_subplot(326)\\n plt.ylabel('MTFy')\\n plt.xlabel('Spatial frequency (cycles/mm)')\\n plt.plot(data_obj.img_data[i].MTF_obj.MTF_y_f, data_obj.img_data[i].MTF_obj.MTF_y)\\n text = 'MTF20y = ' + \\\"{0:.2f}\\\".format(data_obj.img_data[i].MTF_obj.MTF20_y)\\n\\n ax3.annotate(text,\\n xy=(data_obj.img_data[i].MTF_obj.MTF20_y, 0.2),\\n xytext=(np.max(data_obj.img_data[i].MTF_obj.MTF_y_f), 0.7),\\n arrowprops=dict(facecolor='black', shrink=0.05, width=0.5, headwidth=4),\\n horizontalalignment='right')\",\n \"def coeff_display_file(filename,zernike_max_order=20):\\n hdu = pf.open(filename)\\n nn = len(hdu)\\n data = []\\n colnames = ['x','y','M20','M22','M31','M33']\\n for hdui in hdu[1:]:\\n Nobj = hdui.data.shape[0]\\n M20=np.zeros(Nobj)\\n M22=np.zeros(Nobj).astype(complex)\\n M31=np.zeros(Nobj).astype(complex)\\n M33=np.zeros(Nobj).astype(complex)\\n #sigma = 1.1/0.27\\n sigma = 1.08/scale\\n for i in range(Nobj):\\n M20[i],M22[i],M31[i],M33[i]=complexMoments(data=hdui.data[i][4:].reshape(npix,npix),sigma=sigma)\\n x=hdui.header['ccdXcen']\\n y=hdui.header['ccdYcen']\\n data.append([x,y,np.median(M20), np.median(M22), np.median(M31), np.median(M33)])\\n data=np.array(data)\\n betaAll=[]\\n betaErrAll=[]\\n R2adjAll=[]\\n beta,betaErr,R2_adj = zernikeFit(data[:,0].real,data[:,1].real,data[:,2].real,max_order=zernike_max_order)\\n betaAll.append(beta)\\n betaErrAll.append(betaErr)\\n R2adjAll.append(R2_adj)\\n for i in range(3,6):\\n beta,betaErr,R2_adj = zernikeFit(data[:,0].real,data[:,1].real,data[:,i].real,max_order=zernike_max_order)\\n betaAll.append(beta)\\n betaErrAll.append(betaErr)\\n R2adjAll.append(R2_adj)\\n beta,betaErr,R2_adj = zernikeFit(data[:,0].real,data[:,1].real,data[:,i].imag,max_order=zernike_max_order)\\n betaAll.append(beta)\\n betaErrAll.append(betaErr)\\n R2adjAll.append(R2_adj)\\n betaAll = np.array(betaAll)\\n betaErrAll = np.array(betaErrAll)\\n R2adjAll = np.array(R2adjAll)\\n ind = np.arange(len(betaAll[0]))\\n momname = ('M20','M22.Real','M22.imag','M31.real','M31.imag','M33.real','M33.imag')\\n fmtarr = ['bo-','ro-','go-','co-','mo-','yo-','ko-']\\n pl.figure(figsize=(17,13))\\n for i in range(7):\\n pl.subplot(7,1,i+1)\\n pl.errorbar(ind,betaAll[i],yerr = betaErrAll[i],fmt=fmtarr[i])\\n if i == 0:\\n pl.title('x: '+str(hdu[0].header['x'])+' y: '+str(hdu[0].header['y'])+' z: '+str(hdu[0].header['z'])+' tilt: '+str(hdu[0].header['theta'])+' fwhm: '+str(hdu[0].header['s_fwhm'])+' e1: '+str(hdu[0].header['e1'])+' e2: '+str(hdu[0].header['e2']))\\n pl.grid()\\n pl.xlim(-1,21)\\n if i ==0:\\n pl.ylim(-50,100)\\n elif i ==1:\\n pl.ylim(-10,10)\\n elif i ==2:\\n pl.ylim(-10,10)\\n elif i == 3:\\n pl.ylim(-0.01,0.01)\\n elif i == 4:\\n pl.ylim(-0.01,0.01)\\n elif i ==5:\\n pl.ylim(-20,20)\\n elif i == 6:\\n pl.ylim(-20,20)\\n pl.xticks(ind,('','','','','','','','','','','','','','','','','','','',''))\\n pl.ylabel(momname[i])\\n pl.xticks(ind,('1','2','3','4','5','6','7','8','9','10','11','12','13','14','15','16','17','18','19','20'))\\n pl.xlabel('Zernike Coefficients')\\n return betaAll,betaErrAll\",\n \"def plot_SS(H,E,C,nframes,nres,outdir,name_mod):\\n\\tH_av = np.zeros(nres) ; H_err = np.zeros(nres) \\n\\tE_av = np.zeros(nres) ; E_err = np.zeros(nres) \\n\\tC_av = np.zeros(nres) ; C_err = np.zeros(nres) \\n\\tfor ind in range(nres):\\n\\t\\tH_av[ind] = sum(H[ind,:])/nframes ; H_err[ind] = np.std(H[ind,:])\\n\\t\\tE_av[ind] = sum(E[ind,:])/nframes ; E_err[ind] = np.std(E[ind,:])\\n\\t\\tC_av[ind] = sum(C[ind,:])/nframes ; C_err[ind] = np.std(C[ind,:])\\n\\n\\tplt.clf()\\n\\tplt.plot(H_av,label='Helix',c='r') ; plt.errorbar(range(nres), H_av,yerr=H_err/(np.sqrt(nframes)-1), fmt='o',color='r')\\n\\tplt.plot(E_av,label='Beta Sheet',c='b') ; plt.errorbar(range(nres), E_av,yerr=E_err/(np.sqrt(nframes)-1), fmt='o',color='b')\\n\\tplt.plot(C_av,label='Coil',c='k') ; plt.errorbar(range(nres), C_av,yerr=C_err/(np.sqrt(nframes)-1), fmt='o',color='k')\\n\\tplt.legend(loc=1)\\n\\tplt.savefig(outdir+\\\"SS\\\" + name_mod + \\\".png\\\")\\n\\tnp.savetxt(outdir+\\\"SS_H_av\\\" + name_mod + \\\".npy\\\",[H_av,H_err])\\n\\tnp.savetxt(outdir+\\\"SS_E_av\\\" + name_mod + \\\".npy\\\",[E_av,E_err])\\n\\tnp.savetxt(outdir+\\\"SS_C_av\\\" + name_mod + \\\".npy\\\",[C_av,C_err])\\n\\treturn None\",\n \"def plotAllResiduals():\\n #Joint fits\\n files = g.glob('results/J*.fits')\\n individuals = [file for file in files if 'datafit' in file]\\n for file in individuals:\\n id = file.replace('results/', '').replace('datafit.fits', '')\\n print 'processing:', id\\n _plotModelResiduals(id=id, folder='results/', out='results/%sResidual.pdf' % id)\\n\\n #Individual fits\\n files = g.glob('results/I*.fits')\\n individuals = [file for file in files if 'model' in file]\\n for file in individuals:\\n id = file.replace('results/', '').replace('model.fits', '')\\n print 'processing:', id\\n _plotModelResiduals(id=id, folder='results/', out='results/%sResidual.pdf' % id, individual=True)\",\n \"def plot_data(data, param_choice, args):\\n \\n ### set general plot properties\\n \\n savebase = '/usr/users/iff_th2/duman/Cells_in_LAMMPS/POVRAY/'\\n #downlim = -1\\n #uplim = sim.lx/4.\\n num_ticks = 5\\n ax_len = 1.0 # Length of one subplot square box\\n ax_b = 0.0 # Beginning/offset of the subplot in the box\\n ax_sep = 0.0 # Separation length between two subplots\\n total_subplots_in_x = 1 # Total number of subplots \\n fig = plt.figure()\\n subp = misc_tools.Subplots(fig, ax_len, ax_sep, ax_b, total_subplots_in_x) \\n ax0 = subp.addSubplot()\\n \\n name = ''\\n pname = ''\\n if param_choice == 'areak': \\n name = 'AREAK'\\n pname = name + '_eps_' + str(args.eps) + '_fp_' + str(args.fp) + \\\\\\n '_kappa_' + str(args.kappa)\\n xlab = '$\\\\kappa_A$'\\n tit = '$\\\\epsilon=$' + str(args.eps) + ',$f_m=$' + str(args.fp) + \\\\\\n ',$\\\\kappa=$' + str(args.kappa)\\n elif param_choice == 'eps':\\n name = 'EPS'\\n pname = name + '_fp_' + str(args.fp) + '_areak_' + str(args.areak) + \\\\\\n '_kappa_' + str(args.kappa)\\n xlab = '$\\\\epsilon$'\\n tit = '$f_m=$' + str(args.fp) + ',$\\\\kappa_A=$' + str(args.areak) + \\\\\\n ',$\\\\kappa=$' + str(args.kappa) \\n elif param_choice == 'fp':\\n name = 'FP'\\n pname = name + '_eps_' + str(args.eps) + '_areak_' + str(args.areak) + \\\\\\n '_kappa_' + str(args.kappa)\\n xlab = '$f_{m}$'\\n tit = '$\\\\epsilon=$' + str(args.eps) + ',$\\\\kappa_A=$' + str(args.areak) + \\\\\\n ',$\\\\kappa=$' + str(args.kappa) \\n elif param_choice == 'kappa':\\n name = 'KAPPA'\\n pname = name + '_eps_' + str(args.eps) + '_fp_' + str(args.fp) + \\\\\\n '_areak_' + str(args.areak)\\n xlab = '$\\\\kappa$'\\n tit = '$\\\\epsilon=$' + str(args.eps) + ',$f_m=$' + str(args.fp) + \\\\\\n ',$\\\\kappa_A=$' + str(args.areak) \\n base = savebase + name + '/'\\n os.system(\\\"mkdir -p \\\" + base) \\n \\n ### plot \\n\\n subp = misc_tools.Subplots(fig, ax_len, ax_sep, ax_b, total_subplots_in_x) \\n ax0 = subp.addSubplot()\\n \\n x = data.keys()\\n y = [1 for j in range(len(data.keys()))]\\n print x\\n ax0.scatter(x, y)\\n ax0.set_xscale('log')\\n ax0.set_yscale('log')\\n \\n for j, p in enumerate(data.keys()):\\n \\n fname = data[p] \\n \\n if os.path.exists(fname):\\n arr_hand = read_png(fname)\\n \\n zoom=0.099\\n imagebox = OffsetImage(arr_hand, zoom=zoom)\\n\\n xy = [x[j], y[j]] # coordinates to position this image\\n\\n ab = AnnotationBbox(imagebox, xy,\\n xybox=(0., -0.),\\n xycoords='data',\\n boxcoords=\\\"offset points\\\",frameon=1,pad=.1) \\n \\n ax0.add_artist(ab)\\n \\n ### title\\n \\n ax0.set_title(tit, fontsize=30)\\n \\n ### labels\\n \\n ax0.set_xlabel(xlab, fontsize=30)\\n #ax0.set_ylabel(\\\"$F_{s}(q,\\\\\\\\Delta t)$\\\", fontsize=40)\\n\\n ### limits\\n\\n #ax0.set_xlim((-1, 15))\\n ax0.set_ylim((0.9999, 1.0001))\\n \\n ax0.grid(1, color='#cccccc', linestyle='--')\\n ax0.set_frame_on(False)\\n ax0.get_xaxis().tick_bottom()\\n ax0.axes.get_yaxis().set_visible(False)\\n xmin, xmax = ax0.get_xaxis().get_view_interval()\\n ymin, ymax = ax0.get_yaxis().get_view_interval()\\n ax0.add_artist(Line2D((xmin, xmax), (ymin, ymin), color='black', linewidth=2)) \\n ### ticks\\n \\n #ax0.xaxis.set_ticks(np.linspace(0, 15, num_ticks, endpoint=True))\\n #ax0.yaxis.set_ticks(np.linspace(0, uplim, num_ticks, endpoint=True))\\n plt.setp(ax0.get_yticklabels(),visible=False) \\n ax0.tick_params(axis='both', which='major', labelsize=30)\\n \\n ### legend\\n\\n# ax0.legend(bbox_to_anchor=(1.005, 0.,0.65, 1.), loc=2, borderaxespad=0., \\\\\\n# prop={'size': 20}, mode=\\\"expand\\\", frameon=False)\\n \\n ### save \\n \\n savepath = base + \\\"images_per_\\\" + pname + \\\".pdf\\\"\\n print savepath\\n plt.savefig(savepath, dpi=300, bbox_inches='tight', pad_inches=0.08) \\n fig.clf() \\n \\n return\",\n \"def display4(*args):\\n #-------------------- unpack\\n twiss_func = args[0]\\n cos_like = args[1]\\n sin_like = args[2]\\n lat_plot = args[3]\\n #-------------------- beta x,y & dispersion x\\n s = [twiss_func(i,'s') for i in range(twiss_func.nbpoints)] # Abszisse\\n bx = [twiss_func(i,'bx') for i in range(twiss_func.nbpoints)] # beta x\\n by = [twiss_func(i,'by') for i in range(twiss_func.nbpoints)] # beta y\\n dx = [twiss_func(i,'dx') for i in range(twiss_func.nbpoints)] # dispersion x\\n#-------------------- longitudinal trajectories\\n z1= [cos_like(i,'s') for i in range(cos_like.nbpoints)]\\n cz= [cos_like(i,'cz') for i in range(cos_like.nbpoints)]\\n cdp= [cos_like(i,'cdp') for i in range(cos_like.nbpoints)]\\n\\n z2= [sin_like(i,'s') for i in range(sin_like.nbpoints)]\\n sz= [sin_like(i,'sz') for i in range(sin_like.nbpoints)]\\n sdp= [sin_like(i,'sdp') for i in range(sin_like.nbpoints)]\\n #-------------------- lattice viseo\\n vzero = [0. for i in range(lat_plot.nbpoints)] # zero line\\n vis_abszisse = [lat_plot(i,'s') for i in range(lat_plot.nbpoints)]\\n vis_ordinate = [lat_plot(i,'viseo') for i in range(lat_plot.nbpoints)]\\n #-------------------- figure frame\\n width=14; height=7.6\\n # fighdr = 'lattice version = {}, input file = {}'.format(PARAMS['lattice_version'],PARAMS['input_file'])\\n fig = plt.figure(num=1,figsize=(width,height),facecolor='#eaecef',tight_layout=False)\\n\\n #-------------------- beta functions\\n splot211=plt.subplot(211)\\n splot211.set_title('beta x,y')\\n # mapping box\\n splot211.text(0.01, 1.1, UTIL.FLAGS.get('mapping'),transform=splot211.transAxes,fontsize=8,bbox=dict(boxstyle='round',facecolor='wheat',alpha=0.5),verticalalignment='top')\\n # function plots\\n plt.plot(s,bx, label=r\\\"$\\\\beta$x [m]\\\", color='black', linestyle='-')\\n plt.plot(s,by, label=r\\\"$\\\\beta$y [m]\\\", color='red', linestyle='-')\\n plt.plot(s,dx, label=r'$\\\\eta_x$ [m]' , color='green', linestyle='-') # dispersion x\\n vscale=splot211.axis()[3]*0.25\\n viseoz = [x*vscale for x in vis_ordinate]\\n plt.plot(vis_abszisse,viseoz,label='',color='black')\\n plt.plot(vis_abszisse,vzero,color='green',linestyle='--')\\n # zero line\\n splot211.plot(vis_abszisse,vzero,color='green',linestyle='--')\\n plt.legend(loc='lower right',fontsize='x-small')\\n\\n #-------------------- longitudinal tracks z, dP/P\\n # ax_l = left abszisse\\n ax_l=plt.subplot(212)\\n # ax_l=plt.subplot(10,1,(7,9))\\n ax_l.set_title('synchrotron oscillation')\\n ax_l.set_ylabel(r\\\"z [mm]\\\")\\n ax_l.tick_params(axis='y', colors='green')\\n ax_l.yaxis.label.set_color('green')\\n ax_l.plot(z1,cz,label='C',color='green')\\n ax_l.plot(z2,sz,label='S',color='green',linestyle=':')\\n plt.legend(loc='lower left',fontsize='x-small')\\n # ax_r = right abszisse\\n ax_r = ax_l.twinx()\\n ax_r.set_ylabel(r'$\\\\Delta$p/p [%]')\\n ax_r.tick_params(axis='y', colors='red')\\n ax_r.yaxis.label.set_color('red')\\n ax_r.plot(z2,cdp,label='C',color='red')\\n ax_r.plot(z2,sdp,label='S',color='red',linestyle=':')\\n ax_r.plot(vis_abszisse,vzero,color='red', linestyle='--')\\n plt.legend(loc='lower right',fontsize='x-small')\\n # lattice elements\\n vscale=ax_l.axis()[3]*0.25\\n viseoz = [x*vscale for x in vis_ordinate]\\n ax_l.plot(vis_abszisse,viseoz,label='',color='black')\\n ax_l.plot(vis_abszisse,vzero,color='green',linestyle='--')\",\n \"def plot_visual_abstract():\\n # Which generations to plot\\n GENERATIONS = [100, 230, 350]\\n\\n # LunarLander CMA-ES\\n experiment_path = glob(\\\"experiments/wann_LunarLander-v2_CMAES*\\\")\\n assert len(experiment_path) == 1, \\\"There should be only one CMA-ES experiment with LunarLander-v2\\\"\\n experiment_path = experiment_path[0]\\n\\n pivector_paths = glob(os.path.join(experiment_path, \\\"pivectors\\\", \\\"*\\\"))\\n\\n tsnes = []\\n rewards = []\\n for generation in GENERATIONS:\\n # Find pivector files for specific generation, load them and store points\\n generation_paths = [path for path in pivector_paths if \\\"gen_{}_\\\".format(generation) in path]\\n\\n population = [np.load(path) for path in generation_paths]\\n population_tsnes = np.array([x[\\\"tsne\\\"] for x in population])\\n population_rewards = np.array([x[\\\"average_episodic_reward\\\"] for x in population])\\n tsnes.append(population_tsnes)\\n rewards.append(population_rewards)\\n\\n figure, axs = pyplot.subplots(\\n figsize=[2.5 * 3, 2.5],\\n nrows=1,\\n ncols=len(GENERATIONS),\\n sharex=\\\"all\\\",\\n sharey=\\\"all\\\"\\n )\\n\\n min_reward = min(x.min() for x in rewards)\\n max_reward = max(x.max() for x in rewards)\\n scatter = None\\n\\n for idx in range(len(GENERATIONS)):\\n population_tsne = tsnes[idx]\\n population_rewards = rewards[idx]\\n generation = GENERATIONS[idx]\\n ax = axs[idx]\\n\\n scatter = ax.scatter(\\n population_tsne[:, 0],\\n population_tsne[:, 1],\\n c=population_rewards,\\n vmin=min_reward,\\n vmax=max_reward,\\n cmap=\\\"plasma\\\"\\n )\\n ax.set_title(\\\"Generation {}\\\".format(generation))\\n ax.set_xticks([])\\n ax.set_yticks([])\\n ax.axis(\\\"off\\\")\\n\\n # Making room for colorbar\\n # Stackoverflow #13784201\\n figure.subplots_adjust(right=1.0)\\n cbar = figure.colorbar(scatter)\\n cbar.set_ticks([])\\n cbar.ax.set_ylabel(\\\"Reward $\\\\\\\\rightarrow$\\\", rotation=90, fontsize=\\\"large\\\")\\n\\n figure.tight_layout()\\n figure.savefig(\\\"figures/visual_abstract.pdf\\\", bbox_inches=\\\"tight\\\", pad_inches=0.05)\",\n \"def simplexPlot(results):\\n _, hole1Values, logProbs = getStatistics(results.items())\\n import matplotlib.pyplot as plt\\n plt.plot(hole1Values, logProbs)\\n plt.show()\",\n \"def plot_variables(self, val=None, roi=None) -> None:\\n\\n if val is None:\\n val = self.history.MAP\\n\\n if roi is None:\\n roi = np.array([0])\\n elif np.isscalar:\\n roi = np.array([roi])\\n\\n data = self.data\\n\\n dt = val.dt\\n gain = val.gain\\n states = val.states\\n mu_flor = val.mu_flor\\n mu_back = val.mu_back\\n num_rois = val.num_rois\\n num_load = val.num_load\\n num_data = val.num_data\\n num_states = val.num_states\\n\\n times = np.arange(num_data) * dt\\n\\n fig = plt.gcf()\\n fig.clf()\\n #fig.set_size_inches(12, 6)\\n ax = np.empty((len(roi), 1), dtype=object)\\n gs = gridspec.GridSpec(nrows=len(roi), ncols=1, figure=fig)\\n ax[0, 0] = fig.add_subplot(gs[0, 0])\\n for i in range(len(roi)-1):\\n ax[i, 0] = fig.add_subplot(gs[i, 0], sharex=ax[0, 0])\\n\\n for i, r in enumerate(roi):\\n\\n brightness = mu_flor @ states_to_pops(states[r, :, :], num_states) + mu_back[r]\\n\\n ax[i, 0].set_title('roi {}: {} flors'.format(r, val.num_flor[r]))\\n ax[i, 0].set_xlabel('time (s)')\\n ax[i, 0].set_ylabel('brightness (ADU)')\\n ax[i, 0].plot(times, data[r, :], color='g', label='data')\\n ax[i, 0].plot(times, brightness * gain, color='b', label='sampled')\\n ax[i, 0].legend()\\n\\n # plt.tight_layout()\\n plt.pause(.1)\\n\\n return\",\n \"def plot_uwrz_field(f=False,ax=False, oro='h500a7', vm=[-2,2],tinst=18,var='QVrz',ik=0,jk=0):\\n\\n tinst = int(tinst)\\n \\n # in case f is not passed, f and ax are created\\n if not f:\\n f,ax=plt.subplots()\\n\\n # Name the axes \\n decorate_ax(ax,'',daytime(tinst),'')\\n \\n\\n # specify full path of the data\\n\\n iensmean = 1\\n \\n if iensmean:\\n srcpath = BASE3D + oro + '/' + sm +'/' + CIRCMEAN\\n print srcpath\\n else: # 1 single ensemble member first day\\n srcpath = BASE3D + oro + '/' + sm +'/'\\n seedname= filter(lambda x: x.startswith('circmean_seed'), os.listdir(srcpath))[0]\\n srcpath +=seedname\\n\\n # Open the data in netcdf format and read it only \\n ncfl = Dataset(srcpath,'r')\\n \\n # Load the fields of interest\\n # COSMO fields dimensions are (time, z,rlat,rlon)\\n #\\n # Field dimensions in the following are (time,z,r)\\n #\\n # By specifing '::-1' the second timension is inverted\\n urz = ncfl.variables['Urz'][tinst,::-1,:] # U component of wind\\n wrz = ncfl.variables['Wrz'][tinst,::-1,:] # W component of wind\\n\\n speedrz = ncfl.variables['Speedrz'][tinst,::-1,:] # wind speed\\n rhorz = ncfl.variables['RHOrz'][:,::-1,:] # density in rz coordinates\\n TOTP = ncfl.variables['TOT_PRECr'][:,:]/2. # half-hourly output\\n \\n LCLr= ncfl.variables['LCL_MLr'][tinst,:]/1000. # LCL\\n LFCr = ncfl.variables['LFC_MLr'][tinst,:]/1000. # LFC\\n hPBLr = ncfl.variables['HPBLr'][tinst,:]/1000. \\n \\n CAPEr = ncfl.variables['CAPE_MLr'][tinst,:] # CAPE\\n CINr = ncfl.variables['CIN_MLr'][tinst,:] # CIN\\n \\n TOTPsum = np.sum(TOTP[:tinst,:],axis=0)\\n TOTPsum = TOTP[tinst,:]\\n \\n TPthres = 0.5\\n rainyr=np.where(TOTPsum>TPthres)\\n\\n\\n if var: #select a specific humidity var\\n qvrz = ncfl.variables[var][:,::-1,:] # specficif humidity\\n qcrz = ncfl.variables['QCrz'][:,::-1,:]\\n else: # otherwise sum it all up:\\n qxrzvars = filter(lambda x: x.startswith('Q'),ncfl.variables.keys())\\n \\n qvrz = np.zeros(ncfl.variables['QVrz'].shape)\\n for var in qxrzvars:\\n print var\\n qvrz+=ncfl.variables[var][:,::-1,:]\\n \\n tref = 12 # 06:00\\n ipltdiff= 0\\n if ipltdiff:\\n plotvar = rhorz[tinst,:]*qvrz[tinst,:]-rhorz[tref,:]*qvrz[tref,:]\\n qcrz = rhorz[tinst,:]*qcrz[tinst,:]-rhorz[tref,:]*qcrz[tref,:]\\n else:\\n plotvar = rhorz[tinst,:]*qvrz[tinst,:]\\n \\n\\n rhorz = rhorz[tinst,:]\\n \\n \\n # Load the grid in r, z coordinate\\n X = ncfl.variables['X'][:]\\n \\n \\n # nasty and temporary workaround as Z is empty in single seed data - just\\n # take it from the circmean field\\n srcpath2 = BASE3D + oro + '/' + sm +'/' + CIRCMEAN\\n ncfl2=Dataset(srcpath2)\\n Z = ncfl2.variables['Z'][::-1,:]/1000. # highest index <-> ground\\n ncfl2.close() \\n \\n # Add mountain contour\\n r=X[0,:]\\n ax.plot(r,Z[0,:],color='grey',linewidth=2)\\n \\n# ax.plot(r,hPBLr,'k-.',linewidth=1)\\n# ax.plot(r,LCLr,'k-',linewidth=1) \\n \\n ax.fill_between(X[0,:],Z[0,:],0,color='lightgrey')\\n \\n #indicate rainy region\\n \\n ifillrainy = False\\n if ifillrainy:\\n ax.fill_between(X[0,rainyr][0],Z[0,rainyr][0],color='lightblue',alpha=0.8) \\n ax.plot(X[0,rainyr][0],Z[0,rainyr][0],color='lightblue',linewidth=2)\\n else:\\n pass#ax.plot(X[0,rainyr][0],Z[0,rainyr][0],color='blue',linewidth=2,linestyle='dashed')\\n \\n # Velocity vectors with speed (length) smaller than speedthres are not \\n # shown\\n oroorig = oro\\n if oro.endswith('bell') or oro.endswith('cos2'):\\n \\n oro = oro[:-5]\\n print oro\\n \\n i,j=np.where(expnames==oro)\\n\\n if i==[]:\\n print 'HH'\\n \\n oro = oro.split('_')[0]\\n h,a = getha(oro)\\n #h,a = hrange[i],arange[j]\\n print h,a\\n xrang = [0,40]\\n yrang = [0,10.]\\n delx = xrang[1]-xrang[0]\\n dely = yrang[1]-yrang[0]\\n \\n speedthres = 0.1# m/s\\n M = speedrz[:] < speedthres\\n U = ma.masked_array(urz[:,:],mask=M)\\n scalefac_w = 1. #delx/dely\\n W = ma.masked_array(scalefac_w*wrz[:,:],mask=M) \\n \\n \\n \\n if 0: # REMOVE\\n fact_agl = -dely/delx\\n sin = np.arcsin(fact_agl)\\n cos = np.arccos(fact_agl)\\n U=cos*U-sin*W\\n W=sin*U+cos*W\\n # Plot radial velocity\\n urzlevs = np.linspace(vm[0],vm[1],10)\\n\\n\\n levs = np.array([2,4,6,8,10,12,14,16])\\n #levs = np.array([0.25,0.5,1,2,4,8,16,32])\\n #levs = np.array([0.5,1,2,4,8,16,32])\\n if ipltdiff:\\n levs=levs/8. #np.linspace(0.001,0.004,11)d\\n #else:\\n # levs=np.array([0.001,0.0015,0.002,0.0025,0.003,0.0035,0.004])*50\\n #if var.startswith('QC'): levs=np.linspace(0.1,1.5,9)/1000.\\n \\n #cf = ax.contourf(X,Z,plotvar*1000., levels=levs*1000.,cmap=viridis_inv,extend='both')\\n \\n ipltmoistening = False \\n if ipltmoistening:\\n cf = ax.contourf(X,Z,plotvar*1000.,cmap=viridis_inv,extend='both',\\n levels=levs)\\n else:\\n cf = 0\\n \\n #cfc = ax.contourf(X,Z,qvrz*1000.,cmap='Blues',extend='both', alpha=1,\\n # levels=levs/4.) \\n\\n iplt_thermodynvar = False\\n if iplt_thermodynvar:\\n for var in [LFCr]:\\n print var.shape\\n print X.shape\\n ax.plot(var)\\n \\n \\n qstx = 2\\n qstz = 2\\n Q=ax.quiver(X[::qstz,::qstx],(Z+0.02)[::qstz,::qstx],U[::qstz,::qstx],W[::qstz,::qstx],\\n units='inches',scale=10,angles='xy', color='red',pivot='mid',\\n headwidth=4,width=0.009)\\n #Q=ax.quiverkey(Q,a/2,h/2000.,1,r'$1\\\\frac{m}{s}$',labelpos='N',coordinates='data')\\n\\n if jk==2 or oroorig.endswith('cos2'):#(ik,jk)==(1,0):\\n ax.quiverkey(Q,-2,0.05,1,r'$1 \\\\frac{m}{s}$',labelsep=0.05,\\n labelpos='N',coordinates='data')\\n\\n\\n ax.set_xticks(np.arange(0,80,20)) \\n\\n ax.set_xlim(xrang)\\n ax.set_ylim(yrang)\\n\\n if ik==2:\\n ax.set_xlabel('r in km')\\n if jk==0:\\n ax.set_ylabel('z in km') \\n \\n ax.grid(True)\\n\\n ncfl.close()\\n \\n return f,ax ,cf # plot_uwrz_field\",\n \"def plot_results(models,\\n data,\\n batch_size=128,\\n model_name=\\\"vae_mnist\\\"):\\n\\n encoder, decoder = models\\n x_test, y_test = data\\n os.makedirs(model_name, exist_ok=True)\\n\\n filename = os.path.join(model_name, \\\"vae_mean.png\\\")\\n # display a 2D plot of the digit classes in the latent space\\n z_mean, _, _ = encoder.predict(x_test,\\n batch_size=batch_size)\\n plt.figure(figsize=(12, 10))\\n plt.scatter(z_mean[:, 0], z_mean[:, 1], c=y_test)\\n plt.colorbar()\\n plt.xlabel(\\\"z[0]\\\")\\n plt.ylabel(\\\"z[1]\\\")\\n plt.savefig(filename)\\n plt.show()\\n\\n filename = os.path.join(model_name, \\\"digits_over_latent.png\\\")\\n # display a 30x30 2D manifold of digits\\n n = 30\\n digit_size = 28\\n figure = np.zeros((digit_size * n, digit_size * n))\\n # linearly spaced coordinates corresponding to the 2D plot\\n # of digit classes in the latent space\\n grid_x = np.linspace(-4, 4, n)\\n grid_y = np.linspace(-4, 4, n)[::-1]\\n\\n for i, yi in enumerate(grid_y):\\n for j, xi in enumerate(grid_x):\\n z_sample = np.array([[xi, yi]])\\n x_decoded = decoder.predict(z_sample)\\n digit = x_decoded[0].reshape(digit_size, digit_size)\\n figure[i * digit_size: (i + 1) * digit_size,\\n j * digit_size: (j + 1) * digit_size] = digit\\n\\n plt.figure(figsize=(10, 10))\\n start_range = digit_size // 2\\n end_range = n * digit_size + start_range + 1\\n pixel_range = np.arange(start_range, end_range, digit_size)\\n sample_range_x = np.round(grid_x, 1)\\n sample_range_y = np.round(grid_y, 1)\\n plt.xticks(pixel_range, sample_range_x)\\n plt.yticks(pixel_range, sample_range_y)\\n plt.xlabel(\\\"z[0]\\\")\\n plt.ylabel(\\\"z[1]\\\")\\n plt.imshow(figure, cmap='Greys_r')\\n plt.savefig(filename)\\n plt.show()\",\n \"def plot_vis_test(plotfile,pdf_file):\\n\\t# First some parameters looked up from configfile---------------------------------\\n\\t\\n\\tgrbdir = runconf['l2file'][0:10]\\n\\tpre_tstart = runconf['bkg1start']\\n\\tpre_tend = runconf['bkg1end']\\n\\ttrigtime = runconf['trigtime']\\n\\tgrb_tstart = runconf['transtart']\\n\\tgrb_tend = runconf['tranend']\\n\\tpost_tstart = runconf['bkg2start']\\n\\tpost_tend = runconf['bkg2end']\\n\\tt_src = grb_tend - grb_tstart \\n\\tt_tot = (pre_tend-pre_tstart)+(post_tend-post_tstart)\\n\\tra_tran = runconf['ra']\\n\\tdec_tran = runconf['dec']\\n\\tlc_bin = runconf['lc_bin']\\n\\talpha = runconf['alpha']\\n\\tbeta = runconf['beta']\\n\\tE0 = runconf['E0']\\n\\tA = runconf['A']\\n\\tsim_scale = t_src\\n\\tpixbin = int(runconf['pixsize'])\\n\\tcomp_bin = int(runconf['comp_bin'])\\n\\ttyp = runconf['typ']\\n\\n\\t# Calling txy to calculate thetax thetay and the coordinates----------------------\\n\\t\\n\\tthetax,thetay,x,y,z,t = txy(runconf['mkffile'], trigtime, ra_tran, dec_tran)\\n\\t\\n\\t# Plot the 3d visualisation for the position of the transient---------------------\\n\\tplt.figure()\\n\\tfig = visualize_3d(grbdir,x,y,z, t, thetax, thetay, grbdir)\\t\\n\\tpdf_file.savefig(fig)\\n\\t\\n\\t# Plotting the lightcurves for the four quadrants---------------------------------\\n\\tfig = plt.figure()\\n\\tclean_file = fits.open(runconf['infile'])\\n\\tplt.title('Light curves for '+grbdir + \\\"\\\\n\\\" + r\\\"$\\\\theta_x$={tx:0.1f} and $\\\\theta_y$={ty:0.1f} \\\".format(tx=thetax,ty=thetay))\\n\\t\\n\\tquad0 = clean_file[1].data\\n\\tdata0,bin_edge = np.histogram(quad0['time'], bins=np.arange(quad0['time'][0],quad0['time'][-1],lc_bin))\\n\\tplt.plot((bin_edge[:-1]+bin_edge[1:])/2.0,data0,label='Quad 0',lw=0.7)\\n quad1 = clean_file[2].data\\n\\tdata1,bin_edge = np.histogram(quad1['time'], bins=np.arange(quad1['time'][0],quad1['time'][-1],lc_bin))\\n\\tplt.plot((bin_edge[:-1]+bin_edge[1:])/2.0,data1,label='Quad 1',lw=0.7) \\n\\tquad2 = clean_file[3].data\\n\\tdata2,bin_edge = np.histogram(quad2['time'], bins=np.arange(quad2['time'][0],quad2['time'][-1],lc_bin))\\n\\tplt.plot((bin_edge[:-1]+bin_edge[1:])/2.0,data2,label='Quad 2',lw=0.7)\\n quad3 = clean_file[4].data\\n data3,bin_edge = np.histogram(quad3['time'], bins=np.arange(quad3['time'][0],quad3['time'][-1],lc_bin))\\n plt.plot((bin_edge[:-1]+bin_edge[1:])/2.0,data3,label='Quad 3',lw=0.7)\\n\\tplt.axvspan(grb_tstart,grb_tend,color='blue',alpha=0.1,label='GRB')\\n\\tplt.axvspan(pre_tstart,pre_tend,color='orange',alpha=0.2)\\n\\tplt.axvspan(post_tstart,post_tend,color='orange',alpha=0.2,label='Background')\\n\\tplt.legend(prop={'size':6})\\n\\tplt.xlim(pre_tstart-100,post_tend+100)\\n\\tpdf_file.savefig(fig)\\n\\t\\n\\t# Calling the sim_dph--------------------------------------------------------------\\n\\t\\n\\tgrb_flat,bkgd_flat,grb_dph,bkgd_dph,t_src,t_total = data_bkgd_image(grbdir,pre_tstart,pre_tend,grb_tstart,grb_tend,post_tstart,post_tend)\\n\\n\\tsim_flat,sim_dph,badpix_mask,sim_err_dph = simulated_dph(grbdir,typ,t_src,alpha,beta,E0,A)\\n\\n\\tsrc_dph = grb_dph-bkgd_dph*t_src/t_tot\\n\\n print \\\"Total counts in simulated dph: \\\",(sim_dph).sum()\\n print \\\"Total counts after badpix mask is applied: \\\",(sim_dph*badpix_mask).sum()\\n\\tprint \\\"Excess counts in badpix masked src dph: \\\",(src_dph*badpix_mask).sum()\\n \\n\\t# Plotting the DPHs before badpix correction---------------------------------------\\n\\t\\n\\tf,((ax1,ax2),(ax3,ax4)) = plt.subplots(2,2)\\n\\tplt.suptitle('DPHs before badpix correction for '+grbdir + \\\"\\\\n\\\" + r\\\"$\\\\theta_x$={tx:0.1f} and $\\\\theta_y$={ty:0.1f} \\\".format(tx=thetax,ty=thetay))\\n \\t# Sim\\n\\tim = ax3.imshow(sim_dph,interpolation='none')\\n\\tax3.set_title('Sim DPH',fontsize=8)\\n\\tax3.set_xlim(-1,128 - 0.5)\\n\\tax3.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\\n\\tax3.spines['left'].set_position(('data',-0.5))\\n\\tax3.set_yticklabels([])\\n\\tax3.xaxis.set_ticks(np.arange(0,128,16))\\n\\tf.colorbar(im,ax=ax3,fraction=0.046, pad=0.04)\\n\\t\\n\\t # Source \\n\\tim = ax4.imshow(src_dph,interpolation='none',vmin=0)\\n\\tax4.set_title('Src DPH (bkg subtracted)',fontsize=8)\\n\\tax4.set_xlim(-1,128 -0.5)\\n\\tax4.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\\n\\tax4.spines['left'].set_position(('data',-0.5))\\n\\tax4.set_yticklabels([])\\n\\tax4.xaxis.set_ticks(np.arange(0,128,16))\\n\\tf.colorbar(im,ax=ax4,fraction=0.046, pad=0.04)\\n\\n \\t# Source + Background\\n\\tim = ax1.imshow(grb_dph,interpolation='none')\\n\\tax1.set_title('Src + Bkg DPH',fontsize=8)\\n\\tax1.set_xlim(-1,128 -0.5)\\n\\tax1.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\\n\\tax1.spines['left'].set_position(('data',-0.5))\\n\\tax1.set_yticklabels([])\\n\\tax1.xaxis.set_ticks(np.arange(0,128,16))\\n\\tf.colorbar(im,ax=ax1,fraction=0.046, pad=0.04)\\n\\n \\t# Background\\n\\tim = ax2.imshow(bkgd_dph*t_src/t_total,interpolation='none')\\n\\tax2.set_title('Bkg DPH',fontsize=8)\\n\\tax2.set_xlim(-1,128 -0.5)\\n\\tax2.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\\n\\tax2.spines['left'].set_position(('data',-0.5))\\n\\tax2.set_yticklabels([])\\n\\tax2.xaxis.set_ticks(np.arange(0,128,16))\\n\\tf.colorbar(im,ax=ax2,fraction=0.046, pad=0.04)\\n\\tf.set_size_inches([6.5,6.5])\\n\\tpdf_file.savefig(f) # saves the current figure into a pdf_file page\\n\\t\\n\\t# Plotting the Badpix mask---------------------------------------------\\n\\n\\tfig = plt.figure()\\n\\tax = plt.subplot(111)\\n\\tplt.title('Badpix Mask for '+grbdir+ \\\"\\\\n\\\" + r\\\"$\\\\theta_x$={tx:0.1f} and $\\\\theta_y$={ty:0.1f} \\\".format(tx=thetax,ty=thetay))\\n\\tim = ax.imshow(badpix_mask,interpolation='none')\\n\\tax.set_xlim(-9,128 -0.5)\\n\\tax.axvline(x=-5.,ymin=0,ymax=64,linewidth=5,color='k')\\n\\tax.spines['left'].set_position(('data',-0.5))\\n\\tax.xaxis.set_ticks(np.arange(0,128,16))\\n\\tax.yaxis.set_ticks(np.arange(0,128,16))\\n\\tfig.colorbar(im,ax=ax,fraction=0.046, pad=0.04)\\n\\t\\n\\tpdf_file.savefig(fig) # saves the current figure into a pdf_file page\\n\\n\\t# Plotting badpix masked graphs--------------------------------------------\\n\\tf,((ax1,ax2),(ax3,ax4)) = plt.subplots(2,2)\\n\\tplt.suptitle('DPHs after badpix correction for '+grbdir+ \\\"\\\\n\\\" + r\\\"$\\\\theta_x$={tx:0.1f} and $\\\\theta_y$={ty:0.1f} \\\".format(tx=thetax,ty=thetay))\\n \\t# Sim\\n\\tim = ax3.imshow(sim_dph*badpix_mask,interpolation='none')\\n\\tax3.set_title('Sim DPH',fontsize=8)\\n\\tax3.set_xlim(-1,128 -0.5)\\n\\tax3.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\\n\\tax3.spines['left'].set_position(('data',-0.5))\\n\\tax3.set_yticklabels([])\\n\\tax3.xaxis.set_ticks(np.arange(0,128,16))\\n\\tf.colorbar(im,ax=ax3,fraction=0.046, pad=0.04)\\n\\n\\t # Source \\n\\tim = ax4.imshow(src_dph*badpix_mask,interpolation='none',vmin=0)\\n\\tax4.set_title('Src DPH (bkg subtracted)',fontsize=8)\\n\\tax4.set_xlim(-1,128 -0.5)\\n\\tax4.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\\n\\tax4.spines['left'].set_position(('data',-0.5))\\n\\tax4.set_yticklabels([])\\n\\tax4.xaxis.set_ticks(np.arange(0,128,16))\\n\\tf.colorbar(im,ax=ax4,fraction=0.046, pad=0.04)\\n\\n\\t # Source + Background\\n\\tim = ax1.imshow(grb_dph*badpix_mask,interpolation='none')\\n\\tax1.set_title('Src + Bkg DPH',fontsize=8)\\n\\tax1.set_xlim(-1,128 -0.5)\\n\\tax1.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\\n\\tax1.spines['left'].set_position(('data',-0.5))\\n\\tax1.set_yticklabels([])\\n\\tax1.xaxis.set_ticks(np.arange(0,128,16))\\n\\tf.colorbar(im,ax=ax1,fraction=0.046, pad=0.04)\\n\\t\\n\\t # Background\\n\\tim = ax2.imshow(bkgd_dph*badpix_mask*t_src/t_total,interpolation='none')\\n\\tax2.set_title('Bkg DPH',fontsize=8)\\n\\tax2.set_xlim(-1,128 -0.5)\\n\\tax2.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\\n\\tax2.spines['left'].set_position(('data',-0.5))\\n\\tax2.set_yticklabels([])\\n\\tax2.xaxis.set_ticks(np.arange(0,128,16))\\n\\tf.colorbar(im,ax=ax2,fraction=0.046, pad=0.04)\\n\\tf.set_size_inches([6.5,6.5])\\n\\tpdf_file.savefig(f) # saves the current figure into a pdf_file page\\n\\n\\t# Plotting badpix masked graphs (Binned) ----------------------------------------------------\\n\\tfor p in [4,8,16]:\\n\\t\\tf,((ax1,ax2),(ax3,ax4)) = plt.subplots(2,2)\\n\\t\\tplt.suptitle('DPHs after badpix correction for '+grbdir+ \\\"\\\\n\\\" + r\\\"$\\\\theta_x$={tx:0.1f} and $\\\\theta_y$={ty:0.1f} \\\".format(tx=thetax,ty=thetay)+ \\\"pixsize=\\\"+str(p))\\n\\t\\t # Sim\\n\\t\\tim = ax3.imshow(resample(sim_dph*badpix_mask,p),interpolation='none')\\n\\t\\tax3.set_title('Sim DPH',fontsize=8)\\n\\t\\tax3.set_xlim(-1,128/p -0.5)\\n\\t\\tax3.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\\n\\t\\tax3.spines['left'].set_position(('data',-0.5))\\n\\t\\tax3.set_yticklabels([])\\n\\t\\tax3.xaxis.set_ticks(np.arange(0,(128/p),16/p))\\n\\t\\tax3.set_xticklabels(np.arange(0,128,16))\\n\\t\\tf.colorbar(im,ax=ax3,fraction=0.046, pad=0.04)\\n\\t\\t\\n\\t\\t # Source \\n\\t\\tim = ax4.imshow(resample(src_dph*badpix_mask,p),interpolation='none',vmin=0)\\n\\t\\tax4.set_title('Src DPH (bkg subtracted)',fontsize=8)\\n\\t\\tax4.set_xlim(-1,128/p -0.5)\\n\\t\\tax4.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\\n\\t\\tax4.spines['left'].set_position(('data',-0.5))\\n\\t\\tax4.set_yticklabels([])\\n ax4.xaxis.set_ticks(np.arange(0,(128/p),16/p))\\n ax4.set_xticklabels(np.arange(0,128,16))\\t\\t\\n\\t\\tf.colorbar(im,ax=ax4,fraction=0.046, pad=0.04)\\n\\t\\t\\n\\t\\t # Source + Background\\n\\t\\tim = ax1.imshow(resample(grb_dph*badpix_mask,p),interpolation='none')\\n\\t\\tax1.set_title('Src + Bkg DPH',fontsize=10)\\n\\t\\tax1.set_xlim(-1,128/p -0.5)\\n\\t\\tax1.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\\n\\t\\tax1.spines['left'].set_position(('data',-0.5))\\n\\t\\tax1.set_yticklabels([])\\n ax1.xaxis.set_ticks(np.arange(0,(128/p),16/p))\\n ax1.set_xticklabels(np.arange(0,128,16))\\t\\t\\n\\t\\tf.colorbar(im,ax=ax1,fraction=0.046, pad=0.04)\\n\\t\\t\\n\\t\\t # Background\\n\\t\\tim = ax2.imshow(resample(bkgd_dph*badpix_mask*t_src/t_total,p),interpolation='none')\\n\\t\\tax2.set_title('Bkg DPH',fontsize=8)\\n\\t\\tax2.set_xlim(-1,128/p -0.5)\\n\\t\\tax2.axvline(x=-0.75,ymin=0,ymax=64,linewidth=5,color='k')\\n\\t\\tax2.spines['left'].set_position(('data',-0.5))\\n\\t\\tax2.set_yticklabels([])\\n ax2.xaxis.set_ticks(np.arange(0,(128/p),16/p))\\n ax2.set_xticklabels(np.arange(0,128,16))\\t\\t\\n\\t\\tf.colorbar(im,ax=ax2,fraction=0.046, pad=0.04)\\n\\t\\tf.set_size_inches([6.5,6.5])\\n\\t\\t\\n\\t\\tpdf_file.savefig(f) # saves the current figure into a pdf_file page\\n\\n\\n\\t# Plotting the comparison graphs with equal bins ---------------------------------------\\n\\tprint \\\"No. of pixels with zero counts in sim_dph: \\\",sim_dph[sim_dph==0].size\\n\\tprint \\\"No. of pixels with zero counts in grb_dph(no bkg subtration): \\\",grb_dph[grb_dph==0].size\\n\\t\\n\\t# Generating the array for module number ------------------------------------------------\\n\\tA = ['A'+str(i) for i in range(16)]\\n\\tB = np.flip(['B'+str(i) for i in range(16)],0)\\n\\tC = np.flip(['C'+str(i) for i in range(16)],0)\\n\\tD = ['D'+str(i) for i in range(16)]\\n\\tquad_a = np.reshape(A,(4,4))\\n\\tquad_b = np.reshape(B,(4,4))\\n\\tquad_c = np.reshape(C,(4,4))\\n\\tquad_d = np.reshape(D,(4,4))\\n\\tMod_arr = np.ndarray((8,8),dtype='|S3')\\n\\tMod_arr[:4,:4] = quad_a\\n\\tMod_arr[:4,4:] = quad_b\\n\\tMod_arr[4:,4:] = quad_c\\n\\tMod_arr[4:,:4] = quad_d\\n\\tMod_names = Mod_arr.flatten()\\n\\t#print \\\"Module name array : \\\",Mod_names\\n\\t#-----------------------------------------------------------------------------------------\\n\\t\\t\\n\\tsim_dph = sim_dph*badpix_mask\\n\\tsim_err_dph = sim_err_dph*badpix_mask\\n grb_dph = grb_dph*badpix_mask\\n bkgd_dph = bkgd_dph*badpix_mask\\n\\tgrb_err_dph = np.sqrt(grb_dph)*badpix_mask\\n\\tbkgd_err_dph = np.sqrt(bkgd_dph)*badpix_mask\\n\\n\\tsim_bin = resample(sim_dph,pixbin)\\n\\tsim_err_bin = np.sqrt(resample(sim_err_dph**2,pixbin))\\t\\n\\tgrb_bin = resample(grb_dph,pixbin)\\n\\tbkgd_bin = resample(bkgd_dph,pixbin)\\n\\tgrb_err_bin = np.sqrt(resample(grb_err_dph,pixbin))\\t\\n\\tbkgd_err_bin = np.sqrt(resample(bkgd_err_dph,pixbin))\\t\\n\\n\\tsim_flat_bin = sim_bin.flatten()\\n\\tsim_err_flat_bin = sim_err_bin.flatten()\\n\\tgrb_flat_bin = grb_bin.flatten()\\n\\tbkgd_flat_bin = bkgd_bin.flatten()\\n\\tgrb_err_flat_bin = grb_err_bin.flatten()\\n\\tbkgd_err_flat_bin = bkgd_err_bin.flatten()\\n\\t\\n\\n\\t # Defining model background and data\\n\\tmodel = sim_flat_bin\\n\\tmodel_copy = np.copy(model)\\n\\tbkgd = bkgd_flat_bin*t_src/t_tot\\n\\tsrc = grb_flat_bin\\n\\t\\n\\tdata = src - bkgd\\n\\tdata_copy = np.copy(data)\\n\\t\\n\\terr_src = grb_err_flat_bin\\n\\terr_bkgd = bkgd_err_flat_bin\\n\\terr_model = sim_err_flat_bin\\n\\terr_model_copy = np.copy(err_model)\\n\\terr_data = np.sqrt(((err_src)**2) + ((err_bkgd)**2)*(t_src/t_total)**2)\\n\\terr_data_copy = np.copy(err_data)\\n\\t\\n\\tratio = data/model\\n\\terr_ratio = ratio*np.sqrt(((err_data/data)**2) + ((err_model/model)**2))\\n\\t\\n\\tchi_sq = (((model-data)**2)/((err_model)**2 + (err_data)**2)).sum()\\n\\t\\n\\t # PLotting the comparison plots\\n\\tf,(ax1,ax2) = plt.subplots(2,gridspec_kw={'height_ratios':[2,1]},sharex='row')\\n\\t\\n\\tax1.set_title(\\\"Comparison between simulated and real data for \\\"+grbdir+ \\\"\\\\n\\\" + r\\\"$\\\\theta_x$={tx:0.1f} and $\\\\theta_y$={ty:0.1f} $\\\\chi^2$={c:0.1f}\\\".format(tx=thetax,ty=thetay,c=chi_sq))\\n\\tax1.errorbar(np.arange(0,(len(data))),data,yerr=err_data,fmt='.',markersize=2,label=\\\"Data\\\",elinewidth=0.5)\\n\\tax1.errorbar(np.arange(0,(len(model))),model,yerr=err_model,fmt='.',markersize=2,label=\\\"Simulation\\\",elinewidth=0.5)\\n\\tax1.legend()\\n ax1.xaxis.set_ticks(np.arange(0,len(data)))\\n\\tax1.set_ylabel('Counts')\\n\\tax1.xaxis.grid(linewidth=0.5,alpha=0.3)\\n ax1.set_xticklabels(Mod_names,rotation=90,fontsize=5)\\n\\n\\tax2.errorbar(np.arange(0,(len(ratio))),ratio,yerr=err_ratio,fmt='.',markersize=2,label=\\\"Ratio = Data/Model\\\",elinewidth=0.5)\\n\\tax2.xaxis.set_ticks(np.arange(0,len(data)))\\n ax2.set_xticklabels(Mod_names,rotation=90,fontsize=5)\\n ax2.yaxis.set_ticks(np.arange(int(min(ratio-err_ratio)-1),int(max(ratio+err_ratio)+2),1))\\n\\tax2.tick_params(labelsize=5)\\n\\tax2.axhline(y=1,linewidth=0.5,color='k')\\n\\tax2.legend()\\n\\tax2.set_xlabel('CZT Modules')\\n\\tax2.set_ylabel('Ratio of counts')\\n\\tax2.xaxis.grid(linewidth=0.5,alpha=0.3)\\n\\tplt.tight_layout(h_pad=0.0)\\n\\tf.set_size_inches([6.5,10])\\n\\tpdf_file.savefig(f,orientation='portrait') # saves the current figure into a pdf_file page\\n\\n\\t# Plotting comparison graphs with random binning------------------------------\\n\\t\\n sim_flat = sim_dph.flatten()\\n\\tsim_err_flat = sim_err_dph.flatten()\\n grb_flat = grb_dph.flatten()\\n bkgd_flat = bkgd_dph.flatten()\\n\\tsrc_flat = src_dph.flatten()\\n\\t\\n\\torder = np.random.permutation(np.arange(0,len(sim_flat)))\\n\\t\\n sim_flat = sim_flat[order]\\n\\tsim_err_flat = sim_err_flat[order]\\n\\tgrb_flat = grb_flat[order]\\n\\tbkgd_flat = bkgd_flat[order]\\n\\tsrc_flat = src_flat[order]\\n\\t\\n\\tprint \\\"No. of pixels with zero counts in sim_flat: \\\",sim_flat[sim_flat==0].size\\n\\tprint \\\"No. of pixels with zero counts in src_flat: \\\",src_flat[src_flat==0].size\\n\\t\\n\\tbins = np.array(np.sort(np.random.uniform(0,1,comp_bin)*len(sim_flat)),dtype=np.int64)\\n\\tx = np.zeros(len(bins)+2,dtype=np.int64)\\n\\tx[0] = 0\\n\\tx[-1] = len(sim_flat)\\n\\tx[1:-1] = bins\\n\\t\\n\\t#print \\\"The bin edges: \\\",x # ---------------------------------------------------------------\\n\\t\\n\\tsim_flat_bin = np.array([sim_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)])\\n\\tsim_err_flat_bin = np.sqrt(np.array([(sim_err_flat[x[i]:x[i+1]]**2).sum() for i in range(comp_bin+1)]))\\n\\tgrb_flat_bin = np.array([grb_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)])\\n\\tgrb_err_flat_bin = np.sqrt(np.array([grb_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)]))\\n\\tbkgd_flat_bin = np.array([bkgd_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)])\\n\\tbkgd_err_flat_bin = np.sqrt(np.array([bkgd_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)]))\\n\\tsrc_flat_bin = np.array([src_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)])\\n\\t\\n\\tprint \\\"Total sim_flat_bin : \\\",sim_flat_bin.sum() #-----------------------------------------\\n\\t#print \\\" Max(cumsum) : \\\",max(np.cumsum(sim_flat)) #-----------------------------------------\\n\\n # Defining model background and data\\n model = sim_flat_bin #avg_flat_bin\\n bkgd = bkgd_flat_bin*t_src/t_tot\\n src = grb_flat_bin\\n\\t\\n data = src - bkgd\\n\\n err_src = np.sqrt(src)\\n err_bkgd = np.sqrt(bkgd_flat_bin)\\n err_model = sim_err_flat_bin\\n err_data = np.sqrt(((err_src)**2) + ((err_bkgd)**2)*(t_src/t_total)**2)\\n\\t\\n\\tchi_sq_new = (((model-data)**2)/((err_model)**2 + (err_data)**2)).sum()\\n # PLotting the comparison plots\\n fig = plt.figure()\\n plt.title(\\\"Comparison between simulated and real data for \\\"+grbdir+ \\\"\\\\n\\\" + r\\\"$\\\\theta_x$={tx:0.1f} and $\\\\theta_y$={ty:0.1f} $\\\\chi^2$={c:0.1f} \\\".format(tx=thetax,ty=thetay,c=chi_sq_new))\\n plt.errorbar(np.arange(0,(len(data))),data,yerr=err_data,fmt='.',markersize=2,label=\\\"Data\\\",elinewidth=0.5)\\n plt.errorbar(np.arange(0,(len(model))),model,yerr=err_model,fmt='.',markersize=2,label=\\\"Simulation\\\",elinewidth=0.5)\\n plt.ylabel('Counts')\\n\\tplt.xlabel('Random Bins')\\n\\tplt.xticks(np.arange(0,(len(data)),1))\\n\\tplt.legend()\\n pdf_file.savefig(fig) #saves the current figure into a pdf_file page\\n\\n\\t# Plotting observed vs predicted counts------------------------------------------------------\\n\\n\\tfig = plt.figure()\\n\\tplt.title(grbdir + r\\\" : Observed vs Predicted counts with $\\\\chi^2$={cs:0.1f}\\\".format(cs=chi_sq))\\n\\tplt.errorbar(model_copy,data_copy,xerr=err_model_copy,yerr=err_data_copy,fmt='g.',markersize=2,elinewidth=0.5)\\n\\tfor i in range(len(model_copy)):\\n\\t\\tplt.text(model_copy[i],data_copy[i],Mod_names[i],fontsize=5)\\n\\tplt.plot(np.arange(-1000,1000),np.arange(-1000,1000),'k',linewidth=0.5)\\n\\tplt.xlim(min(model_copy)-5,max(model_copy)+5)\\n\\tplt.ylim(min(data_copy)-5,max(data_copy)+5)\\n\\tplt.xlabel('Predicted Counts')\\n\\tplt.ylabel('Observed Counts')\\n\\tplt.legend()\\n\\tplt.grid()\\n\\tpdf_file.savefig(fig)\\n\\n\\t# Scaling the model using curve fit =============================================================== \\n\\t\\n\\tparam,pcov = curve_fit(fit_line_int,model_copy,data_copy)\\n\\tscaling = param[0]\\n\\tintercept = param[1]\\n\\t\\n\\t# Plotting the scaled plots ===================================================================\\n\\t# Plotting the comparison graphs with equal bins ---------------------------------------\\n\\n\\tsim_dph = sim_dph*badpix_mask\\n\\tsim_err_dph = sim_err_dph*badpix_mask\\n grb_dph = grb_dph*badpix_mask\\n bkgd_dph = bkgd_dph*badpix_mask\\n\\tgrb_err_dph = np.sqrt(grb_dph)*badpix_mask\\n\\tbkgd_err_dph = np.sqrt(bkgd_dph)*badpix_mask\\n\\n\\tsim_bin = resample(sim_dph,pixbin)\\n\\tsim_err_bin = np.sqrt(resample(sim_err_dph**2,pixbin))\\t\\n\\tgrb_bin = resample(grb_dph,pixbin)\\n\\tbkgd_bin = resample(bkgd_dph,pixbin)\\n\\tgrb_err_bin = np.sqrt(resample(grb_err_dph,pixbin))\\t\\n\\tbkgd_err_bin = np.sqrt(resample(bkgd_err_dph,pixbin))\\t\\n\\n\\tsim_flat_bin = sim_bin.flatten()\\n\\tsim_err_flat_bin = sim_err_bin.flatten()\\n\\tgrb_flat_bin = grb_bin.flatten()\\n\\tbkgd_flat_bin = bkgd_bin.flatten()\\n\\tgrb_err_flat_bin = grb_err_bin.flatten()\\n\\tbkgd_err_flat_bin = bkgd_err_bin.flatten()\\n\\t\\n\\n\\t # Defining model background and data\\n\\t#model = sim_flat_bin*scaling\\n\\tmodel = sim_flat_bin*scaling + intercept\\n\\tbkgd = bkgd_flat_bin*t_src/t_tot\\n\\tsrc = grb_flat_bin\\n\\t\\n\\tdata = src - bkgd\\n\\t\\n\\terr_src = grb_err_flat_bin\\n\\terr_bkgd = bkgd_err_flat_bin\\n\\t#err_model = sim_err_flat_bin*scaling\\n\\terr_model = sim_err_flat_bin*scaling\\n\\terr_data = np.sqrt(((err_src)**2) + ((err_bkgd)**2)*(t_src/t_total)**2)\\n\\t\\n\\tratio = data/model\\n\\terr_ratio = ratio*np.sqrt(((err_data/data)**2) + ((err_model/model)**2))\\n\\t\\n\\tchi_sq = (((model-data)**2)/((err_model)**2 + (err_data)**2)).sum()\\n\\t\\n\\t # PLotting the comparison plots\\n\\tf,(ax1,ax2) = plt.subplots(2,gridspec_kw={'height_ratios':[2,1]},sharex='row')\\n\\t\\n\\tax1.set_title(\\\"Comparison between simulated (scaled) and real data for \\\"+grbdir+ \\\"\\\\n\\\" + r\\\"$\\\\theta_x$={tx:0.1f} and $\\\\theta_y$={ty:0.1f} $\\\\chi^2$={c:0.1f} \\\".format(tx=thetax,ty=thetay,c=chi_sq))\\n\\tax1.errorbar(np.arange(0,(len(data))),data,yerr=err_data,fmt='.',markersize=2,label=\\\"Data\\\",elinewidth=0.5)\\n\\tax1.errorbar(np.arange(0,(len(model))),model,yerr=err_model,fmt='.',markersize=2,label=\\\"Simulation (scaling = {s:0.2f},offset = {o:0.2f})\\\".format(s=scaling,o=intercept),elinewidth=0.5)\\n\\tax1.legend()\\n ax1.xaxis.set_ticks(np.arange(0,len(data)))\\n\\tax1.set_ylabel('Counts')\\n\\tax1.xaxis.grid(linewidth=0.5,alpha=0.3)\\n ax1.set_xticklabels(Mod_names,rotation=90,fontsize=5)\\n\\t\\n\\tax2.errorbar(np.arange(0,(len(ratio))),ratio,yerr=err_ratio,fmt='.',markersize=2,label=\\\"Ratio = Data/Model(scaling = {s:0.2f}, offset={o:0.2f})\\\".format(s=scaling,o=intercept),elinewidth=0.5)\\n\\tax2.xaxis.set_ticks(np.arange(0,len(data)))\\n ax2.set_xticklabels(Mod_names,rotation=90,fontsize=5)\\n ax2.yaxis.set_ticks(np.arange(int(min(ratio-err_ratio)-1),int(max(ratio+err_ratio)+2),1))\\n\\tax2.tick_params(labelsize=5)\\n\\tax2.axhline(y=1,linewidth=0.5,color='k')\\n\\tax2.legend()\\n\\tax2.set_xlabel('CZT Modules')\\n\\tax2.set_ylabel('Ratio of counts')\\n\\tax2.xaxis.grid(linewidth=0.5,alpha=0.3)\\n\\tplt.tight_layout(h_pad=0.0)\\n\\tf.set_size_inches([6.5,10])\\n\\tpdf_file.savefig(f,orientation='portrait') # saves the current figure into a pdf_file page\\n\\n\\t# Plotting comparison graphs with random binning------------------------------\\n\\t\\n sim_flat = sim_dph.flatten()\\n\\tsim_err_flat = sim_err_dph.flatten()\\n grb_flat = grb_dph.flatten()\\n bkgd_flat = bkgd_dph.flatten()\\n\\tsrc_flat = src_dph.flatten()\\n\\t\\n\\torder = np.random.permutation(np.arange(0,len(sim_flat)))\\n\\t\\n sim_flat = sim_flat[order]\\n\\tsim_err_flat = sim_err_flat[order]\\n\\tgrb_flat = grb_flat[order]\\n\\tbkgd_flat = bkgd_flat[order]\\n\\tsrc_flat = src_flat[order]\\n\\t\\n\\tbins = np.array(np.sort(np.random.uniform(0,1,comp_bin)*len(sim_flat)),dtype=np.int64)\\n\\tx = np.zeros(len(bins)+2,dtype=np.int64)\\n\\tx[0] = 0\\n\\tx[-1] = len(sim_flat)\\n\\tx[1:-1] = bins\\n\\t\\n\\tsim_flat_bin = np.array([sim_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)])\\n\\tsim_err_flat_bin = np.sqrt(np.array([(sim_err_flat[x[i]:x[i+1]]**2).sum() for i in range(comp_bin+1)]))\\n\\tgrb_flat_bin = np.array([grb_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)])\\n\\tgrb_err_flat_bin = np.sqrt(np.array([grb_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)]))\\n\\tbkgd_flat_bin = np.array([bkgd_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)])\\n\\tbkgd_err_flat_bin = np.sqrt(np.array([bkgd_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)]))\\n\\tsrc_flat_bin = np.array([src_flat[x[i]:x[i+1]].sum() for i in range(comp_bin+1)])\\n\\t\\n # Defining model background and data\\n #model = sim_flat_bin*scaling\\n\\tmodel = sim_flat_bin*scaling + intercept\\n bkgd = bkgd_flat_bin*t_src/t_tot\\n src = grb_flat_bin\\n\\t\\n data = src - bkgd\\n\\n err_src = np.sqrt(src)\\n err_bkgd = np.sqrt(bkgd_flat_bin)\\n #err_model = sim_err_flat_bin*scaling\\n\\terr_model = sim_err_flat_bin*scaling\\n err_data = np.sqrt(((err_src)**2) + ((err_bkgd)**2)*(t_src/t_total)**2)\\n\\t\\n\\tchi_sq_new = (((model-data)**2)/((err_model)**2 + (err_data)**2)).sum()\\n # PLotting the comparison plots\\n fig = plt.figure()\\n plt.title(\\\"Comparison between simulated(scaled) and real data for \\\"+grbdir+ \\\"\\\\n\\\" + r\\\"$\\\\theta_x$={tx:0.1f} and $\\\\theta_y$={ty:0.1f} $\\\\chi^2$={c:0.1f} \\\".format(tx=thetax,ty=thetay,c=chi_sq_new))\\n plt.errorbar(np.arange(0,(len(data))),data,yerr=err_data,fmt='.',markersize=2,label=\\\"Data\\\",elinewidth=0.5)\\n plt.errorbar(np.arange(0,(len(model))),model,yerr=err_model,fmt='.',markersize=2,label=\\\"Simulation (scaling = {s:0.2f}, offset = {o:0.2f})\\\".format(s=scaling,o=intercept),elinewidth=0.5)\\n plt.ylabel('Counts')\\n\\tplt.xlabel('Random Bins')\\n\\tplt.xticks(np.arange(0,(len(data)),1))\\n\\tplt.legend()\\n pdf_file.savefig(fig) #saves the current figure into a pdf_file page\\n\\n\\n\\t# Plotting observed vs predicted counts--------------------------------------------------------\\n\\n\\tfig = plt.figure()\\n plt.title(grbdir + r\\\" : Observed vs Predicted counts with $\\\\chi^2$ = {cs:0.1f}\\\".format(cs=chi_sq))\\n plt.errorbar(model_copy,data_copy,xerr=err_model_copy,yerr=err_data_copy,fmt='g.',markersize=2,elinewidth=0.5)\\n\\tfor i in range(len(model_copy)):\\t\\n\\t\\tplt.text(model_copy[i],data_copy[i],Mod_names[i],fontsize=5)\\n #plt.plot(np.arange(-1000,1000),fit_line(np.arange(-1000,1000),scaling),'k',linewidth=0.5,label='m = {s:0.2f}'.format(s=scaling))\\n\\tplt.plot(np.arange(-1000,1000),fit_line_int(np.arange(-1000,1000),scaling,intercept),'k',linewidth=0.5,label='scaling = {s:0.2f}, offset = {i:0.2f}'.format(s=scaling,i=intercept))\\n\\tplt.plot(np.arange(min(model_copy)-5,max(model_copy)+5),np.ones(len(np.arange(min(model_copy)-5,max(model_copy)+5)))*intercept,'r-',label='intercept',linewidth=0.5)\\n plt.xlim(min(model_copy)-5,max(model_copy)+5)\\n plt.ylim(min(data_copy)-5,max(data_copy)+5)\\n plt.xlabel('Predicted Counts')\\n plt.ylabel('Observed Counts')\\n\\tplt.legend()\\n\\tplt.grid()\\n pdf_file.savefig(fig)\\n\\t\\t\\n\\tprint \\\"===============================================================================================\\\"\\n\\t\\n\\treturn\",\n \"def data_model_residual(surface, dem, unw, incidence):\\n los,fem_los,residual = pu.los2pylith(surface,dem,unw,incidence)\\n\\n # Using image_grid\\n fig = plt.figure()\\n grid = ImageGrid(fig, 111, # similar to subplot(111)\\n nrows_ncols = (1, 3),\\n direction=\\\"row\\\",\\n axes_pad = 0.05,\\n add_all=True,\\n label_mode = \\\"1\\\",\\n share_all = True,\\n cbar_location=\\\"top\\\",\\n cbar_mode=\\\"each\\\", #\\\"single\\\"\\n cbar_size=\\\"5%\\\",\\n cbar_pad=0.05,\\n )\\n #grid[0].set_xlabel(\\\"X\\\")\\n #grid[0].set_ylabel(\\\"Y\\\")\\n #grid2[0].set_xticks([-2, 0])\\n #grid2[0].set_yticks([-2, 0, 2])\\n\\n #NOTE: could find global min/max from three arrays here\\n norm = Normalize(vmin=np.nanmin(los), vmax=np.nanmax(los))\\n #for ax,data in zip(grid,[los,fem_los,residual]):\\n im = grid[0].imshow(los,origin='upper',norm=norm,cmap=plt.cm.jet)\\n grid[0].axhline(100,color='m') #show profile\\n cax = grid.cbar_axes[0]\\n cax.colorbar(im)\\n grid[1].axhline(100,color='k') #show profile\\n im1 = grid[1].imshow(fem_los,origin='upper',norm=norm,cmap=plt.cm.jet)\\n\\n cax = grid.cbar_axes[1]\\n cax.colorbar(im1)\\n\\n im2 = grid[2].imshow(residual,origin='upper',cmap=plt.cm.jet)\\n cax = grid.cbar_axes[2]\\n cax.colorbar(im2)\\n\\n # Add letter labels\\n for ax, label in zip(grid,['A', 'B', 'C']):\\n ax.text(0.05, 0.95, label, transform=ax.transAxes,\\n fontsize=16, fontweight='bold', va='top')\\n\\n # Annotate\\n # NOTE: way too high!\\n #plt.suptitle('FEM Results')\\n\\n # Add profile\\n # NOTE: for now EW, but would be easy to do arbitrary line, and convert to km\\n fig = plt.figure()\\n #x = arange(los.shape[0])\\n plt.axhline(color='k',ls='--')\\n plt.plot(los[100],'m.',label='data')\\n plt.plot(fem_los[100],'k-',lw=2,label='model')\\n plt.xlabel('Distance [km]')\\n plt.ylabel('Distance [km]')\\n plt.legend(loc='upper left')\\n\\n plt.show()\",\n \"def _plot_comparison(xs, pan, other_program_name, **kw):\\n\\n pans = ['Bmax', 'Emax']\\n units = ['(mG)', '(kV/m)']\\n title_app = [', Max Magnetic Field', ', Max Electric Field']\\n save_suf = ['-%s-comparison-Bmax' % other_program_name,\\n '-%s-comparison-Emax' % other_program_name]\\n\\n for p,u,t,s in zip(pans, units, title_app, save_suf):\\n #figure object and axes\\n fig = plt.figure()\\n ax_abs = fig.add_subplot(2,1,1)\\n ax_per = ax_abs.twinx()\\n ax_mag = fig.add_subplot(2,1,2)\\n #Bmax\\n #init handles and labels lists for legend\\n kw['H'], kw['L'] = [], []\\n _plot_comparison_repeatables(ax_abs, ax_per, ax_mag, pan, p, u,\\n other_program_name, **kw)\\n _plot_wires(ax_mag, xs.hot, xs.gnd, pan['emf.fields-results'][p], **kw)\\n _check_und_conds([xs], [ax_mag], **kw)\\n ax_abs.set_title('Absolute and Percent Difference' + t)\\n ax_mag.set_ylabel(p + ' ' + u)\\n ax_mag.set_title('Model Results' + t)\\n ax_mag.legend(kw['H'], kw['L'], **_leg_kw)\\n _color_twin_axes(ax_abs, mpl.rcParams['axes.labelcolor'], ax_per, 'firebrick')\\n _format_line_axes_legends(ax_abs, ax_per, ax_mag)\\n #_format_twin_axes(ax_abs, ax_per)\\n _save_fig(xs.sheet + s, fig, **kw)\",\n \"def analyse_plots(plot_dict, data_dict) :\\n for component in [ '_x', '_y' ] :\\n z_pos = array.array( 'd' )\\n trans_pos = array.array( 'd' )\\n errors = array.array( 'd' )\\n zeros = array.array( 'd' )\\n\\n plot = plot_dict['beam_positions'+component]\\n\\n for i in range( plot.GetXaxis().GetNbins()+2 ) :\\n projection = plot.ProjectionY( \\\\\\n 'profile'+component+'_pro_'+str(i), i, i )\\n if projection.GetEntries() == 0 :\\n continue\\n\\n pro_mean, pro_mean_err, pro_std, pro_std_err = \\\\\\n scifi.fit_gaussian( projection )\\n\\n errors.append( pro_mean_err )\\n trans_pos.append( pro_mean )\\n z_pos.append( data_dict['station_positions'][ i-6 ] )\\n zeros.append(0.0)\\n\\n position_graph = ROOT.TGraphErrors( len(zeros), z_pos, trans_pos, \\\\\\n zeros, errors )\\n position_graph.SetName('beam_profile'+component)\\n plot_dict['beam_profile'+component] = position_graph\\n\\n profile_x = plot_dict['beam_profile_x']\\n profile_y = plot_dict['beam_profile_y']\\n\\n up_x_func = ROOT.TF1( \\\"up_fit_x\\\", \\\"pol1\\\", -5000.0, 0.0 )\\n up_y_func = ROOT.TF1( \\\"up_fit_y\\\", \\\"pol1\\\", -5000.0, 0.0 )\\n down_x_func = ROOT.TF1( \\\"down_fit_x\\\", \\\"pol1\\\", 0.0, 5000.0 )\\n down_y_func = ROOT.TF1( \\\"down_fit_y\\\", \\\"pol1\\\", 0.0, 5000.0 )\\n\\n up_fit_x = profile_x.Fit( 'up_fit_x', \\\"QSR\\\" )\\n up_fit_y = profile_y.Fit( 'up_fit_y', \\\"QSR\\\" )\\n down_fit_x = profile_x.Fit( 'down_fit_x', \\\"QSR\\\" )\\n down_fit_y = profile_y.Fit( 'down_fit_y', \\\"QSR\\\" )\\n\\n plot_dict['beam_profile_x_up_fit'] = up_x_func\\n plot_dict['beam_profile_y_up_fit'] = up_y_func\\n plot_dict['beam_profile_x_down_fit'] = down_x_func\\n plot_dict['beam_profile_y_down_fit'] = down_y_func\\n\\n\\n up_beam_gra_x = up_x_func.GetParameter(1)\\n up_beam_gra_x_err = up_x_func.GetParError(1)\\n up_beam_gra_y = up_y_func.GetParameter(1)\\n up_beam_gra_y_err = up_y_func.GetParError(1)\\n\\n up_beam_pos_x = data_dict['station_positions'][-1]*up_beam_gra_x + up_x_func.GetParameter(0)\\n up_beam_pos_x_err = up_x_func.GetParError(0)\\n up_beam_pos_y = data_dict['station_positions'][-1]*up_beam_gra_y + up_y_func.GetParameter(0)\\n up_beam_pos_y_err = up_y_func.GetParError(0)\\n\\n up_beam_rot_x = math.atan( up_beam_gra_x )\\n up_beam_rot_x_err = up_beam_gra_x_err # Approx linear\\n up_beam_rot_y = math.atan( up_beam_gra_y )\\n up_beam_rot_y_err = up_beam_gra_y_err # Approx linear\\n\\n\\n\\n down_beam_gra_x = down_x_func.GetParameter(1)\\n down_beam_gra_x_err = down_x_func.GetParError(1)\\n down_beam_gra_y = down_y_func.GetParameter(1)\\n down_beam_gra_y_err = down_y_func.GetParError(1)\\n\\n down_beam_pos_x = data_dict['station_positions'][1]*down_beam_gra_x + down_x_func.GetParameter(0)\\n down_beam_pos_x_err = down_x_func.GetParError(0)\\n down_beam_pos_y = data_dict['station_positions'][1]*down_beam_gra_y + down_y_func.GetParameter(0)\\n down_beam_pos_y_err = down_y_func.GetParError(0)\\n\\n down_beam_rot_x = math.atan( down_beam_gra_x )\\n down_beam_rot_x_err = down_beam_gra_x_err # Approx linear\\n down_beam_rot_y = math.atan( down_beam_gra_y )\\n down_beam_rot_y_err = down_beam_gra_y_err # Approx linear\\n\\n\\n# down_pos_x = down_beam_pos_x - data_dict['station_positions'][1]*up_beam_gra_x + up_x_func.GetParameter(0)\\n# down_pos_x_err = math.sqrt( up_x_func.GetParError(0)**2 + down_beam_pos_x_err**2 )\\n# down_pos_y = down_beam_pos_y - data_dict['station_positions'][1]*up_beam_gra_y + up_y_func.GetParameter(0)\\n# down_pos_y_err = math.sqrt( up_y_func.GetParError(0)**2 + down_beam_pos_y_err**2 )\\n\\n length = TRACKER_SEPARATION\\n down_pos_x = down_beam_pos_x - ( up_beam_pos_x + length*up_beam_gra_x )\\n down_pos_x_err = math.sqrt( up_beam_pos_x_err**2 + down_beam_pos_x_err**2 + (length*up_beam_gra_x_err)**2 )\\n down_pos_y = down_beam_pos_y - ( up_beam_pos_y + length*up_beam_gra_y )\\n down_pos_y_err = math.sqrt( up_beam_pos_y_err**2 + down_beam_pos_y_err**2 + (length*up_beam_gra_y_err)**2 )\\n\\n down_rot_x = down_beam_rot_x - up_beam_rot_x\\n down_rot_x_err = math.sqrt( down_beam_rot_x_err**2 + up_beam_rot_x_err**2 )\\n down_rot_y = down_beam_rot_y - up_beam_rot_y\\n down_rot_y_err = math.sqrt( down_beam_rot_y_err**2 + up_beam_rot_y_err**2 )\\n\\n\\n print\\n print \\\"Incoming Beam Misalignments:\\\"\\n print\\n print \\\"Displacement and rotation of beam with respect to upstream tracker:\\\"\\n print\\n print \\\"X Position = {0:0.3f} +/- {1:0.3f} mm\\\".format( up_beam_pos_x, up_beam_pos_x_err )\\n print \\\"Y Position = {0:0.3f} +/- {1:0.3f} mm\\\".format( up_beam_pos_y, up_beam_pos_y_err )\\n print\\n print \\\"X Rotation = {0:0.3f} +/- {1:0.3f} mrad\\\".format( up_beam_rot_x*1000.0, up_beam_rot_x_err*1000.0 )\\n print \\\"Y Rotation = {0:0.3f} +/- {1:0.3f} mrad\\\".format( up_beam_rot_y*1000.0, up_beam_rot_y_err*1000.0 )\\n print\\n\\n print\\n print \\\"Downstream Tracker Beam Misalignments:\\\"\\n print\\n print \\\"Displacement and rotation of beam with respect to downstream tracker:\\\"\\n print\\n print \\\"X Position = {0:0.3f} +/- {1:0.3f} mm\\\".format( down_beam_pos_x, down_beam_pos_x_err )\\n print \\\"Y Position = {0:0.3f} +/- {1:0.3f} mm\\\".format( down_beam_pos_y, down_beam_pos_y_err )\\n print\\n print \\\"X Rotation = {0:0.3f} +/- {1:0.3f} mrad\\\".format( down_beam_rot_x*1000.0, down_beam_rot_x_err*1000.0 )\\n print \\\"Y Rotation = {0:0.3f} +/- {1:0.3f} mrad\\\".format( down_beam_rot_y*1000.0, down_beam_rot_y_err*1000.0 )\\n print\\n\\n print\\n print \\\"Downstream Tracker Alignment:\\\"\\n print\\n print \\\"Displacement and rotation of between the two trackers:\\\"\\n print\\n print \\\"X Position = {0:0.3f} +/- {1:0.3f} mm\\\".format( down_pos_x, down_pos_x_err )\\n print \\\"Y Position = {0:0.3f} +/- {1:0.3f} mm\\\".format( down_pos_y, down_pos_y_err )\\n print\\n print \\\"X Rotation = {0:0.3f} +/- {1:0.3f} mrad\\\".format( down_rot_x*1000.0, down_rot_x_err*1000.0 )\\n print \\\"Y Rotation = {0:0.3f} +/- {1:0.3f} mrad\\\".format( down_rot_y*1000.0, down_rot_y_err*1000.0 )\\n print\",\n \"def plotEvaluation(results,nbr_file : int,path : str, labels = [\\\"\\\"],target_name = \\\"\\\"):\\n fig,ax = plt.subplots(1,1)\\n ax.set_yscale(\\\"log\\\")\\n for res in range(len(results)):\\n data = [np.array(p[1]) for p in results[res]]\\n number_of_simulation = len(data)\\n\\n average_values = np.zeros(len(data[0]))\\n for d in data:\\n average_values =average_values + d\\n average_values = np.array(average_values) / number_of_simulation\\n \\n error_values = [0 for i in range(len(average_values))]\\n for j in range(len(error_values)):\\n if j%int(len(error_values)/50)==0 :\\n for i in range(len(data)):\\n error_values[j] += (data[i][j] - average_values[j])**2\\n error_values[j] = np.sqrt(error_values[j]/number_of_simulation)\\n opt = 0\\n tfile = ''\\n if path == 'data/B/b':\\n opt = B_opts[nbr_file-1]\\n tfile = 'b'\\n else:\\n opt = C_opts[nbr_file-1]\\n tfile = 'c'\\n \\n \\n ax.errorbar(range(len(average_values)),average_values,yerr = error_values, ecolor = \\\"black\\\", linewidth = 1, elinewidth = 1, label = labels[res])\\n \\n \\n #ax.ylim((opt-5,max(opt*2,average_values[-1]+10)))\\n plt.title(f'{target_name} : The evolution of the best evaluation (in average) \\\\nfor graph {tfile}{nbr_file}.stp for {number_of_simulation} simulations')\\n plt.xlabel(\\\"steps\\\")\\n plt.ylabel(\\\"evaluation\\\")\\n ax.legend()\\n ax.axhline(opt, color='red', label = \\\"Optimal solution\\\")\\n plt.savefig(f'best_{tfile}{nbr_file}_evaluation_{target_name}.png')\\n plt.show()\",\n \"def param_evol(sample_results, showpars=None, start=0, **plot_kwargs):\\n import matplotlib.pyplot as pl\\n\\n chain = sample_results['chain'][:, start:, :]\\n lnprob = sample_results['lnprobability'][:, start:]\\n nwalk = chain.shape[0]\\n try:\\n parnames = np.array(sample_results['theta_labels'])\\n except(KeyError):\\n parnames = np.array(sample_results['model'].theta_labels())\\n\\n # Restrict to desired parameters\\n if showpars is not None:\\n ind_show = np.array([p in showpars for p in parnames], dtype=bool)\\n parnames = parnames[ind_show]\\n chain = chain[:, :, ind_show]\\n\\n # Set up plot windows\\n ndim = len(parnames) + 1\\n nx = int(np.floor(np.sqrt(ndim)))\\n ny = int(np.ceil(ndim * 1.0 / nx))\\n sz = np.array([nx, ny])\\n factor = 3.0 # size of one side of one panel\\n lbdim = 0.2 * factor # size of left/bottom margin\\n trdim = 0.2 * factor # size of top/right margin\\n whspace = 0.05 * factor # w/hspace size\\n plotdim = factor * sz + factor * (sz - 1) * whspace\\n dim = lbdim + plotdim + trdim\\n\\n fig, axes = pl.subplots(nx, ny, figsize=(dim[1], dim[0]))\\n lb = lbdim / dim\\n tr = (lbdim + plotdim) / dim\\n fig.subplots_adjust(left=lb[1], bottom=lb[0], right=tr[1], top=tr[0],\\n wspace=whspace, hspace=whspace)\\n\\n # Sequentially plot the chains in each parameter\\n for i in range(ndim - 1):\\n ax = axes.flatten()[i]\\n for j in range(nwalk):\\n ax.plot(chain[j, :, i], **plot_kwargs)\\n ax.set_title(parnames[i])\\n # Plot lnprob\\n ax = axes.flatten()[-1]\\n for j in range(nwalk):\\n ax.plot(lnprob[j, :])\\n ax.set_title('lnP')\\n return fig\",\n \"def display1(*args):\\n #----------*----------* # unpack\\n twiss_func = args[0]\\n lat_plot = args[3]\\n #-------------------- beta x,y & dispersion x\\n s = [twiss_func(i,'s') for i in range(twiss_func.nbpoints)]\\n bx = [twiss_func(i,'bx') for i in range(twiss_func.nbpoints)]\\n by = [twiss_func(i,'by') for i in range(twiss_func.nbpoints)]\\n dx = [twiss_func(i,'dx') for i in range(twiss_func.nbpoints)]\\n #-------------------- lattice viseo\\n vzero = [0. for i in range(lat_plot.nbpoints)] # zero line\\n vis_abszisse = [lat_plot(i,'s') for i in range(lat_plot.nbpoints)]\\n vis_ordinate = [lat_plot(i,'viseo') for i in range(lat_plot.nbpoints)]\\n #-------------------- figure frame\\n width=14; height=7.6\\n plt.figure(num=0,figsize=(width,height),facecolor='#eaecef',tight_layout=False)\\n\\n #-------------------- transverse X\\n splot111=plt.subplot(111)\\n splot111.set_title('beta functions')\\n plt.plot(s,bx, label=r'$\\\\beta_x$ [m]', color='red', linestyle='-') # beta x\\n plt.plot(s,by, label=r'$\\\\beta_y$ [m]', color='blue', linestyle='-') # beta y\\n plt.plot(s,dx, label=r'$\\\\eta_x$ [m]' , color='green',linestyle='-') # dispersion x\\n vscale=splot111.axis()[3]*0.25\\n viseoz = [x*vscale for x in vis_ordinate]\\n plt.plot(vis_abszisse,viseoz,label='',color='black')\\n plt.plot(vis_abszisse,vzero,color='black')\\n plt.legend(loc='lower right',fontsize='x-small')\",\n \"def ResBeam_Stats_plot(n, header_bmaj, header_bmin): \\n\\n file_dir = 'SpectralCube_BeamLogs'\\n basename = '/beamlog.image.restored.' + imagebase + field\\n\\n # use different basename for the Milky Way range\\n if not glob.glob(file_dir + basename +'*.txt'):\\n basename = '/beamlog.image.restored.' + imagebase + 'MilkyWay.' + field\\n\\n \\n BEAM_THRESHOLD = []\\n \\n title1 = 'Restoring beam bmaj standard deviation [arcsec]'\\n plt_name1 = 'BmajStdev.png'\\n saved_fig1 = fig_dir+'/'+plt_name1\\n\\n title2 = 'Restoring beam bmin standard deviation [arcsec]'\\n plt_name2 = 'BminStdev.png'\\n saved_fig2 = fig_dir+'/'+plt_name2\\n\\n title3 = 'Maximum ratio of beam area'\\n plt_name3 = 'max_ratioBA.png'\\n saved_fig3 = fig_dir+'/'+plt_name3\\n\\n title4 = 'Minimum ratio of beam area' \\n plt_name4 = 'min_ratioBA.png'\\n saved_fig4 = fig_dir+'/'+plt_name4\\n \\n params = {'axes.labelsize': 10,\\n 'axes.titlesize': 10,\\n 'font.size':10}\\n\\n pylab.rcParams.update(params)\\n\\n beamXPOS, beamYPOS = BeamPosition()\\n fig1, ax1 = plt.subplots()\\n fig2, ax2 = plt.subplots()\\n fig3, ax3 = plt.subplots()\\n fig4, ax4 = plt.subplots()\\n \\n for i in range(0,36):\\n bnum = n[i]\\n infile = file_dir + basename +'.beam%02d.txt'%(bnum)\\n bmaj_stdev, bmin_stdev, beam_threshold, max_ratio_BA, min_ratio_BA = cal_ResBeam_Stats(infile, header_bmaj, header_bmin)\\n BEAM_THRESHOLD.append(beam_threshold)\\n\\n ax1.scatter([beamXPOS[i]], [beamYPOS[i]], s=1400, edgecolors='black', facecolors='none')\\n ax1.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\\n ax1.text(beamXPOS[i], beamYPOS[i]-0.02, round(bmaj_stdev, 3), va='center', ha='center', fontsize=8, color='blue')\\n\\n ax2.scatter([beamXPOS[i]], [beamYPOS[i]], s=1400, edgecolors='black', facecolors='none')\\n ax2.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\\n ax2.text(beamXPOS[i], beamYPOS[i]-0.02, round(bmin_stdev,3), va='center', ha='center', fontsize=8, color='blue')\\n\\n maxplot = ax3.scatter([beamXPOS[i]], [beamYPOS[i]], s=1300, c=[max_ratio_BA], cmap='summer', edgecolors='black', vmin=0, vmax=1.1)\\n ax3.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\\n ax3.text(beamXPOS[i], beamYPOS[i]-0.02, round(max_ratio_BA,3), va='center', ha='center', fontsize=8, color='blue')\\n \\n minplot = ax4.scatter([beamXPOS[i]], [beamYPOS[i]], s=1300, c=[min_ratio_BA], cmap='summer', edgecolors='black', vmin=0, vmax=1.1)\\n ax4.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\\n ax4.text(beamXPOS[i], beamYPOS[i]-0.02, round(min_ratio_BA,3), va='center', ha='center', fontsize=8, color='blue')\\n \\n ax1.set_xlim(0,0.7)\\n ax1.set_ylim(0,1.4)\\n ax1.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\\n ax1.set_title(title1)\\n\\n ax2.set_xlim(0,0.7)\\n ax2.set_ylim(0,1.4)\\n ax2.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\\n ax2.set_title(title2)\\n\\n ax3.set_xlim(0,0.7)\\n ax3.set_ylim(0,1.4)\\n ax3.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\\n ax3.set_title(title3)\\n plt.colorbar(maxplot, ax=ax3)\\n\\n ax4.set_xlim(0,0.7)\\n ax4.set_ylim(0,1.4)\\n ax4.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\\n ax4.set_title(title4)\\n plt.colorbar(minplot, ax=ax4)\\n\\n fig1.savefig(saved_fig1, bbox_inches='tight')\\n fig2.savefig(saved_fig2, bbox_inches='tight')\\n fig3.savefig(saved_fig3, bbox_inches='tight')\\n fig4.savefig(saved_fig4, bbox_inches='tight')\\n\\n plt.close('all')\\n\\n return saved_fig1, saved_fig2, plt_name1, plt_name2, saved_fig3, saved_fig4, plt_name3, plt_name4, BEAM_THRESHOLD\",\n \"def plot_optimal_uncertainty_reduction(results_for_exp, results_for_exp_inftau):\\n plt.ylim(0, 1)\\n\\n plot_param_per_l4_and_l2(\\n sp.mean(sp.amax(results_for_exp, axis=2), axis=2),\\n sp.std(sp.amax(results_for_exp, axis=2), axis=2))\\n plot_param_per_l4_and_l2(sp.mean(results_for_exp_inftau, axis=2), c='g')\",\n \"def main(result_dir, figure_dir, *, n_samples=1000):\\n\\n # define input and output directories\\n result_path = Path(result_dir)\\n figure_path = Path(figure_dir)\\n figure_path.mkdir(parents=True, exist_ok=True)\\n\\n # load model parameters\\n model_params = np.load(result_path / 'model_params_best.npz')\\n\\n # plot posterior distributions\\n keys = [k for k in sorted(model_params) if k.startswith('FVGP/kern')]\\n for key in keys:\\n params = model_params[key]\\n\\n if not key.endswith('W'):\\n continue\\n\\n loc, scale = params[0], np.exp(params[1])\\n figname = key.replace('/', '_')\\n\\n # retrieve corresponding precision parameter\\n gamma_key = key.replace('FVGP', 'PartialSVGP') + '/precision'\\n gamma_loc = model_params[gamma_key][0, 0, :]\\n gamma_scale = np.exp(model_params[gamma_key][1, 0, :])\\n\\n # sort by increasing (log)-precision\\n idx = np.argsort(gamma_loc)\\n gamma_loc, gamma_scale = gamma_loc[idx], gamma_scale[idx]\\n loc, scale = loc[:, idx], scale[:, idx]\\n\\n # flip to make bigger deviation positive\\n flip_mask = loc.mean(0) < 0\\n loc[:, flip_mask] = -loc[:, flip_mask]\\n\\n # plot posterior distributions\\n gamma_figname = key.replace('/', '_') + '_precision.png'\\n fig = plot_gamma_posterior(gamma_loc, gamma_scale, n_samples)\\n fig.savefig(str(figure_path / gamma_figname))\\n\\n fig = plot_W_posterior(loc, scale)\\n\\n fig.savefig(str(figure_path / figname))\",\n \"def compare_parameter_plots(result_file, result_file_eccentric, fitted_params, resultType, planet,\\n plotPublished = False, publishedDataFile = None, saveplot=True, foldext=''):\\n\\n # Check if we are wanting to compare the eccentric and circular resutls.\\n\\n inputData_circular = np.genfromtxt(result_file, dtype=None, delimiter=', ', comments='#', encoding = None)\\n inputData_eccentric = np.genfromtxt(result_file_eccentric, dtype=None, delimiter=', ', comments='#', encoding = None)\\n\\n inputData = [inputData_circular, inputData_eccentric]\\n\\n # Find out the indices of the type of average and the error\\n if 't0' in str(inputData[0][0]):\\n values = [s for i, s in enumerate(inputData[0][0]) if 't0' in s]\\n indices = [i for i, s in enumerate(inputData[0][0]) if 't0' in s]\\n Nvalues = len(indices)\\n Nbefore = indices[0]\\n\\n if resultType == 'Mean':\\n k = values.index('t0_mu') + Nbefore\\n e = values.index('t0_std') + Nbefore\\n\\n elif resultType == 'Median':\\n k = values.index('t0_med') + Nbefore\\n e = values.index('t0_poserr') + Nbefore\\n\\n elif resultType == 'LSQ':\\n k = values.index('t0_lqs') + Nbefore\\n e = values.index('t0_std') + Nbefore\\n\\n else:\\n raise ValueError(\\\"Result type not recognised, please chose Mean, Median or LSQ.\\\")\\n\\n elif 't_secondary' in str(inputData[0]):\\n values = [s for i, s in enumerate(inputData[0]) if 't_secondary' in s]\\n indices = [i for i, s in enumerate(inputData[0]) if 't_secondary' in s]\\n Nvalues = len(indices)\\n Nbefore = indices[0]\\n\\n if resultType == 'Mean':\\n k = values.index('t_secondary_mu') + Nbefore\\n e = values.index('t_secondary_std') + Nbefore\\n\\n elif resultType == 'Median':\\n k = values.index('t_secondary_med') + Nbefore\\n e = values.index('t_secondary_poserr') + Nbefore\\n\\n elif resultType == 'LSQ':\\n k = values.index('t_secondary_lqs') + Nbefore\\n e = values.index('t_secondary_std') + Nbefore\\n\\n else:\\n raise ValueError(\\\"Result type not recognised, please chose Mean, Median or LSQ.\\\")\\n\\n else:\\n raise ValueError(\\\"Not implemented indices selection if we have not fit for t0\\\")\\n\\n # If we have some published values, create a table of the Nsigma difference\\n if plotPublished:\\n print \\\"\\\\nOpening file for writing nsigma from published...\\\"\\n f = open(\\\"{3}/PhD/SpitzerTransits/{0}{1}/{0}_NsigmaFEccentricCircular.txt\\\".format(planet, foldext), 'w')\\n print >> f, (\\\"Param\\\\tAOR\\\\tChannel\\\\tMethod\\\\tCirc_val\\\\tCirc_err\\\\tEcc_val\\\\tEcc_err\\\\tSigma\\\\tNsigdiff\\\")\\n print >> f, (\\\"==============================================================================================\\\")\\n\\n for p in range(len(fitted_params)):\\n\\n # Figure out which parameter we are looking at\\n param = fitted_params[p]\\n\\n # Initialise plotting the parameters\\n fig = plt.figure(figsize=(8,5))\\n ax1 = fig.add_axes([0.1, 0.1, 0.4, 0.8])\\n ax2 = fig.add_axes([0.5, 0.1, 0.4, 0.8])\\n ax1.set_title(r'Ch1 ($3.6\\\\mu m$)')\\n ax2.set_title(r'Ch2 ($4.5\\\\mu m$)')\\n ax1.set_ylabel(param)\\n\\n markers = ['o', '*']\\n offset = [0,0.01]\\n lab = [' cir',' ecc']\\n\\n # create lists to save the parameters to so that we can compare the circular and elliptical results\\n ch1polyMean_list, ch1PLDMean_list, ch1polyStds_list, ch1PLDStds_list = [],[],[],[]\\n ch2polyMean_list, ch2PLDMean_list, ch2polyStds_list, ch2PLDStds_list = [],[],[],[]\\n\\n for c in range(len(inputData)):\\n\\n # Get the AOR labels for poly and PLD and check that they are the same for channel 1\\n ch1polyAORs = [line[0] for line in inputData[c] if 'ch1' in line and 'poly' in line]\\n ch1PLDAORs = [line[0] for line in inputData[c] if 'ch1' in line and 'PLD' in line]\\n\\n if ch1polyAORs != ch1PLDAORs:\\n warnings.warn(\\\"The PLD and poly AORs for channel 1 are not the same, plotted labels might be wrong!\\\")\\n\\n # Get the Mean and stddev of poly and PLD for the parameter that we are looking at for channel 1\\n ch1polyMean = [float(line[k+p*Nvalues]) for line in inputData[c] if 'ch1' in line and 'poly' in line]\\n ch1PLDMean = [float(line[k+p*Nvalues]) for line in inputData[c] if 'ch1' in line and 'PLD' in line]\\n if resultType == 'Mean' or resultType == 'LSQ':\\n ch1polyStds = np.array([float(line[e+p*Nvalues]) for line in inputData[c] if 'ch1' in line and 'poly' in line])\\n ch1PLDStds = np.array([float(line[e+p*Nvalues]) for line in inputData[c] if 'ch1' in line and 'PLD' in line])\\n elif resultType == 'Median':\\n # asymetric errors\\n ch1polyStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData[c] if 'ch1' in line and 'poly' in line]).T\\n ch1PLDStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData[c] if 'ch1' in line and 'PLD' in line]).T\\n\\n ch1polyMean_list.append(ch1polyMean)\\n ch1PLDMean_list.append(ch1PLDMean)\\n ch1polyStds_list.append(ch1polyStds)\\n ch1PLDStds_list.append(ch1PLDStds)\\n\\n\\n # Get the AOR labels for poly and PLD and check that they are the same for channel 2\\n ch2polyAORs = [line[0] for line in inputData[c] if 'ch2' in line and 'poly' in line]\\n ch2PLDAORs = [line[0] for line in inputData[c] if 'ch2' in line and 'PLD' in line]\\n\\n if ch2polyAORs != ch2PLDAORs:\\n warnings.warn(\\\"The PLD and poly AORs for channel 2 are not the same, plotted labels might be wrong!\\\")\\n\\n # Get the Mean and stddev of poly and PLD for the parameter that we are looking at for channel 2\\n ch2polyMean = [float(line[k+p*Nvalues]) for line in inputData[c] if 'ch2' in line and 'poly' in line]\\n ch2PLDMean = [float(line[k+p*Nvalues]) for line in inputData[c] if 'ch2' in line and 'PLD' in line]\\n if resultType == 'Mean' or resultType == 'LSQ':\\n ch2polyStds = np.array([float(line[e+p*Nvalues]) for line in inputData[c] if 'ch2' in line and 'poly' in line])\\n ch2PLDStds = np.array([float(line[e+p*Nvalues]) for line in inputData[c] if 'ch2' in line and 'PLD' in line])\\n elif resultType == 'Median':\\n # asymmetric errors\\n ch2polyStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData[c] if 'ch2' in line and 'poly' in line]).T\\n ch2PLDStds = np.array([[float(line[e+1+p*Nvalues]),float(line[e+p*Nvalues])] for line in inputData[c] if 'ch2' in line and 'PLD' in line]).T\\n\\n ch2polyMean_list.append(ch2polyMean)\\n ch2PLDMean_list.append(ch2PLDMean)\\n ch2polyStds_list.append(ch2polyStds)\\n ch2PLDStds_list.append(ch2PLDStds)\\n\\n # Calculate the weighted means...\\n WMch1poly, TSch1poly = weightedMean(np.array(ch1polyMean), np.array(ch1polyStds))\\n WMch1PLD, TSch1PLD = weightedMean(np.array(ch1PLDMean), np.array(ch1PLDStds))\\n WMch2poly, TSch2poly = weightedMean(np.array(ch2polyMean), np.array(ch2polyStds))\\n WMch2PLD, TSch2PLD = weightedMean(np.array(ch2PLDMean), np.array(ch2PLDStds))\\n\\n # Channel 1\\n # polynomial\\n ax1.errorbar(np.array(range(len(ch1polyMean)))-0.05+offset[c], ch1polyMean, yerr = ch1polyStds, marker = markers[c], linestyle='', color ='b', label = 'Poly' + lab[c])\\n # PLD\\n ax1.errorbar(np.array(range(len(ch1PLDMean)))+0.05+offset[c], ch1PLDMean, yerr = ch1PLDStds, marker = markers[c], linestyle='', color = 'r', label = 'PLD' + lab[c])\\n # labels\\n ax1.set_xticks(range(len(ch1PLDMean)))\\n ax1.set_xticklabels(ch1polyAORs, rotation='vertical')\\n\\n\\n # Channel2\\n # polynomial\\n ax2.errorbar(np.array(range(len(ch2polyMean )))-0.05+offset[c], ch2polyMean, yerr = ch2polyStds, marker = markers[c], linestyle='', color ='b')\\n # PLD\\n ax2.errorbar(np.array(range(len(ch2PLDMean )))+0.05+offset[c], ch2PLDMean, yerr = ch2PLDStds, marker = markers[c], linestyle='', color = 'r')\\n # labmarkers[c]\\n ax2.set_xticks(range(len(ch2PLDMean)))\\n ax2.set_xticklabels(ch2polyAORs, rotation='vertical')\\n\\n # Plot the weighted means\\n if len(ch1polyMean) > 1.:\\n ax1.axhline(WMch1poly, color = 'b')\\n ax1.axhspan(WMch1poly - TSch1poly,\\n WMch1poly + TSch1poly,\\n alpha = 0.3, color='b',label='Weighted Mean')\\n ax1.axhline(WMch1PLD, color = 'r')\\n ax1.axhspan(WMch1PLD - TSch1PLD,\\n WMch1PLD + TSch1PLD,\\n alpha = 0.3, color='r',label='Weighted Mean')\\n\\n ax2.axhline(WMch2poly, color = 'b')\\n ax2.axhspan(WMch2poly - TSch2poly,\\n WMch2poly + TSch2poly,\\n alpha = 0.3, color='b')\\n ax2.axhline(WMch2PLD, color = 'r')\\n ax2.axhspan(WMch2PLD - TSch2PLD,\\n WMch2PLD + TSch2PLD,\\n alpha = 0.3, color='r')\\n\\n\\n if plotPublished:\\n # Plot the published values if they they are given\\n # and calculate Nsigma from published and save to a file\\n data = np.genfromtxt(publishedDataFile, dtype=None, delimiter=', ', encoding = None)\\n\\n if param in data.T[0].tolist():\\n\\n pIdx = data.T[0].tolist().index(param)\\n ax1.axhline(float(data[pIdx][1]), color = 'k', linestyle = 'dashed')\\n ax1.axhspan(float(data[pIdx][1]) - float(data[pIdx][2]),\\n float(data[pIdx][1]) + float(data[pIdx][2]),\\n alpha = 0.3, color='k',label='Literature')\\n\\n ax2.axhline(float(data[pIdx][3]),color = 'k', linestyle = 'dashed')\\n ax2.axhspan(float(data[pIdx][3]) - float(data[pIdx][4]),\\n float(data[pIdx][3]) + float(data[pIdx][4]),\\n alpha = 0.3, color='k',label='Literature')\\n\\n\\n # Save the number of sigma to a file\\n # This doesn't need to be in param loop because we want to do it for all the parameters\\n # regardless if we have published values.\\n # polynomial\\n for i in range(len(ch1polyAORs)):\\n print >> f, ('{0:}\\\\t{1:}\\\\t{2:}\\\\t{3:}\\\\t{4:.4f}\\\\t{5:.4f}\\\\t{6:.4f}\\\\t{7:.4f}\\\\t{8:.4f}\\\\t{9:.4f}'.format(\\n param, ch1polyAORs[i], 'ch1', 'poly',\\n float(ch1polyMean_list[0][i]), float(ch1polyStds_list[0].T[i].max()), #channel 1\\n float(ch1polyMean_list[1][i]), float(ch1polyStds_list[1].T[i].max()), # choose the biggest error\\n *nsigma(float(ch1polyMean_list[0][i]), float(ch1polyStds_list[0].T[i].max()),\\n float(ch1polyMean_list[1][i]), float(ch1polyStds_list[0].T[i].max()))))\\n\\n for i in range(len(ch2polyAORs)):\\n print >> f, ('{0:}\\\\t{1:}\\\\t{2:}\\\\t{3:}\\\\t{4:.4f}\\\\t{5:.4f}\\\\t{6:.4f}\\\\t{7:.4f}\\\\t{8:.4f}\\\\t{9:.4f}'.format(\\n param, ch2polyAORs[i], 'ch2', 'poly',\\n float(ch2polyMean_list[0][i]), float(ch2polyStds_list[0].T[i].max()), #channel 1\\n float(ch2polyMean_list[1][i]), float(ch2polyStds_list[1].T[i].max()), # choose the biggest error\\n *nsigma(float(ch2polyMean_list[0][i]), float(ch2polyStds_list[0].T[i].max()),\\n float(ch2polyMean_list[1][i]), float(ch2polyStds_list[0].T[i].max()))))\\n #PLD\\n for i in range(len(ch1PLDAORs)):\\n print >> f, ('{0:}\\\\t{1:}\\\\t{2:}\\\\t{3:}\\\\t{4:.4f}\\\\t{5:.4f}\\\\t{6:.4f}\\\\t{7:.4f}\\\\t{8:.4f}\\\\t{9:.4f}'.format(\\n param, ch1PLDAORs[i], 'ch1', 'PLD',\\n float(ch1PLDMean_list[0][i]), float(ch1PLDStds_list[0].T[i].max()), #channel 1\\n float(ch1PLDMean_list[1][i]), float(ch1PLDStds_list[1].T[i].max()), # choose the biggest error\\n *nsigma(float(ch1PLDMean_list[0][i]), float(ch1PLDStds_list[0].T[i].max()),\\n float(ch1PLDMean_list[1][i]), float(ch1PLDStds_list[0].T[i].max()))))\\n\\n for i in range(len(ch2PLDAORs)):\\n print >> f, ('{0:}\\\\t{1:}\\\\t{2:}\\\\t{3:}\\\\t{4:.4f}\\\\t{5:.4f}\\\\t{6:.4f}\\\\t{7:.4f}\\\\t{8:.4f}\\\\t{9:.4f}'.format(\\n param, ch2PLDAORs[i], 'ch2', 'PLD',\\n float(ch2PLDMean_list[0][i]), float(ch2PLDStds_list[0].T[i].max()), #channel 1\\n float(ch2PLDMean_list[1][i]), float(ch2PLDStds_list[1].T[i].max()), # choose the biggest error\\n *nsigma(float(ch2PLDMean_list[0][i]), float(ch2PLDStds_list[0].T[i].max()),\\n float(ch2PLDMean_list[1][i]), float(ch2PLDStds_list[0].T[i].max()))))\\n pass\\n\\n # Set the y limits of both plots to be the same sacle and to include both ch1 and ch2 points\\n axis1ylim = ax1.get_ylim()\\n axis2ylim = ax2.get_ylim()\\n if ax1.get_ylim()[0] < ax2.get_ylim()[0]:\\n ymin = ax1.get_ylim()[0]\\n else:\\n ymin = ax2.get_ylim()[0]\\n if ax1.get_ylim()[1] < ax2.get_ylim()[1]:\\n ymax = ax2.get_ylim()[1]\\n else:\\n ymax = ax1.get_ylim()[1]\\n ax1.set_ylim(ymin,ymax)\\n ax2.set_ylim(ax1.get_ylim())\\n ax2.get_yaxis().set_visible(False)\\n\\n ax1.legend(loc = 'best')\\n\\n\\n # Save if required\\n if saveplot:\\n plt.savefig(\\\"{3}/PhD/SpitzerTransits/{0}{1}/{0}_{2}_eccentricCircular.png\\\".format(planet,foldext,param, os.getenv('HOME')),bbox_inches='tight')\\n #plt.close()\\n if plotPublished:\\n f.close()\\n else:\\n pass\",\n \"def plot_results(outputs, x, e, t, a, folds, groups,\\n quantiles, strat='quantile', adj='KM', plot=True):\\n if plot:\\n mpl.rcParams['hatch.linewidth'] = 2.0\\n\\n fig, big_axes = plt.subplots(\\n figsize=(8 * (len(groups) + 2), 6 * len(quantiles)),\\n nrows=len(quantiles),\\n ncols=1)\\n\\n plt.subplots_adjust(hspace=0.4)\\n\\n i = 0\\n for _, big_ax in enumerate(big_axes, start=1):\\n big_ax.set_title(\\n 'Receiver Operator Characteristic and Calibration at t=' +\\n str(quantiles[i]) + '\\\\n',\\n fontsize=16)\\n big_ax.tick_params(\\n labelcolor=(1., 1., 1., 0.0),\\n top='off',\\n bottom='off',\\n left='off',\\n right='off')\\n i += 1\\n \\n eces = {}\\n metrics = {}\\n\\n for quant in quantiles:\\n eces[quant] = {}\\n \\n for i in range(len(quantiles)):\\n\\n scores = outputs[quantiles[i]]\\n for j in range(len(groups) + 2):\\n\\n pt = (i * (len(groups) + 2) + j + 1)\\n if plot:\\n ax = fig.add_subplot(len(quantiles), len(groups) + 2, pt)\\n else:\\n ax = None\\n \\n if (j==1):\\n eces[quantiles[i]]['all'] = plot_calibration_curve(ax,\\n scores,\\n e,\\n t,\\n a,\\n folds,\\n None,\\n quantiles[i],\\n strat=strat,\\n adj=adj,\\n plot=plot) \\n \\n if (j>1):\\n eces[quantiles[i]][groups[j - 2]] = plot_calibration_curve(ax,\\n scores,\\n e,\\n t,\\n a,\\n folds,\\n groups[j - 2],\\n quantiles[i],\\n strat=strat,\\n adj=adj,\\n plot=plot)\\n \\n if (j==0):\\n metrics[quantiles[i]] = plot_roc_curve(ax,\\n scores,\\n e,\\n t,\\n a,\\n folds,\\n groups,\\n quantiles[i],\\n plot=plot)\\n\\n for quant in quantiles:\\n metrics[quant] = metrics[quant] + (eces[quant], )\\n \\n if plot: \\n plt.show()\\n return metrics\",\n \"def results():\\n\\n # # 1. tau_e graph\\n # # ------------------------------------------------------------\\n\\n tau_es = np.load(datapath / \\\"tau_es.npy\\\", allow_pickle=True)\\n\\n # I want to plot tau_e against b for various Ns. Annoyingly this\\n # means I have to do some index juggling.\\n\\n # This is all because of the way I set up datagen.DataSet... oh well.\\n\\n for i, N in enumerate(Ns):\\n\\n # values to plot against b for the specific N\\n vals = []\\n\\n for j, b in enumerate(bs):\\n\\n k = Nb_to_ks[i][j]\\n vals.append(tau_es[k])\\n\\n plt.plot(bs, vals, \\\"-\\\")\\n\\n plt.title(\\\"Auto-correlation e-folding timelag for \\\"\\n \\\"variable temperatures, grid sizes\\\")\\n\\n plt.xlabel(\\\"$\\\\\\\\beta$\\\")\\n plt.ylabel(\\\"$\\\\\\\\tau_e$\\\")\\n\\n plt.legend([f\\\"N={N}\\\" for N in Ns])\\n\\n plt.savefig(resultspath / \\\"tau_es.pdf\\\")\\n # plt.show()\\n plt.close()\\n\\n # 2. magnetisation graphs\\n # ------------------------------------------------------------\\n\\n mags_list = [np.load(datapath / f\\\"mags-{k}.npy\\\") for k in range(kcount)]\\n\\n for i, N in enumerate(Ns):\\n\\n plt.title(f\\\"Square magnetisations N={N}\\\")\\n plt.xlabel(\\\"t\\\")\\n plt.ylabel(\\\"M\\\")\\n\\n for j, b in enumerate(bs):\\n\\n c = np.max([0, np.min([1, 10 * (b - 0.4)])])\\n\\n k = Nb_to_ks[i][j]\\n vals = np.mean(mags_list[k]**2, axis=1)\\n plt.plot(vals, color=(1 - c, 0, c))\\n\\n plt.savefig(resultspath / f\\\"mags-{N}.pdf\\\")\\n # plt.show()\\n plt.close()\\n\\n # 3. autoc graphs\\n # ------------------------------------------------------------\\n\\n autocs_list = [\\n np.load(datapath / f\\\"autocs-{k}.npy\\\") for k in range(kcount)]\\n\\n for i, N in enumerate(Ns):\\n\\n plt.figure(figsize=(8, 6))\\n plt.axes(position=[.05, .05, .8, .9])\\n\\n plt.title(f\\\"Auto-correlation of $|M|$ with N={N}\\\")\\n plt.xlabel(\\\"$ \\\\\\\\tau $\\\")\\n plt.ylabel(\\\"$ A(\\\\\\\\tau) $\\\")\\n\\n for j, b in enumerate(bs):\\n\\n c = np.max([0, np.min([1, 10 * (b - 0.4)])])\\n\\n k = Nb_to_ks[i][j]\\n autocs = np.load(datapath / f\\\"autocs-{k}.npy\\\")\\n\\n iternum = autocs.shape[0]\\n sysnum = autocs.shape[1]\\n vals = np.mean(autocs, axis=1)\\n errs = np.std(autocs, axis=1, ddof=1) / np.sqrt(sysnum)\\n\\n plt.errorbar(range(iternum), vals, errs,\\n color=(1 - c, 0, c), ecolor=(1 - c, 0, c, 0.4),\\n elinewidth=1.5)\\n\\n # plt.plot(np.log(vals))\\n\\n plt.legend(bs, loc='center left', bbox_to_anchor=(1, 0.5))\\n\\n plt.savefig(resultspath / f\\\"autocs-{N}.pdf\\\")\\n # plt.show()\\n plt.close()\",\n \"def plot_iminuit_contours():\\n log.info(\\\"plotting parameters contours obtained from iminuit\\\")\\n # where to take the results, configurations for the individual butterflies\\n instruments = [\\\"fermi\\\", \\\"magic\\\", \\\"veritas\\\", \\\"fact\\\", \\\"hess\\\", \\\"joint\\\"]\\n labels = [\\\"Fermi-LAT\\\", \\\"MAGIC\\\", \\\"VERITAS\\\", \\\"FACT\\\", \\\"H.E.S.S.\\\", \\\"joint fit\\\"]\\n colors = COLORS\\n lss = [\\\"--\\\", \\\"--\\\", \\\"--\\\", \\\"--\\\", \\\"--\\\", \\\"-\\\"]\\n\\n fig, axarr = plt.subplots(1, 3, figsize=(16, 5))\\n\\n # with one loop we realize all the contour plots\\n for instrument, label, color, ls in zip(instruments, labels, colors, lss):\\n path = config.repo_path / f\\\"results/fit/gammapy/{instrument}\\\"\\n\\n contours_path = path / \\\"fit_1.0_sigma_contours_logparabola.npy\\\"\\n results_path = path / \\\"fit_results_logparabola.yaml\\\"\\n\\n if not path.exists():\\n log.warning(f\\\"Missing: {path} . Skipping.\\\")\\n continue\\n\\n # load the contours and the results of the fit\\n contours = np.load(contours_path).tolist()\\n results = load_yaml(results_path)\\n # true values to be plotted\\n amplitude = float(results[\\\"parameters\\\"][0][\\\"value\\\"])\\n alpha = float(results[\\\"parameters\\\"][2][\\\"value\\\"])\\n beta = float(results[\\\"parameters\\\"][3][\\\"value\\\"])\\n\\n # amplitude vs alpha\\n amplitude_alpha = contours[\\\"contour_amplitude_alpha\\\"]\\n axarr[0].plot(\\n amplitude_alpha[\\\"amplitude\\\"] * 10,\\n amplitude_alpha[\\\"alpha\\\"],\\n marker=\\\"\\\",\\n ls=\\\"-\\\",\\n lw=2.5,\\n color=color,\\n )\\n # plot actual value\\n axarr[0].plot(\\n amplitude * 1e11, alpha, marker=\\\"X\\\", markersize=7, color=color, lw=2.5\\n )\\n axarr[0].set_xlabel(\\n r\\\"$\\\\phi_0 \\\\,/\\\\,(10^{-11}\\\\,{\\\\rm TeV} \\\\, {\\\\rm cm}^{-2} {\\\\rm s}^{-1})$\\\",\\n size=FONTSIZE_CONTOURS,\\n )\\n axarr[0].set_ylabel(r\\\"$\\\\Gamma$\\\", size=FONTSIZE_CONTOURS)\\n # make axis thicker\\n for axis in [\\\"top\\\", \\\"bottom\\\", \\\"left\\\", \\\"right\\\"]:\\n axarr[0].spines[axis].set_linewidth(2.5)\\n axarr[0].set_yticks([2.2, 2.4, 2.6, 2.8])\\n axarr[0].set_ylim([2.1, 2.9])\\n axarr[0].set_xticks([3, 4, 5])\\n axarr[0].set_xlim([2.8, 5.2])\\n axarr[0].tick_params(\\n \\\"both\\\", length=7, width=1.6, which=\\\"major\\\", labelsize=FONTSIZE_CONTOURS\\n )\\n axarr[0].tick_params(\\n \\\"both\\\", length=4, width=1.6, which=\\\"minor\\\", labelsize=FONTSIZE_CONTOURS\\n )\\n\\n # amplitude vs beta\\n amplitude_beta = contours[\\\"contour_amplitude_beta\\\"]\\n axarr[1].plot(\\n amplitude_beta[\\\"amplitude\\\"] * 10,\\n # contour have a scale factor of 1e-10, parameters are in units of 1e-11\\n amplitude_beta[\\\"beta\\\"],\\n marker=\\\"\\\",\\n ls=\\\"-\\\",\\n lw=2.5,\\n color=color,\\n )\\n # plot actual value\\n axarr[1].plot(amplitude * 1e11, beta, marker=\\\"X\\\", markersize=7, color=color)\\n axarr[1].set_xlabel(\\n r\\\"$\\\\phi_0 \\\\,/\\\\,(10^{-11}\\\\,{\\\\rm TeV} \\\\, {\\\\rm cm}^{-2} {\\\\rm s}^{-1})$\\\",\\n size=FONTSIZE_CONTOURS,\\n )\\n axarr[1].set_ylabel(r\\\"$\\\\beta$\\\", size=FONTSIZE_CONTOURS)\\n axarr[1].set_xticks([3, 4, 5])\\n axarr[1].set_xlim([2.8, 5.2])\\n axarr[1].set_yticks([0.2, 0.4, 0.6])\\n axarr[1].set_ylim([0.0, 0.8])\\n # make axis thicker\\n for axis in [\\\"top\\\", \\\"bottom\\\", \\\"left\\\", \\\"right\\\"]:\\n axarr[1].spines[axis].set_linewidth(2.5)\\n axarr[1].tick_params(\\n \\\"both\\\", length=7, width=1.6, which=\\\"major\\\", labelsize=FONTSIZE_CONTOURS\\n )\\n axarr[1].tick_params(\\n \\\"both\\\", length=4, width=1.6, which=\\\"minor\\\", labelsize=FONTSIZE_CONTOURS\\n )\\n\\n # alpha vs beta\\n alpha_beta = contours[\\\"contour_alpha_beta\\\"]\\n axarr[2].plot(\\n alpha_beta[\\\"alpha\\\"],\\n alpha_beta[\\\"beta\\\"],\\n marker=\\\"\\\",\\n ls=\\\"-\\\",\\n lw=2.5,\\n color=color,\\n )\\n # plot actual value\\n axarr[2].plot(alpha, beta, marker=\\\"X\\\", markersize=7, color=color)\\n axarr[2].set_xlabel(r\\\"$\\\\Gamma$\\\", size=FONTSIZE_CONTOURS)\\n axarr[2].set_ylabel(r\\\"$\\\\beta$\\\", size=FONTSIZE_CONTOURS)\\n axarr[2].set_xticks([2.2, 2.4, 2.6, 2.8])\\n axarr[2].set_xlim([2.1, 2.9])\\n axarr[2].set_yticks([0.2, 0.4, 0.6])\\n axarr[2].set_ylim([0.0, 0.8])\\n # make axis thicker\\n for axis in [\\\"top\\\", \\\"bottom\\\", \\\"left\\\", \\\"right\\\"]:\\n axarr[2].spines[axis].set_linewidth(2.5)\\n axarr[2].tick_params(\\n \\\"both\\\", length=7, width=1.6, which=\\\"major\\\", labelsize=FONTSIZE_CONTOURS\\n )\\n axarr[2].tick_params(\\n \\\"both\\\", length=4, width=1.6, which=\\\"minor\\\", labelsize=FONTSIZE_CONTOURS\\n )\\n\\n # legend\\n import matplotlib.lines as mlines\\n\\n fermi = mlines.Line2D(\\n [], [], color=COLORS[0], marker=\\\"\\\", ls=\\\"-\\\", lw=2.5, label=\\\"Fermi-LAT\\\"\\n )\\n magic = mlines.Line2D(\\n [], [], color=COLORS[1], marker=\\\"\\\", ls=\\\"-\\\", lw=2.5, label=\\\"MAGIC\\\"\\n )\\n veritas = mlines.Line2D(\\n [], [], color=COLORS[2], marker=\\\"\\\", ls=\\\"-\\\", lw=2.5, label=\\\"VERITAS\\\"\\n )\\n fact = mlines.Line2D(\\n [], [], color=COLORS[3], marker=\\\"\\\", ls=\\\"-\\\", lw=2.5, label=\\\"FACT\\\"\\n )\\n hess = mlines.Line2D(\\n [], [], color=COLORS[4], marker=\\\"\\\", ls=\\\"-\\\", lw=2.5, label=\\\"H.E.S.S.\\\"\\n )\\n joint = mlines.Line2D(\\n [], [], color=COLORS[5], marker=\\\"\\\", ls=\\\"-\\\", lw=2.5, label=\\\"joint fit\\\"\\n )\\n\\n box = axarr[2].get_position()\\n axarr[2].set_position([box.x0, box.y0, box.width * 0.97, box.height])\\n # plot the legend on top of the central plot\\n axarr[2].legend(\\n handles=[fermi, magic, veritas, fact, hess, joint],\\n loc=\\\"center left\\\",\\n fontsize=FONTSIZE_CONTOURS,\\n bbox_to_anchor=(1., 0.5),\\n )\\n\\n plt.tight_layout()\\n filename = \\\"results/figures/iminuit_logparabola_contour.png\\\"\\n filename_pdf = \\\"results/figures/iminuit_logparabola_contour.pdf\\\"\\n fig.savefig(filename)\\n log.info(f\\\"Writing {filename}\\\")\\n fig.savefig(filename)\\n fig.savefig(filename_pdf)\",\n \"def plot_parameter_evolution(analyses, pdf=False):\\n ncs = np.arange(11, 15)\\n genes = set(analyses.gene)\\n constructs = set(analyses.construct)\\n long_labels = {'bac': 'bac', 'no_pr': 'no pr', 'no_sh': 'no sh'}\\n gene_long = {'hb': 'hunchback', 'kn': 'knirps', 'sn': 'snail'}\\n y_label = {'j': 'Normalized flux $j$',\\n 'rho': 'Site occupation density $\\\\\\\\rho$', 'tau': 'Residence time $\\\\\\\\tau$ (s)', 'alpha_comb': 'Initiation rate $\\\\\\\\alpha$ (pol/min)'}\\n\\n # Add extra jiggle to be able to distinguish overlapping data points\\n x_jiggle = 0.04\\n x_shifts = np.array([-1, 0, 1]) * x_jiggle\\n\\n # Plot parameters\\n capsize = 0\\n markersize = 4\\n lw = 1 # line width\\n\\n for gene in genes:\\n grouped_data = analyses.groupby(by=['gene', 'construct', 'nc'])\\n all_means = grouped_data.mean()\\n all_stds = grouped_data.std(ddof=1)\\n all_ps = analyses.groupby(by=['gene', 'nc']).first()\\n\\n for quantity in ['j', 'rho', 'tau', 'alpha_comb']:\\n ymaxs = {'j': 0.36, 'rho': 0.27, 'tau': 103, 'alpha_comb': 12}\\n num = 12\\n set_figure_size(num=num, rows=1, page_width_frac=0.5, clear=True, height_factor=0.7)\\n fig, ax = plt.subplots(1, 1, num=num, clear=True)\\n avg_data, std_data = {}, {}\\n for construct in constructs:\\n if quantity in ['rho', 'j']:\\n avg_data[construct] = all_means.loc[(\\n gene, construct, slice(None)), quantity].values\\n std_data[construct] = all_stds.loc[(\\n gene, construct, slice(None)), quantity].values\\n\\n elif quantity in ['tau', 'alpha_comb']:\\n avg_data[construct] = all_means.loc[(\\n gene, construct, slice(None)), quantity].values\\n std_data[construct] = np.sqrt(\\n all_means.loc[(gene, construct, slice(None)), quantity + 'V'].values)\\n\\n # Prepare a marker generator and plot the data with errorbars\\n marker_gen = itertools.cycle(markers_additivity)\\n for i, construct in enumerate(constructs):\\n m = next(marker_gen)\\n plt.errorbar(\\n ncs + x_shifts[i], avg_data[construct],\\n yerr=std_data[construct],\\n fmt='-' + m, color=colors_additivity[construct],\\n capsize=capsize, label=long_labels[construct],\\n markersize=markersize, lw=lw)\\n\\n # Adjust plot\\n plt.xlabel('Nuclear cycle')\\n plt.ylabel(y_label[quantity])\\n plt.ylim(ymin=0, ymax=ymaxs[quantity])\\n\\n plt.xticks(ncs)\\n plt.title(gene_long[gene])\\n\\n plt.tight_layout()\\n plt.show()\\n\\n # Save figure\\n figname = 'additivity_' + quantity + '_' + gene\\n figpath = os.path.join(figures_folder, figname)\\n fig.savefig(figpath + '.png', pad_inches=0, bbox_inches='tight')\\n if pdf:\\n fig.savefig(figpath + '.pdf', pad_inches=0, bbox_inches='tight')\",\n \"def plotResults(results):\\n e = results['eclean'] - results['eCTI']\\n e1 = results['e1clean'] - results['e1CTI']\\n e2 = results['e2clean'] - results['e2CTI']\\n\\n print 'Delta e, e_1, e_2:', np.mean(e), np.mean(e1), np.mean(e2)\\n print 'std e, e_1, e_2:', np.std(e), np.std(e1), np.std(e2)\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n ax.hist(e, bins=15, label='$e$', alpha=0.5)\\n ax.hist(e1, bins=15, label='$e_{2}$', alpha=0.5)\\n ax.hist(e2, bins=15, label='$e_{1}$', alpha=0.5)\\n ax.set_xlabel(r'$\\\\delta e$ [no CTI - CDM03 corrected]')\\n plt.legend(shadow=True, fancybox=True)\\n plt.savefig('ellipticityDelta.pdf')\\n plt.close()\\n\\n r2 = (results['R2clean'] - results['R2CTI'])/results['R2clean']\\n print 'delta R2 / R2: mean, std ', np.mean(r2), np.std(r2)\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n ax.hist(r2, bins=15, label='$R^{2}$')\\n ax.set_xlabel(r'$\\\\frac{\\\\delta R^{2}}{R^{2}_{ref}}$ [no CTI - CDM03 corrected]')\\n plt.legend(shadow=True, fancybox=True)\\n plt.savefig('sizeDelta.pdf')\\n plt.close()\",\n \"def plot_evaluation(parameters_dict, log_df, settings, evaluation_set_kde, plotname):\\n\\n\\n plots = []\\n\\n\\n ### setup the colors for each component\\n if int(settings['nr_components']) < 3:\\n colors = ['rgb(228,26,28)', 'rgb(55,126,184)']\\n elif int(settings['nr_components']) < 13:\\n colors = np.array(cl.scales[str(settings['nr_components'])]['qual']['Paired'])\\n else:\\n colors = cl.interp(cl.scales['10']['qual']['Paired'], 20)\\n\\n\\n ### set up ab list\\n ab_list = evaluation_set_kde['contact'].keys()\\n\\n\\n\\n\\n ####################### plotting of settings\\n print_to_table = {}\\n for key in sorted(settings.keys()):\\n if key not in ['fold_id_dir','plot_name', 'fixed_parameters', 'threads_proteins', 'qijab_dir',\\n 'debug_mode', 'parameter_file', 'settings_file', 'optimization_log_file', 'braw_dir', 'pdb_dir', 'paramdir',\\n 'mask_sse', 'lambda_w_fix', 'lfactor', 'plotdir', 'psicov_dir', 'contact', 'hessian_pseudocount']:\\n print_to_table[key] = settings[key]\\n\\n print(\\\"Generate settings table...\\\")\\n table_settings_1 = plot_settings_table(print_to_table, 1)\\n table_settings_2 = plot_settings_table(print_to_table, 2)\\n table_settings_3 = plot_settings_table(print_to_table, 3)\\n plots.append(table_settings_1)\\n plots.append(table_settings_2)\\n plots.append(table_settings_3)\\n\\n\\n ####################### negLL and realted plots\\n if 'step' in log_df.columns and 'pass' in log_df.columns:\\n\\n if 'negLL' in log_df.columns:\\n plot_negll = plot_convergence_trace_plotly(log_df,\\n name=['negLL', 'negLL_crossval'],\\n plot_title='neg LL trace for training and cross-val set')\\n plots.append(plot_negll)\\n\\n plot_expfit_negll = plot_exponentialFit_negLL(log_df, plot_title='exponential Fit neg LL')\\n plots.append(plot_expfit_negll)\\n\\n if 'timestamp' in log_df.columns:\\n plot_timestamps = plot_convergence_trace_plotly(log_df,\\n name=['timestamp'],\\n plot_title='time (s) per iteration')\\n plots.append(plot_timestamps)\\n\\n\\n if 'gradient_norm_weights' in log_df.columns:\\n plot_grad_norm_weights = plot_convergence_trace_plotly(log_df,\\n name=['gradient_norm_weights'],\\n plot_title='norm of weight gradients')\\n plots.append(plot_grad_norm_weights)\\n\\n if 'gradient_norm_means' in log_df.columns:\\n plot_grad_norm_means = plot_convergence_trace_plotly(log_df,\\n name=['gradient_norm_means'],\\n plot_title='norm of mean gradients')\\n plots.append(plot_grad_norm_means)\\n\\n if 'gradient_norm_prec' in log_df.columns:\\n plot_grad_norm_prec = plot_convergence_trace_plotly(log_df,\\n name=['gradient_norm_prec'],\\n plot_title='norm of precMat gradients')\\n plots.append(plot_grad_norm_prec)\\n\\n\\n ####################### plotting of parameters\\n print(\\\"Generate distribution of parameters...\\\")\\n\\n #weights\\n weights_dict = {}\\n for component in range(settings['nr_components']):\\n weights_dict['component ' + str(component)] = {\\n 'weights (contact)': parameters_dict[\\\"weight_contact_\\\" + str(component)][0],\\n 'weights (bg)': parameters_dict[\\\"weight_bg_\\\" + str(component)][0]\\n }\\n plot_weights = plot_barplot(\\n weights_dict,\\n 'Distribution of weights',\\n 'component weights',\\n type='group',\\n colors=colors\\n #,plot_out=\\\"/home/vorberg/weights.html\\\"\\n )\\n\\n #mu\\n mu_df = pd.DataFrame.from_dict(dict((k, parameters_dict[k]) for k in sorted(parameters_dict.keys()) if 'mu' in k))\\n plot_means = plot_boxplot(\\n mu_df,\\n 'Distribution of Means',\\n \\\"values of mean parameters\\\",\\n colors=colors\\n #,plot_out=\\\"/home/vorberg/mus.html\\\"\\n )\\n\\n #std deviation\\n prec_df = pd.DataFrame.from_dict(dict((k, parameters_dict[k]) for k in sorted(parameters_dict.keys()) if 'prec' in k))\\n try:\\n std_dev = prec_df.apply(lambda p: np.sqrt(1.0/p))\\n if settings['prec_wrt_L']:\\n std_dev = prec_df.apply(lambda p: np.sqrt(1.0/(p*142))) #in case precision is specified depending on L=142\\n except ZeroDivisionError as e:\\n print(e)\\n std_dev=prec_df\\n\\n std_dev.columns = [column_name.replace(\\\"prec\\\", \\\"std\\\") for column_name in std_dev.columns]\\n plot_stddev = plot_boxplot(\\n std_dev,\\n 'Distribution of std deviations',\\n \\\"values of std deviation parameters\\\",\\n colors=colors\\n #,plot_out=\\\"/home/vorberg/std.html\\\"\\n )\\n\\n\\n plots.append(plot_weights)\\n plots.append(plot_means)\\n plots.append(plot_stddev)\\n\\n ####################### Scatterplot mu vs std dev\\n print(\\\"Generate scatter plot mu vs std...\\\")\\n scatter_dict = {}\\n for component in range(settings['nr_components']):\\n scatter_dict['mu_'+str(component)] = [\\n mu_df['mu_'+str(component)].tolist(),\\n std_dev['std_'+str(component)].tolist(),\\n AB.values()\\n ]\\n plot_mu_vs_stddev = plot_scatter(scatter_dict,\\n 'Mean vs std deviation',\\n 'mean',\\n \\\"std deviation\\\",\\n False,\\n colors\\n #,plot_out=\\\"/home/vorberg/mu_vs_std.html\\\"\\n )\\n\\n plots.append(plot_mu_vs_stddev)\\n\\n\\n ############################################## plotting of gradient norms\\n print(\\\"Generate gradient norms plot...\\\")\\n\\n #gradients for mu\\n mu_grad_dict = {}\\n annotations_dict = {}\\n for component in range(settings['nr_components']):\\n key = 'mu_'+str(component)\\n mu_grad_dict[key] = log_df[key].tolist()[-1]\\n annotations_dict[key] = AB\\n\\n\\n plot_gradient_mu_stats = jitter_plot(mu_grad_dict,\\n 'Distribution of gradients for mean in last iteration',\\n annotations_dict,\\n colors,\\n None)\\n plots.append(plot_gradient_mu_stats)\\n\\n\\n #gradients for precMat\\n precMat_grad_dict = {}\\n annotations_dict = {}\\n for component in range(settings['nr_components']):\\n key = 'prec_'+str(component)\\n precMat_grad_dict['diagPrecMat_'+str(component)] = log_df[key].tolist()[-1]\\n annotations_dict['diagPrecMat_'+str(component)] = AB\\n\\n\\n plot_gradient_precMat_stats = jitter_plot(\\n precMat_grad_dict,\\n 'Distribution of gradients for precMat in last iteration',\\n annotations_dict,\\n colors,\\n None\\n )\\n plots.append(plot_gradient_precMat_stats)\\n\\n ##################################### plotting of gradient trace of a specific ab pair for all components\\n print(\\\"Generate gradient trace plot...\\\")\\n\\n gradient_df = log_df.filter(regex=(\\\"mu_[0-9]*\\\"))\\n plot_gradient_mu_ab_trace = plot_gradient_ab_trace(gradient_df,\\n ab_list,\\n colors\\n )\\n plots.append(plot_gradient_mu_ab_trace)\\n\\n gradient_df = log_df.filter(regex=(\\\"prec_[0-9]*\\\"))\\n plot_gradient_prec_ab_trace = plot_gradient_ab_trace(\\n gradient_df,\\n ab_list,\\n colors\\n )\\n plots.append(plot_gradient_prec_ab_trace)\\n\\n\\n ##################################### plotting of univariate mixtures\\n if len(evaluation_set_kde['contact']) == 0 or len(evaluation_set_kde['bg']) == 0:\\n print \\\"Evaluation set is empty. Cannot plot Mixture Visualization.\\\"\\n else:\\n print(\\\"Generate parameter visualization 1d plots...\\\")\\n plots.append(plot_parameter_visualisation_1d(parameters_dict, evaluation_set_kde, settings, colors, settings['prec_wrt_L']))\\n # plot_parameter_visualisation_1d(parameters_dict, evaluation_set_kde, settings, colors, settings['prec_wrt_L'], plot_out=\\\"/home/vorberg/1d_vis.html\\\")\\n\\n # ------------------------------------------------------------------------------\\n ### define merged plot\\n # ------------------------------------------------------------------------------\\n cols = 3.0\\n rows = int(np.ceil((len(plots)-1) / cols)) + 2\\n subplot_titles = []\\n\\n # set up titles\\n for plot in range(len(plots)-1):\\n subplot_titles.append(plots[plot]['layout']['title'])\\n if len(subplot_titles) < (cols * (rows-2)):\\n for i in range(int((cols * (rows-2))) - len(subplot_titles) ):\\n subplot_titles.append(\\\" \\\")\\n subplot_titles.append(plots[-1]['layout']['title'])\\n\\n\\n # plot all plots as subplots\\n fig = tools.make_subplots(rows=rows,\\n cols=3,\\n specs = [ [{} for col in range(int(cols))] for row in range(rows-2)] + \\\\\\n [[{'rowspan':2, 'colspan': 3}, None, None], [None, None, None]],\\n subplot_titles=tuple(subplot_titles),\\n print_grid=False)\\n\\n\\n\\n\\n for i, plot in enumerate(plots[:-1]):\\n col = i % int(cols)\\n row = (i - col) / int(cols)\\n\\n #add traces to subplot\\n for trace in plot['data']:\\n trace['showlegend']=False\\n fig.append_trace(trace, row + 1, col + 1)\\n\\n # adjust x and y axis for table plotting\\n if 'annotations' in plot['layout'].keys():\\n for cell in plot['layout']['annotations']:\\n cell['yref'] = 'y' + str(i + 1)\\n cell['xref'] = 'x' + str(i + 1)\\n fig['layout']['annotations'] += plot['layout']['annotations']\\n\\n # adjust axis for all plots\\n fig['layout']['xaxis' + str(i + 1)].update(plot['layout']['xaxis1'])\\n fig['layout']['yaxis' + str(i + 1)].update(plot['layout']['yaxis1'])\\n\\n ## add mixture visualisation plot - spans 3 columns\\n for trace in plots[-1]['data']:\\n fig.append_trace(trace, int(rows)-1, 1)\\n fig['layout']['xaxis' + str(int(cols * (rows-2) + 1))].update(plots[-1]['layout']['xaxis1'])\\n fig['layout']['yaxis' + str(int(cols * (rows-2) + 1))].update(plots[-1]['layout']['yaxis1'])\\n\\n #check which plots are visible/invisible according to menu selection\\n trace_visibility_ab = {}\\n for ab in range(len(ab_list)):\\n trace_visibility_ab[ab] = []\\n for i, plot in enumerate(plots):\\n if 'updatemenus' not in plot['layout'].keys():\\n trace_visibility_ab[ab].extend([True] * len(plot['data']))\\n else:\\n trace_visibility_ab[ab].extend(plot['layout']['updatemenus'][0]['buttons'][ab]['args'][1])\\n\\n\\n #use menu of last plot (=vis of mixture) as template for multiplot menu\\n fig['layout']['updatemenus'] = plots[-1]['layout']['updatemenus']\\n for ab in range(len(ab_list)):\\n fig['layout']['updatemenus'][0]['buttons'][ab]['args'][1] = trace_visibility_ab[ab]\\n\\n\\n fig['layout']['legend']['yanchor'] = 'bottom'\\n fig['layout']['legend']['y'] = 0\\n fig['layout']['height'] = rows * 250\\n fig['layout']['font'] = {'size': 18} # set global font size\\n\\n plotly_plot(fig, filename=plotname, auto_open=False)\",\n \"def plot(results, key, titles):\\n # get parametric sweep data\\n N = int(math.sqrt(len(results.data)))\\n M = results.data[key].reshape(N, N)\\n R = results.data['r'].reshape(N, N)\\n PD = results.data['pd'].reshape(N, N)\\n\\n fig = plt.figure()\\n ax = fig.gca(projection='3d')\\n surf = ax.plot_surface(R, PD, M,\\n cmap=cm.viridis, linewidth=0,\\n vmin=0, vmax=np.nanmax(M),\\n antialiased=False)\\n\\n # set x/y axis labels, ticks\\n ax.set_xlabel(\\\"Coolant Channel Diameter [m]\\\", fontsize=7)\\n plt.xticks(rotation=25, fontsize=6)\\n ax.set_ylabel(\\\"Fuel Pitch to Coolant D Ratio [-]\\\", fontsize=7)\\n plt.yticks(rotation=25, fontsize=6)\\n ax.set_zlabel(titles[key][1], fontsize=7)\\n\\n # Customize the z axis.\\n ax.set_zlim(np.nanmin(M), np.nanmax(M))\\n ax.zaxis.set_major_locator(LinearLocator(10))\\n ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))\\n\\n # edit z tick labels\\n for t in ax.zaxis.get_major_ticks():\\n t.label.set_fontsize(6)\\n niceMathTextForm = ScalarFormatter(useMathText=True)\\n ax.w_zaxis.set_major_formatter(niceMathTextForm)\\n ax.ticklabel_format(axis=\\\"z\\\", style=\\\"sci\\\", scilimits=(0, 0))\\n plt.title(titles[key][0])\\n\\n # Add a color bar which maps values to colors.\\n fig.colorbar(surf, shrink=0.5, aspect=5, format='%.0e')\\n\\n return plt\",\n \"def plot_u(self, **kwargs):\\r\\n\\r\\n # Get the kwargs.\\r\\n items = kwargs['items']\\r\\n if type(items) is not list:\\r\\n items = [items]\\r\\n if 'desc' in kwargs.keys():\\r\\n desc = kwargs['desc']\\r\\n else:\\r\\n desc = ''\\r\\n\\r\\n # Loop and plot each requested dof.\\r\\n fig = figure()\\r\\n ax = subplot(111)\\r\\n for item in items:\\r\\n if item.__len__() != 3:\\r\\n raise Exception('!!! You must supply (case, acron, dof) to plot !!!')\\r\\n c = item[0]\\r\\n if c not in self.u.keys():\\r\\n raise Exception('!!! Case {0} is has not been run or does not exist !!!'.format(c))\\r\\n dof = (item[1], item[2])\\r\\n\\r\\n # Find the dof tuple in the acron_dof list or the dof list from the ltm object.\\r\\n if dof in self.ltm.acron_dofs:\\r\\n i_dof = self.ltm.acron_dofs.index(dof)\\r\\n elif dof in self.ltm.dofs:\\r\\n i_dof = self.ltm.dofs.index(dof)\\r\\n else:\\r\\n raise Exception(\\\"!!! DOF \\\" + dof.__str__() + \\\" not in LTM \\\" + self.ltm.name)\\r\\n\\r\\n # Plot the requested time history.\\r\\n label = '({0}, {1}) case: {2}'.format(dof[0], dof[1], c)\\r\\n ax.plot(self.time[c], self.u[c][i_dof, :], label=label)\\r\\n ax.legend()\\r\\n title('Response of FF: %s' % (self.pfile.name))\\r\\n xlabel('Time (s)')\\r\\n fig.canvas.set_window_title('{0} {1}'.format(self.name, desc))\\r\\n show()\",\n \"def plot_all_LLRs(self, outdir):\\n\\t\\t#Iterate over all parameter groups\\n\\t\\tfor group in self.group_names:\\n\\t\\t\\tself.plot_group_LLR(groupname=group, outdir=outdir)\",\n \"def plot(filename):\\n\\tdata = np.load(filename)\\n\\tAlpha = data['ALPHA']\\n\\tCn = data['NFE']\\n\\tCf = data['FFE']\\n\\tP = data['PHINORM']\\n\\tSr = data['STABILITY']\\n\\tFlag = data['FLAG']\\n\\tIter = data['ITER']\\n\\tF = data['F']\\n\\tD = data['D']\\n\\tE = data['EPSILON']\\n\\tdelta = data['DELTA']\\n\\n\\t#auxiliary variables\\n\\tLogA = np.log10(Alpha)\\n\\tLogP = np.log10(P)\\n\\n\\tplt.rc('text', usetex=False)\\n\\tplt.rc('font', family='serif')\\n\\torient = 'vertical'\\n\\tXLABEL = r\\\"$d$\\\"\\n\\tYLABEL = r\\\"$\\\\epsilon$\\\"\\n\\t\\n\\tNd = D.shape[0]\\n\\tNepsilon = D.shape[1]\\n\\tN = Nd*Nepsilon\\n\\t\\n\\tD = np.reshape(D, (N, ))\\n\\tE = np.reshape(E, (N, ))\\n\\tSr = np.reshape(Sr, (N, ))\\n\\tLogA = np.reshape(LogA, (N, ))\\n\\tLogP = np.reshape(LogP, (N, ))\\n\\tG = np.sqrt(np.abs(F))/delta\\n\\tG = np.reshape(G, (N, ))\\n\\n\\tfig = plt.figure(1)\\n\\tax = fig.add_subplot(221, projection='3d')\\n\\tax.set_xlabel(XLABEL, fontsize=AXESFONTSIZE)\\n\\tax.set_ylabel(YLABEL, fontsize=AXESFONTSIZE)\\n\\tax.set_zlabel(r\\\"$\\\\log_{10}{\\\\alpha}$\\\", fontsize=AXESFONTSIZE)\\n\\tax.set_xlim3d(D.min(), D.max())\\n\\tax.set_ylim3d(E.min(), E.max())\\n\\tax.set_zlim3d(LogA.min(), LogA.max())\\n\\tsurf1 = ax.plot_trisurf(D, E, LogA, vmin=LogA.min(), vmax=LogA.max(), cmap=cm.jet, edgecolor='none')\\n\\tfig.colorbar(surf1, shrink=0.5, aspect=5, pad=0.05, orientation = orient)\\n\\n\\tax = fig.add_subplot(222, projection='3d')\\n\\tax.set_xlabel(XLABEL, fontsize=AXESFONTSIZE)\\n\\tax.set_ylabel(YLABEL, fontsize=AXESFONTSIZE)\\n\\tax.set_zlabel(\\\"\\\\n\\\" + r\\\"$\\\\log\\\\left(\\\\Vert \\\\phi\\\\Vert_{L^{2}(\\\\partial D_{a})} \\\\right)$\\\", fontsize=AXESFONTSIZE, linespacing=2)\\n\\tax.set_xlim3d(D.min(), D.max())\\n\\tax.set_ylim3d(E.min(), E.max())\\n\\tsurf2 = ax.plot_trisurf(D, E, LogP, cmap=cm.jet, vmin=LogP.min(), vmax=LogP.max(), edgecolor='none')\\n\\tfig.colorbar(surf2, shrink=0.5, aspect=5, pad=0.05, orientation = orient)\\n\\n\\tax = fig.add_subplot(223, projection='3d')\\n\\tax.set_xlabel(XLABEL, fontsize=AXESFONTSIZE)\\n\\tax.set_ylabel(YLABEL, fontsize=AXESFONTSIZE)\\n\\tax.set_zlabel(\\\"\\\\n\\\" + r\\\"$\\\\frac{\\\\Vert \\\\phi^{\\\\epsilon} - \\\\phi_{0}\\\\Vert}{\\\\Vert \\\\phi^{0}\\\\Vert}$\\\", fontsize=AXESFONTSIZE, linespacing=2)\\n\\tax.set_xlim3d(D.min(), D.max())\\n\\tax.set_ylim3d(E.min(), E.max())\\n\\tsurf3 = ax.plot_trisurf(D, E, Sr, cmap=cm.jet, vmin=Sr.min(), vmax=Sr.max(), edgecolor='none')\\n\\tfig.colorbar(surf3, shrink=0.5, aspect=5, pad=0.05, orientation = orient)\\n\\n\\tax = fig.add_subplot(224, projection='3d')\\n\\tax.set_xlabel(XLABEL, fontsize=AXESFONTSIZE)\\n\\tax.set_ylabel(YLABEL, fontsize=AXESFONTSIZE)\\n\\tax.set_zlabel(\\\"\\\\n\\\" + r\\\"$\\\\frac{\\\\sqrt{|F(\\\\alpha)|}}{\\\\delta}$\\\", fontsize=AXESFONTSIZE, linespacing=2)\\n\\tax.set_xlim3d(D.min(), D.max())\\n\\tax.set_ylim3d(E.min(), E.max())\\n\\tscatter4 = ax.scatter(D, E, G, c=G, s=5)\\n\\tfig.colorbar(scatter4, shrink=0.5, aspect=5, pad=0.05, orientation = orient)\\n\\tax.view_init(azim=-129, elev=20)\\n\\n\\tfig.subplots_adjust(left = 0.02, right = 0.98, wspace=0.05, hspace=0.05, top=0.95, bottom=0.05)\\n\\tplt.show()\",\n \"def plotGrid(parameters, plot_name):\\n\\n allNames = sorted(parameters)\\n combinations = it.product(*(parameters[Name] for Name in allNames))\\n\\n combs = [list(c) for c in list(combinations) ]\\n combs_df = pd.DataFrame(combs, columns=[\\\"criterion\\\", \\\"max_features\\\", \\\"n_estimators\\\"])\\n\\n trace = go.Scatter3d(\\n x=combs_df['criterion'],\\n y=combs_df['max_features'],\\n z=combs_df['n_estimators'],\\n mode='markers',\\n marker=dict(\\n size= 5,\\n color='green',\\n opacity=0.99,\\n colorscale='Viridis',\\n showscale=False\\n )\\n )\\n data = [trace]\\n layout = go.Layout(\\n margin=dict(\\n l=30,\\n r=30,\\n b=30,\\n t=30\\n ),\\n height=700,\\n width=960,\\n showlegend=True,\\n scene=dict(\\n xaxis=dict(\\n title='criterion',\\n nticks=10,\\n ),\\n yaxis=dict(\\n title='max_features',\\n nticks=10,\\n ),\\n zaxis=dict(\\n title='n_estimators',\\n nticks=10,\\n ),\\n camera=dict(\\n eye=dict(\\n y=2.089757339892154,\\n x=-0.5464711077183096,\\n z=0.14759264478960377,\\n )\\n ),\\n ),\\n )\\n\\n fig = go.Figure(data=data, layout=layout)\\n fig.show()\\n fig.write_image(plot_name)\\n fig.write_html(script_path + \\\"/results/GridSearchPlot.html\\\")\",\n \"def plot_specific_forward_model_result(real_data_array, synth_forward_model_result_array, data_labels, plot_title=\\\"\\\", perform_normallised_waveform_inversion=True):\\n fig, axarr = plt.subplots(len(real_data_array[:,0]), sharex=True)\\n for i in range(len(axarr)):\\n if perform_normallised_waveform_inversion:\\n axarr[i].plot(real_data_array[i,:]/np.max(np.absolute(real_data_array[i,:])),c='k', alpha=0.6) # Plot real data\\n axarr[i].plot(synth_forward_model_result_array[i,:]/np.max(np.absolute(synth_forward_model_result_array[i,:])),c='r',linestyle=\\\"--\\\", alpha=0.6) # Plot synth data\\n else:\\n axarr[i].plot(real_data_array[i,:],c='k', alpha=0.6) # Plot real data\\n axarr[i].plot(synth_forward_model_result_array[i,:],c='r',linestyle=\\\"--\\\", alpha=0.6) # Plot synth data\\n axarr[i].set_title(data_labels[i])\\n plt.suptitle(plot_title)\\n plt.show()\",\n \"def plotMSSpectra3D(listOfFilesToPlot, listOfNames=None, listOfColors=None, gridLines=False, yMin=0.5, yMax=2.5, yScale = 1.0,\\r\\n legend=True, normalizeToN15=False, subtractRef=None, legendLoc=4, lw=1.5, xMin=0, xMax=2000, scaleP=False, scaleI=0, scaleVal=1.0,\\r\\n figsize=(10,10), tLeft=0, tRight=-1, fixedOffset=False, noTicks=False, xlabel='mass', zlabel='intensity', a14=1.0): \\r\\n if listOfNames==None:\\r\\n listOfNames = listOfFilesToPlot\\r\\n if listOfColors==None:\\r\\n listOfColors = [pylab.cm.jet(float(i)/float(len(listOfFilesToPlot))) for i in range(len(listOfFilesToPlot))]\\r\\n \\r\\n fig = pylab.figure(figsize=figsize)\\r\\n ax = fig.add_subplot(111, projection='3d')\\r\\n\\r\\n yTotal = len(listOfFilesToPlot)\\r\\n top = 0.0\\r\\n\\r\\n if not (subtractRef is None):\\r\\n [bhah, zsRef, blah] = qMS.readMSSpectraFile(listOfFilesToPlot[subtractRef])\\r\\n #zsRef = list(numpy.array(zsRef)-fixedOffset\\r\\n zNorm = max(zsRef[len(zsRef)/2:])\\r\\n zsRef = numpy.array(zsRef)/zNorm\\r\\n \\r\\n for i,f in enumerate(listOfFilesToPlot):\\r\\n [xs, zs, name] = qMS.readMSSpectraFile(f)\\r\\n if fixedOffset:\\r\\n off = zs[len(zs)/2]\\r\\n print off\\r\\n #zs = list(numpy.array(zs)-zs[len(zs)/2])\\r\\n zs = list(numpy.array(zs)-off)\\r\\n ys = [yTotal-i]*len(xs)\\r\\n ys = numpy.array(ys)*yScale\\r\\n if normalizeToN15:\\r\\n zNorm = max(zs[len(zs)/2:])\\r\\n zs = numpy.array(zs)/zNorm\\r\\n if not (subtractRef is None):\\r\\n zNorm = max(zs[len(zs)/2:])\\r\\n zs = numpy.array(zs)/zNorm\\r\\n zs[:len(zsRef)/2] = zs[:len(zs)/2]-zsRef[:len(zsRef)/2]\\r\\n zs = zs*zNorm\\r\\n #xs = xs[:len(xs)/2]\\r\\n #ys = ys[:len(ys)/2]\\r\\n #zs = zs[:len(zs)/2]\\r\\n zs[:len(zs)/2] = numpy.array(zs[:len(zs)/2])*a14\\r\\n if (scaleP is True) and (i==scaleI):\\r\\n zs = numpy.array(zs)*scaleVal\\r\\n ax.plot(numpy.array(xs[tLeft:tRight]),numpy.array(ys[tLeft:tRight]),numpy.array(zs[tLeft:tRight]), color=listOfColors[i], lw=lw, label=listOfNames[i])\\r\\n top = max([top, float(max(zs))])\\r\\n\\r\\n\\r\\n ax.w_xaxis.pane.set_visible(False)\\r\\n ax.w_yaxis.pane.set_visible(False)\\r\\n ax.w_zaxis.pane.set_visible(False)\\r\\n\\r\\n if gridLines: \\r\\n ax.w_xaxis.gridlines.set_linewidth(1)\\r\\n ax.w_yaxis.gridlines.set_linewidth(1)\\r\\n ax.w_zaxis.gridlines.set_linewidth(1)\\r\\n \\r\\n else:\\r\\n ax.w_xaxis.gridlines.set_visible(False)\\r\\n ax.w_yaxis.gridlines.set_visible(False)\\r\\n ax.w_zaxis.gridlines.set_visible(False)\\r\\n\\r\\n [i.set_linewidth(1) for i in ax.w_xaxis.get_ticklines()]\\r\\n [i.set_linewidth(1) for i in ax.w_yaxis.get_ticklines()]\\r\\n [i.set_linewidth(1) for i in ax.w_zaxis.get_ticklines()]\\r\\n\\r\\n ax.w_xaxis.line.set_linewidth(1)\\r\\n ax.w_yaxis.line.set_linewidth(1)\\r\\n ax.w_zaxis.line.set_linewidth(1)\\r\\n \\r\\n ax.set_zticks([round(i,1) for i in [0, top/3, 2*top/3, top]])\\r\\n ax.set_zlim3d([0, top])\\r\\n ax.set_ylim3d(yMin, yMax)\\r\\n ax.set_yticks(range(1,yTotal+1))\\r\\n pylab.yticks(range(1,yTotal+1), ['']*yTotal)\\r\\n ax.set_xlim3d([xMin, xMax])\\r\\n \\r\\n if noTicks:\\r\\n ax.set_zticks([])\\r\\n ax.set_xticks([])\\r\\n ax.set_yticks([])\\r\\n\\r\\n ax.set_xlabel(xlabel)\\r\\n ax.set_zlabel(zlabel)\\r\\n\\r\\n ax.view_init(15, -60)\\r\\n if legend:\\r\\n pylab.legend(loc=legendLoc)\\r\\n \\r\\n pylab.tight_layout()\\r\\n return ax\",\n \"def plot_profiles(self, parameters, fig=1):\\n # Make sure the parameters are a list\\n if isinstance(parameters, str) or isinstance(parameters, unicode):\\n parameters = [parameters]\\n \\n # Decide how many subplots to create\\n nrows = int(len(parameters) / 3)\\n if len(parameters) % 3 > 0:\\n nrows += 1\\n \\n # Initialize a figure for plotting\\n width = 8\\n height = 4 * nrows\\n plt.figure(fig, figsize=(width, height))\\n plt.clf()\\n \\n # Plot each parameter\\n for parm in parameters:\\n ax = plt.subplot(nrows, 3, parameters.index(parm)+1)\\n self.plot_parameter(parm)\\n \\n plt.tight_layout()\\n \\n plt.show()\",\n \"def plot_source_residuals_comparison(source_truth, source_model_list, name_list, \\n vmin_res=-0.5, vmax_res=-0.5, cmap='cubehelix',\\n fontsize=12):\\n n_model = len(source_model_list)\\n fig, axes = plt.subplots(1+n_model, 2, figsize=(9, (1+n_model)*3.5))\\n axes[0, 1].axis('off')\\n ax = axes[0, 0]\\n #ax.get_xaxis().set_visible(False)\\n #ax.get_yaxis().set_visible(False)\\n ax.set_title(\\\"true source\\\", fontsize=fontsize)\\n im = ax.imshow(source_truth, cmap=cmap, vmin=0)\\n lims = (len(source_truth)/4, 3*len(source_truth)/4) # zoom a bit on the image\\n #ax.set_xlim(*lims)\\n #ax.set_ylim(*lims)\\n plot_util.nice_colorbar(im, label=\\\"flux\\\", fontsize=fontsize)\\n \\n i = 1\\n for source_model, name in zip(source_model_list, name_list):\\n print(\\\"min/max for source model '{}': {}/{}\\\".format(name, source_model.min(), source_model.max()))\\n\\n residuals_source = source_model - source_truth\\n\\n ax = axes[i, 0]\\n ax.set_title(\\\"model '{}'\\\".format(name), fontsize=fontsize)\\n #ax.get_xaxis().set_visible(False)\\n #ax.get_yaxis().set_visible(False)\\n im = ax.imshow(source_model, cmap=cmap)\\n #ax.set_xlim(*lims)\\n #ax.set_ylim(*lims)\\n plot_util.nice_colorbar(im, label=\\\"flux\\\", fontsize=fontsize)\\n \\n ax = axes[i, 1]\\n #ax.get_xaxis().set_visible(False)\\n #ax.get_yaxis().set_visible(False)\\n ax.set_title(\\\"difference\\\", fontsize=fontsize)\\n #ax.set_xlim(*lims)\\n #ax.set_ylim(*lims)\\n im = ax.imshow(residuals_source, cmap='RdBu_r', vmin=vmin_res, vmax=vmax_res)\\n plot_util.nice_colorbar_residuals(im, residuals_source, vmin_res, vmax_res,\\n label=r\\\"f${}_{\\\\rm model}$ - f${}_{\\\\rm truth}$\\\", fontsize=fontsize)\\n \\n print(\\\"SDR for model '{}' = {:.3f}\\\".format(name, metrics_util.SDR(source_truth, source_model)))\\n i += 1\\n\\n return fig\",\n \"def plot_fit_results(tool):\\n fig, ax = plt.subplots()\\n\\n model_meyer_ref = CrabSpectrum(\\\"meyer\\\").model\\n model_meyer_ref.plot(\\n [10 * u.GeV, 100 * u.TeV],\\n energy_power=2,\\n flux_unit=\\\"erg-1 cm-2 s-1\\\",\\n ls=\\\":\\\",\\n lw=2.2,\\n color=\\\"#555555\\\",\\n label=\\\"Meyer et al. (2010)\\\",\\n )\\n\\n # where to take the results, configurations for the individual butterflies\\n instruments = [\\\"fermi\\\", \\\"magic\\\", \\\"veritas\\\", \\\"fact\\\", \\\"hess\\\", \\\"joint\\\"]\\n labels = [\\\"Fermi-LAT\\\", \\\"MAGIC\\\", \\\"VERITAS\\\", \\\"FACT\\\", \\\"H.E.S.S.\\\", \\\"joint fit\\\"]\\n lss = [\\\"--\\\", \\\"--\\\", \\\"--\\\", \\\"--\\\", \\\"--\\\", \\\"-\\\"]\\n colors = COLORS\\n # with one loop we realize all the butterfly plots\\n for instrument, label, color, ls in zip(instruments, labels, colors, lss):\\n\\n path = (\\n config.repo_path\\n / f\\\"results/fit/{tool}/{instrument}/fit_results_logparabola.yaml\\\"\\n )\\n\\n if not path.exists():\\n log.warning(f\\\"Missing: {path} . Skipping.\\\")\\n continue\\n\\n results = load_yaml(path)\\n parameters = results[\\\"parameters\\\"]\\n\\n model_lp = LogParabola.from_log10(\\n amplitude=parameters[0][\\\"value\\\"] * u.Unit(parameters[0][\\\"unit\\\"]),\\n reference=parameters[1][\\\"value\\\"] * u.Unit(parameters[1][\\\"unit\\\"]),\\n alpha=parameters[2][\\\"value\\\"] * u.Unit(parameters[2][\\\"unit\\\"]),\\n beta=parameters[3][\\\"value\\\"] * u.Unit(parameters[3][\\\"unit\\\"]),\\n )\\n\\n # energy range for the plot\\n dataset = config.get_dataset(instrument)\\n energy_range = dataset.energy_range\\n\\n # just in case of the joint fit put a thicker line and a less transparent butterfly\\n if instrument == \\\"joint\\\":\\n model_lp.plot(\\n energy_range,\\n energy_power=2,\\n flux_unit=\\\"erg-1 cm-2 s-1\\\",\\n ls=ls,\\n lw=3,\\n color=color,\\n label=label,\\n )\\n else:\\n model_lp.plot(\\n energy_range,\\n energy_power=2,\\n flux_unit=\\\"erg-1 cm-2 s-1\\\",\\n ls=ls,\\n lw=2.2,\\n color=color,\\n label=label,\\n )\\n\\n # read the butterfly from the multivariate sampling results\\n table_path = Path(\\n f\\\"{config.repo_path}/results/figures/stat_err/{instrument}_flux_errorband.dat\\\"\\n )\\n log.info(f\\\"reading butterfly values from {table_path}\\\")\\n t = Table.read(table_path, format=\\\"ascii.ecsv\\\")\\n energies = t[\\\"energies\\\"].data * t[\\\"energies\\\"].unit\\n flux_lo = t[\\\"flux_lo\\\"].data * t[\\\"flux_lo\\\"].unit\\n flux_hi = t[\\\"flux_hi\\\"].data * t[\\\"flux_hi\\\"].unit\\n\\n if instrument == \\\"joint\\\":\\n alpha = 0.38\\n else:\\n alpha = 0.28\\n\\n plt.fill_between(\\n energies.to(\\\"TeV\\\"),\\n (energies ** 2 * flux_lo).to(\\\"erg cm-2 s-1\\\"),\\n (energies ** 2 * flux_hi).to(\\\"erg cm-2 s-1\\\"),\\n color=color,\\n alpha=alpha,\\n label=\\\"\\\",\\n )\\n\\n ax.legend(fontsize=FONTSIZE)\\n ax.set_ylim([1e-12, 2e-10])\\n\\n ax.set_xlabel(E_UNIT_LABEL, size=FONTSIZE)\\n ax.set_ylabel(SED_UNIT_LABEL, size=FONTSIZE)\\n # make axis thicker\\n for axis in [\\\"top\\\", \\\"bottom\\\", \\\"left\\\", \\\"right\\\"]:\\n ax.spines[axis].set_linewidth(1.6)\\n ax.tick_params(\\\"both\\\", length=7, width=1.6, which=\\\"major\\\", labelsize=FONTSIZE)\\n ax.tick_params(\\\"both\\\", length=4, width=1.6, which=\\\"minor\\\", labelsize=FONTSIZE)\\n\\n plt.tight_layout()\\n\\n filename = f\\\"results/figures/crab_sed_{tool}_fit.png\\\"\\n filename_pdf = f\\\"results/figures/crab_sed_{tool}_fit.pdf\\\"\\n log.info(f\\\"Writing {filename}\\\")\\n fig.savefig(filename)\\n fig.savefig(filename_pdf)\",\n \"def plot_results(self, a):\\n import matplotlib.pyplot as plt\\n fig, axes = plt.subplots(nrows=len(a.data_vars), sharex='all', sharey='all')\\n for ax, var in zip(axes, a.data_vars):\\n data = a[var]\\n plt.sca(ax)\\n data.plot(x='time', cmap=plt.cm.viridis_r, yincrease=False, robust=True)\\n plt.show()\",\n \"def plot_model(model, inputs, outputs, tss=90):\\n mdl = np.load(model)\\n sys = ss(mdl['A'], mdl['B'], mdl['C'], mdl['D'],1)\\n gain_matrix = dcgain(sys).T\\n num_i = len(inputs)\\n num_o = len(outputs)\\n fig, axs = plt.subplots(num_i,num_o, figsize=(3*len(outputs), 2*len(inputs)), facecolor='w', edgecolor='k')\\n fig.suptitle('Step responce: '+model)\\n T = np.arange(tss)\\n for idx_i in range(num_i):\\n for idx_o in range(num_o):\\n ax = axs[idx_i][idx_o]\\n t,y_step = step_response(sys,T, input=idx_i, output=idx_o)\\n gain = round(gain_matrix[idx_i][idx_o],4)\\n ax.plot(t, y_step,color='r')\\n if idx_i == 0:\\n ax.set_title(outputs[idx_o], rotation='horizontal', ha='center', fontsize=10)\\n if idx_o == 0:\\n ax.set_ylabel(inputs[idx_i], rotation=90, fontsize=10)\\n ax.grid(color='k', linestyle='--', linewidth=0.5)\\n ax.tick_params(axis='x', colors='red',size=0,labelsize=4)\\n ax.tick_params(axis='y', colors='red',size=0,labelsize=4)\\n ax.annotate(str(gain),xy=(.72,.8),xycoords='axes fraction')\\n # fig.tight_layout()\\n plt.show()\",\n \"def fdd_plot(result_file_list,default_fdds,ion_default):\\n # Getting data from the file\\n fdd_param_keys = [result_file.split('_')[0] for result_file in result_file_list]\\n# print \\\" Parameters to plot for:\\\", fdd_param_keys\\n fig = plt.figure(figsize=(14,12))#(8.27,11.69))\\n axs = [None]*(len(result_file_list)*5 + 1) # List of axes: 2 ions x (1 uncert + 1 value) + 1 for iterations (axs[0] will not be used)\\n for j,result_file_name in enumerate(result_file_list):\\n with open(result_file_name,'r') as res_file:\\n res_data = res_file.read().split('\\\\n')\\n if res_data[-1] == \\\"\\\": # delete empty line if present\\n del res_data[-1]\\n else:\\n pass\\n fdd_list, H_list, Hunc_list, D_list, Dunc_list, n_iter_list,fdd_iter_list = [[] for i in range(7)]\\n for line in res_data:\\n line_split = line.split()\\n if line_split[1] == '0' or line_split[1] == '-1':\\n fdd_list.append(float(line_split[0].split('_')[-1])) # fdd_list\\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\\n if line_split[1] == '0':\\n n_iter_list.append(int(line_split[2])) # number of iterations list\\n else:\\n n_iter_list.append(-1) # 125, number of iterations\\n H_list.append(float(line_split[3])) # H_list\\n Hunc_list.append(float(line_split[4])) # Hunc_list\\n D_list.append(float(line_split[5])) # D_list\\n Dunc_list.append(float(line_split[6])) # Dunc_list\\n elif line_split[1] == '1':\\n print \\\" {} = {} <- excluded: error '1' (no f26 file was found, check 'stdout.dat' and 'stderr.dat')\\\".format(fdd_param_keys[j], line_split[0])\\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\\n n_iter_list.append(0) # number of iterations list\\n elif line_split[1] == '2':\\n print \\\" {} = {} <- excluded: error '2' (error happened during VPFITing, check 'stderr.dat')\\\".format(fdd_param_keys[j], line_split[0])\\n\\t\\tfdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\\n\\t\\tn_iter_list.append(0) # number of iterations list\\n elif line_split[1] == '3':\\n print \\\" {} = {} <- excluded: error '3' (zero size f26 file, check 'stdout.dat')\\\".format(fdd_param_keys[j], line_split[0])\\n\\t\\tfdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\\n\\t\\tn_iter_list.append(0) # number of iterations list\\n elif line_split[1] == '4':\\n print \\\" {} = {} <- excluded: error '4' (new and original f26's have different number of lines, check 'stdout.dat')\\\".format(fdd_param_keys[j], line_split[0])\\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\\n\\t\\tn_iter_list.append(-3) # number of iterations list\\n elif line_split[1] == '5':\\n print \\\" {} = {} <- excluded: error '5' ('****' uncertainty was found for one of specified ion! Check f26 file)\\\".format(fdd_param_keys[j], line_split[0])\\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\\n\\t\\tn_iter_list.append(-2) # number of iterations list\\n else:\\n print \\\" Unknown error code was specified in {}\\\".format(result_file_name)\\n\\n # Data are ready to plot\\n # First column of subplots (uncertainties)\\n axs[5*j+1] = plt.subplot(len(fdd_param_keys),3,3*j+1)\\n axs[5*j+1].plot(fdd_list,Dunc_list,color='b',drawstyle=\\\"steps-mid\\\") # Plotting data\\n axs[5*j+1].plot(default_fdds[fdd_param_keys[j]],ion_default[3],'bo',mew=0.0) # plotting default result\\n axs[5*j+1].set_ylabel(r'$\\\\Delta$N(D I)',color='b')\\n axs[5*j+1].tick_params('y',colors='b')\\n axs[5*j+1].ticklabel_format(useOffset=False)\\n axs[5*j+1].set_xscale('log')\\n if fdd_param_keys[j] == 'fdbstep':\\n axs[5*j+1].set_xlabel('{} [{:g}], km/s'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\\n else:\\n axs[5*j+1].set_xlabel('{} [{:g}]'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\\n axs[5*j+1].axvline(default_fdds[fdd_param_keys[j]],linewidth=1,color='g') # indicate fdd from vp_setup.dat\\n# axs[5*j+1].margins(y=np.ptp(Dunc_list)/2.0) # Include marging above and below the data to show default fdds\\n axs[5*j+2] = axs[5*j+1].twinx() # second plot on the same axis\\n axs[5*j+2].plot(fdd_list,Hunc_list,color='r',drawstyle=\\\"steps-mid\\\")\\n axs[5*j+2].plot(default_fdds[fdd_param_keys[j]],ion_default[1],'ro',mew=0.0)\\n axs[5*j+2].set_ylabel(r'$\\\\Delta$N(H I)',color='r')\\n axs[5*j+2].tick_params('y',colors='r')\\n axs[5*j+2].ticklabel_format(useOffset=False,axis='y')\\n # Second column of subplots (middle values)\\n axs[5*j+3] = plt.subplot(len(fdd_param_keys),3,3*j+2)\\n plot_interal = False # Add 1-sigma interval\\n if plot_interal == True:\\n median = np.median(D_list)\\n med_unc = np.median(Dunc_list)\\n print \\\"median = {} +/- {} for {}\\\".format(median,med_unc,fdd_param_keys[j])\\n axs[5*j+3].fill_between(fdd_list, median-med_unc, median+med_unc,facecolor='green', alpha=0.4)\\n axs[5*j+3].plot(fdd_list,D_list,color='b',drawstyle=\\\"steps-mid\\\",zorder=2) # Plotting data\\n axs[5*j+3].plot(default_fdds[fdd_param_keys[j]],ion_default[2],'bo',zorder=10,mew=0.0)\\n axs[5*j+3].set_ylabel(r'N(D I)',color='b')\\n axs[5*j+3].ticklabel_format(useOffset=False)\\n axs[5*j+3].tick_params('y',colors='b')\\n axs[5*j+3].set_xscale('log')\\n if fdd_param_keys[j] == 'fdbstep':\\n axs[5*j+3].set_xlabel('{} [{:g}], km/s'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\\n else:\\n axs[5*j+3].set_xlabel('{} [{:g}]'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\\n axs[5*j+3].axvline(default_fdds[fdd_param_keys[j]],linewidth=1,color='g') # indicate fdd from vp_setup.dat\\n# axs[5*j+3].margins(y=np.ptp(D_list),tight=False) # Include marging above and below the data to show default fdds\\n axs[5*j+4] = axs[5*j+3].twinx()\\n axs[5*j+4].plot(fdd_list,H_list,color='r',drawstyle=\\\"steps-mid\\\",zorder=1)\\n axs[5*j+4].plot(default_fdds[fdd_param_keys[j]],ion_default[0],'ro',zorder=10,mew=0.0)\\n axs[5*j+4].set_ylabel(r'N(H I)',color='r')\\n axs[5*j+4].tick_params('y',colors='r')\\n axs[5*j+4].ticklabel_format(useOffset=False,axis='y')\\n # Third column of subplots (number of iterations)\\n axs[5*j+5] = plt.subplot(len(fdd_param_keys),3,3*j+3)\\n axs[5*j+5].plot(fdd_iter_list,n_iter_list,drawstyle=\\\"steps-mid\\\") # Plotting n_iter_list\\n# axs[5*j+5].yaxis.tick_right()\\n# axs[5*j+5].yaxis.set_label_position(\\\"right\\\")\\n axs[5*j+5].set_ylabel('N iterations')\\n axs[5*j+5].ticklabel_format(useOffset=False)\\n axs[5*j+5].set_xscale('log')\\n if fdd_param_keys[j] == 'fdbstep':\\n axs[5*j+5].set_xlabel('{} [{:g}], km/s'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\\n else:\\n axs[5*j+5].set_xlabel('{} [{:g}]'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\\n axs[5*j+5].axvline(default_fdds[fdd_param_keys[j]],linewidth=1,color='g') # indicate fdd from vp_setup.dat\\n axs[5*j+5].axhline(0,linewidth=1,color='grey',ls=\\\":\\\") # indicate fdd from vp_setup.dat\\n\\n# plt.tight_layout()\\n fig.subplots_adjust(hspace=0.3,wspace=0.9) # Set up spaces between subplots\\n plt.savefig(\\\"fdd_plot.pdf\\\",bbox_inches='tight', pad_inches=0)\\n plt.show()\\n plt.close()\\n print \\\" Plot is done!\\\"\",\n \"def plotFittingResults(self):\\n _listFitQ = [tmp.getValue() for tmp in self.getDataOutput().getScatteringFitQ()]\\n _listFitValues = [tmp.getValue() for tmp in self.getDataOutput().getScatteringFitValues()]\\n _listExpQ = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataQ()]\\n _listExpValues = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataValues()]\\n\\n #_listExpStdDev = None\\n #if self.getDataInput().getExperimentalDataStdDev():\\n # _listExpStdDev = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataStdDev()]\\n #if _listExpStdDev:\\n # pylab.errorbar(_listExpQ, _listExpValues, yerr=_listExpStdDev, linestyle='None', marker='o', markersize=1, label=\\\"Experimental Data\\\")\\n # pylab.gca().set_yscale(\\\"log\\\", nonposy='clip')\\n #else: \\n # pylab.semilogy(_listExpQ, _listExpValues, linestyle='None', marker='o', markersize=5, label=\\\"Experimental Data\\\")\\n\\n pylab.semilogy(_listExpQ, _listExpValues, linestyle='None', marker='o', markersize=5, label=\\\"Experimental Data\\\")\\n pylab.semilogy(_listFitQ, _listFitValues, label=\\\"Fitting curve\\\")\\n pylab.xlabel('q')\\n pylab.ylabel('I(q)')\\n pylab.suptitle(\\\"RMax : %3.2f. Fit quality : %1.3f\\\" % (self.getDataInput().getRMax().getValue(), self.getDataOutput().getFitQuality().getValue()))\\n pylab.legend()\\n pylab.savefig(os.path.join(self.getWorkingDirectory(), \\\"gnomFittingResults.png\\\"))\\n pylab.clf()\",\n \"def plot_results(\\n data,\\n xparam,\\n yparam,\\n pxrange=None,\\n pyrange=None,\\n data_comp=None,\\n data_bohlin=None,\\n figsize=None,\\n alpha=0.25,\\n):\\n # set the plotting defaults\\n set_params(lw=2, fontsize=22)\\n\\n fig, ax = plt.subplots(figsize=figsize)\\n\\n if data_bohlin is not None:\\n if (xparam in data_bohlin.colnames) and (yparam in data_bohlin.colnames):\\n xcol = data_bohlin[xparam]\\n xcol_unc = get_unc(xparam, data_bohlin)\\n ycol = data_bohlin[yparam]\\n ycol_unc = get_unc(yparam, data_bohlin)\\n ax.errorbar(\\n xcol,\\n ycol,\\n xerr=xcol_unc,\\n yerr=ycol_unc,\\n fmt=\\\"ro\\\",\\n label=\\\"Bohlin (1978)\\\",\\n alpha=alpha,\\n )\\n if data_comp is not None:\\n xcol = data_comp[xparam]\\n xcol_unc = get_unc(xparam, data_comp)\\n ycol = data_comp[yparam]\\n ycol_unc = get_unc(yparam, data_comp)\\n # ax.errorbar(xcol, ycol, xerr=xcol_unc, yerr=ycol_unc,\\n # fmt='go', label='FUSE Comparisons', alpha=0.25)\\n ax.plot(xcol, ycol, \\\"go\\\")\\n # plot the error bars as ellipses illustrating the covariance\\n corrs = get_corr(\\n xparam,\\n yparam,\\n xcol,\\n ycol,\\n xcol_unc,\\n ycol_unc,\\n cterm=data_comp[\\\"AV\\\"].data,\\n cterm_unc=data_comp[\\\"AV_unc\\\"].data,\\n )\\n plot_errorbar_corr(\\n ax, xcol, ycol, xcol_unc, ycol_unc, corrs, alpha=alpha, pcol=\\\"g\\\"\\n )\\n\\n xcol = data[xparam].data\\n xcol_unc = get_unc(xparam, data)\\n ycol = data[yparam].data\\n ycol_unc = get_unc(yparam, data)\\n # ax.errorbar(xcol, ycol, xerr=xcol_unc, yerr=ycol_unc,\\n # fmt='bo', label='FUSE Reddened', alpha=0.25)\\n ax.plot(xcol, ycol, \\\"bo\\\")\\n\\n # plot the error bars as ellipses illustrating the covariance\\n if yparam[0:3] == \\\"CAV\\\":\\n cparam = \\\"AV\\\"\\n elif yparam[0:1] == \\\"C\\\":\\n cparam = \\\"EBV\\\"\\n else:\\n cparam = \\\"AV\\\"\\n\\n corrs = get_corr(\\n xparam,\\n yparam,\\n xcol,\\n ycol,\\n xcol_unc,\\n ycol_unc,\\n cterm=data[cparam].data,\\n cterm_unc=data[cparam + \\\"_unc\\\"].data,\\n )\\n plot_errorbar_corr(\\n ax, xcol, ycol, xcol_unc, ycol_unc, corrs, alpha=alpha, pcol=\\\"b\\\", pellipse=True\\n )\\n\\n ax.set_xlabel(format_colname(xparam))\\n ax.set_ylabel(format_colname(yparam))\\n\\n # fit a line\\n # params = np.polyfit(xcol, ycol, 1) # , w=1.0/ycol_unc)\\n # line_init = models.Polynomial1D(1)\\n line_init = models.Linear1D()\\n fit = fitting.LinearLSQFitter()\\n # fitter with outlier rejection\\n or_fit = fitting.FittingWithOutlierRemoval(fit, sigma_clip, niter=3, sigma=3.0)\\n\\n # fit the data w/o weights\\n fitted_model = fit(line_init, xcol, ycol)\\n print(fitted_model)\\n\\n # fit the data using the uncertainties as weights\\n fitted_model_weights = fit(line_init, xcol, ycol, weights=1.0 / ycol_unc)\\n\\n # fit the data using the uncertainties as weights\\n fitted_model_weights_sc, mask_sc = or_fit(line_init, xcol, ycol, weights=1.0 / ycol_unc)\\n data_sc = np.ma.masked_array(ycol, mask=mask_sc)\\n\\n # print(\\\"linear fit params [slope, y-intercept]\\\")\\n # print(params)\\n xlim = ax.get_xlim()\\n x_mod = np.linspace(xlim[0], xlim[1])\\n # y_mod = params[1] + x_mod * params[0]\\n # ax.plot(x_mod, y_mod, \\\"k--\\\")\\n\\n ax.plot(x_mod, fitted_model(x_mod), \\\"k-\\\")\\n ax.plot(x_mod, fitted_model_weights(x_mod), \\\"k--\\\")\\n ax.plot(x_mod, fitted_model_weights_sc(x_mod), \\\"k.\\\")\\n\\n ax.plot(xcol, data_sc, 'ko')\\n print(data_sc)\\n\\n if pxrange is not None:\\n ax.set_xlim(pxrange)\\n if pyrange is not None:\\n ax.set_ylim(pyrange)\\n\\n return fig\",\n \"def P_AI_Rocky2(in_dict):\\n # START\\n fs = 16\\n plt.rc('font', size=fs)\\n fig = plt.figure(figsize=(8,12))\\n ds = nc.Dataset(in_dict['fn'])\\n\\n # PLOT CODE\\n aa = [-122.8, -122.54, 47.92, 48.22]\\n # import cmocean\\n # cmap = cmocean.cm.speed\\n # cmap = 'RdYlBu_r'\\n cmap = 'Spectral_r'\\n\\n from warnings import filterwarnings\\n filterwarnings('ignore') # skip some warning messages\\n \\n # plot Code\\n \\n # calculate speed\\n uu = ds['u'][0, -1, :, :]\\n vv = ds['v'][0, -1, :, :]\\n u = zfun.fillit(uu)\\n v = zfun.fillit(vv)\\n u[np.isnan(u)] = 0\\n v[np.isnan(v)] = 0\\n # interpolate to the clipped rho grid\\n ur = (u[1:-1,1:] + u[1:-1,:-1])/2\\n vr = (v[1:,1:-1] + v[:-1,1:-1])/2\\n spd = np.sqrt(ur**2 + vr**2)\\n spd[spd==0] = np.nan\\n \\n G = zrfun.get_basic_info(in_dict['fn'], only_G=True)\\n \\n # panel 1\\n ax = fig.add_subplot(111)\\n cs = plt.pcolormesh(G['lon_psi'], G['lat_psi'], spd, cmap=cmap,\\n vmin=0, vmax=1.5)\\n tstr = (r'Admiralty Inlet Surface Speed ($m\\\\ s^{-1}$)')\\n #pfun.add_bathy_contours(ax, ds, txt=True)\\n pfun.add_coast(ax)\\n ax.axis(aa)\\n pfun.dar(ax)\\n ax.set_xlabel('Longitude')\\n ax.set_ylabel('Latitude')\\n ax.set_title(tstr)\\n pfun.add_info(ax, in_dict['fn'])\\n ax.set_xticks([-122.8, -122.7, -122.6])\\n ax.set_yticks([48, 48.1, 48.2])\\n \\n # Inset colorbar\\n from mpl_toolkits.axes_grid1.inset_locator import inset_axes\\n cbaxes = inset_axes(ax, width=\\\"4%\\\", height=\\\"30%\\\", loc='upper right', borderpad=3)\\n fig.colorbar(cs, cax=cbaxes, orientation='vertical')\\n \\n #pfun.add_bathy_contours(ax, ds)\\n pfun.add_coast(ax)\\n ax.axis(aa)\\n pfun.dar(ax)\\n ax.set_xlabel('Longitude')\\n ax.set_title(tstr)\\n \\n pfun.add_velocity_vectors(ax, ds, in_dict['fn'], v_scl=100, v_leglen=1,\\n nngrid=80, zlev='top', center=(.1,.05))\\n \\n fig.tight_layout()\\n # FINISH\\n ds.close()\\n if len(in_dict['fn_out']) > 0:\\n plt.savefig(in_dict['fn_out'])\\n plt.close()\\n else:\\n plt.show()\\n plt.rcdefaults()\",\n \"def plot_run_basic():\\n # Define files prefix, model variables to plot and title\\n str_learning_rate = ['lr_', 'learning_rate', 'Learning rate', 'LR']\\n str_f_number = ['f_', 'F', 'Filter number', 'F']\\n str_regular = ['reg_param_', 'reg_par', 'Regularization', 'RP']\\n\\n fig = plt.figure(figsize=(16,12))\\n # Plot learning rate\\n acc_span, acc_tot, setting_val = CNN.get_acc_run_basic(str_learning_rate[0], str_learning_rate[1])\\n CNN.subplot_run_basic(acc_span, acc_tot, setting_val, str_learning_rate[2], str_learning_rate[3], [2,2,1])\\n # Plot F number\\n acc_span, acc_tot, setting_val = CNN.get_acc_run_basic(str_f_number[0], str_f_number[1])\\n CNN.subplot_run_basic(acc_span, acc_tot, setting_val, str_f_number[2], str_f_number[3], [2,2,2])\\n # Plot Regularization\\n acc_span, acc_tot, setting_val = CNN.get_acc_run_basic(str_regular[0], str_regular[1])\\n CNN.subplot_run_basic(acc_span, acc_tot, setting_val, str_regular[2], str_regular[3], [2,2,3])\\n plt.suptitle('Validation accuracy - Sweep parameters', fontsize=20)\\n plt.show();\\n \\n # Save as PDF file if wanted\\n if DataLoader.SAVE_FIGURE:\\n DataLoader.save_plot(fig, 'sweep_parameters_CNN.pdf')\",\n \"def plotResults(times, result, args, calculate_nT = True, order_SD = False, nSkipp = 1, showProgress = False):\\n t1 = time.time()\\n times = times[::nSkipp]\\n\\n if 'omegaArgs' in args:\\n wList = args['omega'](times, args['omegaArgs'])\\n fList = args['f0']/wList**2 - args['f0']/args['omegaArgs'][0]**2\\n else:\\n wList = args['omega'](times, args)\\n fList = args['f0']/wList**2 - args['f0']/args['w0']**2\\n\\n masterList = [[],[],[],[]]\\n nStates = len(result.states[::nSkipp])\\n progress = 0\\n for psi in result.states[::nSkipp]:\\n alpha, xi, nBar, nT = getParams(psi, calculate_nT = calculate_nT, order_SD = order_SD)\\n masterList[0].append(np.abs(alpha))\\n masterList[1].append(np.abs(xi))\\n masterList[2].append(nBar)\\n masterList[3].append(nT)\\n if showProgress:\\n progress += 1\\n print('\\\\r', \\\"Progress:\\\", round(100*progress/nStates), \\\"%, processing time:\\\", round(time.time() - t1), \\\"s\\\", end = '')\\n\\n fig, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(5)\\n fig.set_size_inches(15.5, 7.5, forward=True)\\n ax1.plot(times, masterList[0], label = r'$|\\\\alpha |$')\\n ax1.legend()\\n ax2.plot(times, masterList[1], label = \\\"r\\\")\\n ax2.legend()\\n ax3.plot(times, masterList[2], label = \\\"nBar\\\")\\n if calculate_nT:\\n ax3.plot(times, masterList[3], label = \\\"nT\\\")\\n ax3.legend()\\n ax4.plot(times, wList, label = \\\"w(t)\\\")\\n ax4.legend()\\n ax5.plot(times, fList, label = r'$10^{-15} F/\\\\hbar$ in N/(Js)')\\n ax5.legend()\\n plt.show()\\n return(0)\",\n \"def plot_morphism_output(data, outdir):\\n\\n # show the distributions for each variable separately\\n for col in data.columns:\\n ProfilePlotter._plot_1d(data[col], outfile = os.path.join(outdir, col + \\\".pdf\\\"))\\n\\n # later, maybe also show 2d plots etc.\",\n \"def plot_brute_leastsquares_results(result, best_vals=True, varlabels=None,\\r\\n output=None, leastsq_fit_result=None):\\r\\n from matplotlib.colors import LogNorm\\r\\n import matplotlib.cm as cm\\r\\n \\r\\n npars = len(result.var_names)\\r\\n _fig, axes = plt.subplots(npars, npars)\\r\\n\\r\\n if not varlabels:\\r\\n varlabels = result.var_names\\r\\n if best_vals and isinstance(best_vals, bool):\\r\\n best_vals = result.params\\r\\n if leastsq_fit_result is not None:\\r\\n best_vals_leastsq = leastsq_fit_result.params\\r\\n\\r\\n for i, par1 in enumerate(result.var_names):\\r\\n for j, par2 in enumerate(result.var_names):\\r\\n\\r\\n # parameter vs chi2 in case of only one parameter\\r\\n if npars == 1:\\r\\n axes.plot(result.brute_grid, result.brute_Jout, 'o', ms=3)\\r\\n axes.set_ylabel(r'$\\\\chi^{2}$')\\r\\n axes.set_xlabel(varlabels[i])\\r\\n if best_vals:\\r\\n axes.axvline(best_vals[par1].value, ls='dashed', color='b')\\r\\n if best_vals_leastsq:\\r\\n axes.axvline(best_vals_leastsq[par1].value, ls='dashed', color='r')\\r\\n\\r\\n # parameter vs chi2 profile on top\\r\\n elif i == j and j < npars-1:\\r\\n if i == 0:\\r\\n axes[0, 0].axis('off')\\r\\n ax = axes[i, j+1]\\r\\n red_axis = tuple([a for a in range(npars) if a != i])\\r\\n ax.plot(np.unique(result.brute_grid[i]),\\r\\n np.minimum.reduce(result.brute_Jout, axis=red_axis),\\r\\n 'o', ms=3)\\r\\n ax.set_ylabel(r'$\\\\chi^{2}$')\\r\\n ax.yaxis.set_label_position(\\\"right\\\")\\r\\n ax.yaxis.set_ticks_position('right')\\r\\n ax.set_xticks([])\\r\\n if best_vals:\\r\\n ax.axvline(best_vals[par1].value, ls='dashed', color='b')\\r\\n if best_vals_leastsq:\\r\\n ax.axvline(best_vals_leastsq[par1].value, ls='dashed', color='r')\\r\\n # parameter vs chi2 profile on the left\\r\\n elif j == 0 and i > 0:\\r\\n ax = axes[i, j]\\r\\n red_axis = tuple([a for a in range(npars) if a != i])\\r\\n ax.plot(np.minimum.reduce(result.brute_Jout, axis=red_axis),\\r\\n np.unique(result.brute_grid[i]), 'o', ms=3)\\r\\n ax.invert_xaxis()\\r\\n ax.set_ylabel(varlabels[i])\\r\\n if i != npars-1:\\r\\n ax.set_xticks([])\\r\\n else:\\r\\n ax.set_xlabel(r'$\\\\chi^{2}$')\\r\\n if best_vals:\\r\\n ax.axhline(best_vals[par1].value, ls='dashed', color='b')\\r\\n if best_vals_leastsq:\\r\\n ax.axhline(best_vals_leastsq[par1].value, ls='dashed', color='r')\\r\\n\\r\\n # contour plots for all combinations of two parameters\\r\\n elif j > i:\\r\\n ax = axes[j, i+1]\\r\\n red_axis = tuple([a for a in range(npars) if a not in (i, j)])\\r\\n X, Y = np.meshgrid(np.unique(result.brute_grid[i]),\\r\\n np.unique(result.brute_grid[j]))\\r\\n lvls1 = np.linspace(result.brute_Jout.min(),\\r\\n np.median(result.brute_Jout)/2.0, 20, dtype='int')\\r\\n lvls2 = np.linspace(np.median(result.brute_Jout)/2.0,\\r\\n np.median(result.brute_Jout), 20, dtype='int')\\r\\n \\r\\n lvls = np.unique(np.concatenate((lvls1, lvls2)))\\r\\n \\r\\n ax.contourf(X.T, Y.T, np.minimum.reduce(result.brute_Jout, axis=red_axis),\\r\\n lvls, norm=LogNorm(),\\r\\n cmap=cm.nipy_spectral)\\r\\n ax.set_yticks([])\\r\\n if best_vals:\\r\\n ax.axvline(best_vals[par1].value, ls='dashed', color='b')\\r\\n ax.axhline(best_vals[par2].value, ls='dashed', color='b')\\r\\n ax.plot(best_vals[par1].value, best_vals[par2].value, 'bs', ms=3)\\r\\n if best_vals_leastsq:\\r\\n ax.axvline(best_vals_leastsq[par1].value, ls='dashed', color='r')\\r\\n ax.axhline(best_vals_leastsq[par2].value, ls='dashed', color='r')\\r\\n ax.plot(best_vals_leastsq[par1].value, best_vals_leastsq[par2].value, 'rs', ms=3)\\r\\n if j != npars-1:\\r\\n ax.set_xticks([])\\r\\n else:\\r\\n ax.set_xlabel(varlabels[i])\\r\\n if j - i >= 2:\\r\\n axes[i, j].axis('off')\\r\\n\\r\\n if output is not None:\\r\\n plt.savefig(output)\\r\\n else: \\r\\n plt.tight_layout()\\r\\n plt.show()\",\n \"def visualize_cross_validation_results(cross_val_results, plots_filepath):\\n\\n pair_model_scores, pair_model_stds, \\\\\\n siamese_model_scores_2, siamese_model_stds_2, \\\\\\n siamese_model_scores_10, siamese_model_stds_10 = cross_val_results\\n param_names = (\\\"NBCH1\\\", \\\"NBCH2\\\", \\\"NBFCH\\\", \\\"BATCH_NORM\\\", \\\"SKIP_CON\\\", \\\"LR\\\")\\n\\n def aggregate_results(scores, stds):\\n \\\"\\\"\\\"\\n Helper function to aggregate score means and standard deviations for a model across parameter values\\n\\n :param scores: dictionary of score means {param_combo: score_mean}\\n :param stds: dictionary of score stds {param_combo: score_std}\\n\\n :returns: list of tuples of pandas.Dataframe objects containing aggregated mean and std data\\n \\\"\\\"\\\"\\n\\n scores = pd.DataFrame(scores.values(),\\n index=scores.keys(),\\n columns=[\\\"SCORE MEAN\\\", ])\\n stds = pd.DataFrame(stds.values(),\\n index=stds.keys(),\\n columns=[\\\"SCORE STD\\\", ])\\n scores.index.name = param_names\\n stds.index.name = param_names\\n data = []\\n for param_gropby_levels in ((0,), (1,), (2,), (3, 4), (5,)):\\n aggregate_scores = scores.groupby(level=param_gropby_levels).mean()\\n aggregate_stds = scores.groupby(level=param_gropby_levels).std()\\n data.append((aggregate_scores, aggregate_stds))\\n return data\\n\\n pair_model_data = aggregate_results(pair_model_scores, pair_model_stds)\\n siamese_model_2_data = aggregate_results(siamese_model_scores_2, siamese_model_stds_2)\\n siamese_model_10_data = aggregate_results(siamese_model_scores_10, siamese_model_stds_10)\\n\\n # Group results for all models\\n model_names = (\\\"Pair\\\", \\\"Siamese 2\\\", \\\"Siamese 10\\\")\\n grouped_data = []\\n for pair_model_group_data, siamese_model_2_group_data, siamese_model_10_group_data in zip(pair_model_data,\\n siamese_model_2_data,\\n siamese_model_10_data):\\n score_means = (pair_model_group_data[0], siamese_model_2_group_data[0], siamese_model_10_group_data[0])\\n score_mean_data = pd.concat(score_means, axis=1)\\n score_mean_data.columns = model_names\\n\\n score_stds = (pair_model_group_data[1], siamese_model_2_group_data[1], siamese_model_10_group_data[1])\\n score_std_data = pd.concat(score_stds, axis=1)\\n score_std_data.columns = model_names\\n\\n grouped_data.append((score_mean_data, score_std_data))\\n\\n plots_param_names = (\\\"nbch1\\\", \\\"nbch2\\\", \\\"nbfch\\\", \\\"batch_norm+skip_con\\\", \\\"lr\\\")\\n for i, (plot_param_names, (score_mean_data, score_std_data)) in enumerate(zip(plots_param_names, grouped_data)):\\n plt.figure(figsize=(10, 5))\\n score_mean_data.plot(kind=\\\"line\\\" if plot_param_names == \\\"lr\\\" else \\\"bar\\\",\\n yerr=score_std_data,\\n capsize=5,\\n ylim=(0.4, 1.1),\\n colormap=colormap_brg_darker)\\n plt.title(\\\"Cross validation results for parameters:\\\\n{}\\\".format(plot_param_names), fontsize=18)\\n plt.xlabel(\\\"Parameter value\\\", fontsize=14)\\n plt.ylabel(\\\"Average accuracy\\\", fontsize=14)\\n plt.xticks(fontsize=12, rotation=30)\\n plt.yticks(fontsize=12)\\n plt.legend(title=\\\"Model\\\", title_fontsize=10)\\n plt.tight_layout()\\n plt.savefig(fname=plots_filepath + \\\"cross_validation_{}.eps\\\".format(plot_param_names),\\n dpi=\\\"figure\\\", format=\\\"eps\\\")\\n plt.close()\",\n \"def plot_dataset(\\n self,\\n out_dir: str = None,\\n therm_frac: int = 0.,\\n num_chains: int = None,\\n ridgeplots: bool = True,\\n profile: bool = False,\\n ):\\n tdict = {}\\n dataset = self.get_dataset(therm_frac)\\n for key, val in dataset.data_vars.items():\\n t0 = time.time()\\n if np.std(val.values.flatten()) < 1e-2:\\n continue\\n\\n if len(val.shape) == 2: # shape: (chain, draw)\\n val = val[:num_chains, :]\\n\\n if len(val.shape) == 3: # shape: (chain, leapfrogs, draw)\\n val = val[:num_chains, :, :]\\n\\n fig, ax = plt.subplots(constrained_layout=True, figsize=set_size())\\n _ = val.plot(ax=ax)\\n if out_dir is not None:\\n io.check_else_make_dir(out_dir)\\n out_file = os.path.join(out_dir, f'{key}_xrPlot.png')\\n fig.savefig(out_file, dpi=400, bbox_inches='tight')\\n plt.close('all')\\n plt.clf()\\n\\n if profile:\\n tdict[key] = time.time() - t0\\n io.log(f'time spent plotting {key}: {tdict[key]}')\\n\\n if out_dir is not None:\\n out_dir = os.path.join(out_dir, 'ridgeplots')\\n io.check_else_make_dir(out_dir)\\n\\n if ridgeplots:\\n make_ridgeplots(dataset, num_chains=num_chains, out_dir=out_dir)\\n\\n return tdict\",\n \"def surface_plot(name: str = 'start_date_analysis1.pkl'):\\n df = pd.read_pickle(name)\\n\\n # set up a figure twice as wide as it is tall\\n fig = plt.figure(figsize=plt.figaspect(0.5))\\n # ===============\\n # First subplot\\n # ===============\\n # set up the axes for the first plot\\n ax = fig.add_subplot(1, 2, 1, projection='3d')\\n ax.set_title('Modifications per File')\\n ax.set_xlabel('Date (Months)')\\n ax.set_ylabel('Threshold Individual')\\n for idx, row in enumerate(sorted(df['threshold_pairs'].unique())):\\n data = df[df['threshold_pairs'] == row]\\n label = 'Threshold pairs ' + str(row)\\n # Plot the surface.\\n surf = ax.plot_trisurf(data['date'], data['threshold'], data['mpf'], alpha=0.7,\\n linewidth=0, antialiased=False, label=label)\\n surf._facecolors2d = surf._facecolors3d\\n surf._edgecolors2d = surf._edgecolors3d\\n # ===============\\n # Second subplot\\n # ===============\\n # set up the axes for the second plot\\n ax = fig.add_subplot(1, 2, 2, projection='3d')\\n ax.set_title('Transitions per Test')\\n ax.set_xlabel('Date (Months)')\\n ax.set_ylabel('Threshold Individual')\\n for idx, row in enumerate(sorted(df['threshold_pairs'].unique())):\\n data = df[df['threshold_pairs'] == row]\\n label = 'Threshold pairs ' + str(row)\\n # Plot the surface.\\n\\n surf = ax.plot_trisurf(data['date'], data['threshold'], data['tpt'], alpha=0.7,\\n linewidth=0, antialiased=False, label=label)\\n\\n surf._facecolors2d = surf._facecolors3d\\n surf._edgecolors2d = surf._edgecolors3d\\n\\n # cbar = fig.colorbar(surf)\\n # cbar.locator = LinearLocator(numticks=10)\\n # cbar.update_ticks()\\n\\n plt.suptitle('Threshold Start Date Analysis 3D', fontsize=14)\\n plt.legend()\\n plt.show()\",\n \"def plot_modelparametercollections(plotname, parametercollection_SF, parametercollection_AGN,\\n stat_SF, stat_AGN, AGNcol='blue',SFcol='red', constraintsstr=None,\\n fluxratiodictionarylist=None, verbose=True):\\n\\n Nobj = len(parametercollection_SF)\\n if verbose: print(' - Will generate plots of NEOGAL \\\"PDFs\\\" for all '+str(Nobj)+' objects in parameter collections')\\n for oo in np.arange(Nobj):\\n objid = parametercollection_SF[oo]['id']\\n if verbose:\\n infostr = ' plotting info for '+str(objid)+' ('+str(\\\"%.5d\\\" % (oo+1))+' / '+str(\\\"%.5d\\\" % Nobj)+') '\\n sys.stdout.write(\\\"%s\\\\r\\\" % infostr)\\n sys.stdout.flush()\\n plotname_obj = plotname.replace('.pdf','_id'+str(objid)+'.pdf')\\n # if verbose: print(' - Generating the figure '+plotname_obj)\\n figuresize_x = 6\\n figuresize_y = 5\\n fig = plt.figure(figsize=(figuresize_x,figuresize_y))\\n Fsize = 9\\n LW = 2\\n plt.rc('text', usetex=True) # enabling LaTex rendering of text\\n plt.rc('font', family='serif',size=Fsize) # setting text font\\n plt.rc('xtick', labelsize=Fsize)\\n plt.rc('ytick', labelsize=Fsize)\\n plt.clf()\\n plt.ioff()\\n\\n left = 0.10 # the left side of the subplots of the figure\\n right = 0.95 # the right side of the subplots of the figure\\n bottom = 0.10 # the bottom of the subplots of the figure\\n top = 0.90 # the top of the subplots of the figure\\n wspace = 1.50 # the amount of width reserved for blank space between subplots\\n hspace = 0.50 # the amount of height reserved for white space between subplots\\n plt.subplots_adjust(left=left, bottom=bottom, right=right, top=top, wspace=wspace, hspace=hspace)\\n\\n Nrows, Ncols = 3, 6\\n ylabel = 'Number of NEOGAL SF ('+str(SFcol)+') and AGN ('+str(AGNcol)+') models'\\n\\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n Nmodels_SF = float(len(parametercollection_SF[oo]['Zgas']))\\n Nmodels_AGN = float(len(parametercollection_AGN[oo]['Zgas']))\\n\\n titlestr = 'Models satisfying ID='+str(objid)+' cuts: SF='+str(Nmodels_SF)+'; AGN='+str(Nmodels_AGN)\\n if (Nmodels_AGN > 0) & (Nmodels_SF > 0):\\n Nmodels_ratio = Nmodels_SF/Nmodels_AGN\\n titlestr_addition = '; SF/AGN='+str(\\\"%.4f\\\" % Nmodels_ratio)\\n titlestr = titlestr+titlestr_addition\\n\\n if fluxratiodictionarylist is not None:\\n constraints = fluxratiodictionarylist[oo]\\n constraintslist = [key+':['+str(\\\"%.2f\\\" % constraints[key][0])+','+str(\\\"%.2f\\\" % constraints[key][1])+']'\\n for key in constraints.keys() if key not in ['id']]\\n\\n if len(constraintslist) < 4:\\n constraintsstr = '; '.join(constraintslist)\\n elif (len(constraintslist) > 3) & (len(constraintslist) < 7):\\n constraintsstr = '; '.join(constraintslist[:3])+'\\\\n'+'; '.join(constraintslist[3:6])\\n elif (len(constraintslist) > 6) & (len(constraintslist) < 10):\\n constraintsstr = '; '.join(constraintslist[:3])+'\\\\n'+'; '.join(constraintslist[3:6])+\\\\\\n '\\\\n'+'; '.join(constraintslist[6:])\\n else:\\n constraintsstr = '; '.join(constraintslist[:3])+'\\\\n'+'; '.join(constraintslist[3:6])+\\\\\\n '\\\\n'+'; '.join(constraintslist[6:9])+'\\\\n'+'; '.join(constraintslist[9:])\\n\\n constraintsstr = constraintsstr.replace('10000000000.00','1e10')\\n\\n titlestr = titlestr+'\\\\n'+constraintsstr\\n # titlestr = r'{\\\\fontsize{'+str(Fsize)+'pt}{3em}\\\\selectfont{}{'+titlestr+'\\\\r}{\\\\fontsize{'+str((Fsize-2.))+'pt}{3em}\\\\selectfont{}('+constraintsstr+'}'\\n\\n # plt.text(x=0.5, y=0.94, s=titlestr, fontsize=Fsize, ha=\\\"center\\\", transform=fig.transFigure)\\n # plt.text(x=0.5, y=0.88, s=constraintsstr, fontsize=Fsize-2, ha=\\\"center\\\", transform=fig.transFigure)\\n # fig.title(titlestr,fontsize=Fsize)\\n fig.suptitle(titlestr,fontsize=Fsize-2)\\n\\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n # Zgas\\n plt.subplot(Nrows, Ncols, (1,3))\\n\\n bindefs = np.array([0.0001, 0.0002, 0.0005, 0.001, 0.002, 0.004, 0.006, 0.008, 0.014,\\n 0.017, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07])-0.00001\\n\\n plotkey = 'Zgas'\\n nm.plot_modelparametercollections_addhist(parametercollection_SF[oo][plotkey],parametercollection_AGN[oo][plotkey],\\n stat_SF[oo][plotkey],stat_AGN[oo][plotkey],\\n SFcol,AGNcol,LW,bindefs=bindefs,Nbins=None)\\n\\n plt.xscale('log')\\n plt.xlabel(nm.keylabels(plotkey))\\n plt.xlim([0.00001,0.1])\\n\\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n # logUs\\n plt.subplot(Nrows, Ncols, (4,6))\\n\\n bindefs = np.arange(-4.75, -0.25, 0.5)\\n\\n plotkey = 'logUs'\\n nm.plot_modelparametercollections_addhist(parametercollection_SF[oo][plotkey],parametercollection_AGN[oo][plotkey],\\n stat_SF[oo][plotkey],stat_AGN[oo][plotkey],\\n SFcol,AGNcol,LW,bindefs=bindefs,Nbins=None)\\n\\n plt.xlabel(nm.keylabels(plotkey))\\n plt.xlim([-5,-0.5])\\n\\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n # xid\\n plt.subplot(Nrows, Ncols, (7,9))\\n\\n bindefs = np.array([0.0, 0.2, 0.4, 0.6])\\n\\n plotkey = 'xid'\\n nm.plot_modelparametercollections_addhist(parametercollection_SF[oo][plotkey],parametercollection_AGN[oo][plotkey],\\n stat_SF[oo][plotkey],stat_AGN[oo][plotkey],\\n SFcol,AGNcol,LW,bindefs=bindefs,Nbins=None)\\n\\n plt.xlabel(nm.keylabels(plotkey))\\n plt.xlim([-0.05,0.65])\\n plt.ylabel(ylabel)\\n\\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n # nh\\n plt.subplot(Nrows, Ncols, (10,12))\\n\\n bindefs = 10**np.array([1.5, 2.5, 3.5, 4.5])\\n\\n plotkey = 'nh'\\n nm.plot_modelparametercollections_addhist(parametercollection_SF[oo][plotkey],parametercollection_AGN[oo][plotkey],\\n stat_SF[oo][plotkey],stat_AGN[oo][plotkey],\\n SFcol,AGNcol,LW,bindefs=bindefs,Nbins=None)\\n plt.xscale('log')\\n plt.xlabel(nm.keylabels(plotkey))\\n plt.xlim([10,1e5])\\n\\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n # COCOsol\\n plt.subplot(Nrows, Ncols, (13,14))\\n\\n #bindefs = np.array([0.10, 0.14, 0.20, 0.27, 0.38, 0.52, 0.72, 1.00, 1.40])\\n bindefs = np.arange(0.05,1.5,0.06)\\n\\n plotkey = 'COCOsol'\\n nm.plot_modelparametercollections_addhist(parametercollection_SF[oo][plotkey],None,\\n stat_SF[oo][plotkey],None,\\n SFcol,AGNcol,LW,bindefs=bindefs,Nbins=None)\\n\\n plt.xlabel(nm.keylabels(plotkey))\\n plt.xlim([0.00,1.55])\\n\\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n # mup\\n plt.subplot(Nrows, Ncols, (15,16))\\n\\n bindefs = np.array([0,200,400])\\n\\n plotkey = 'mup'\\n nm.plot_modelparametercollections_addhist(parametercollection_SF[oo][plotkey],None,\\n stat_SF[oo][plotkey],None,\\n SFcol,AGNcol,LW,bindefs=bindefs,Nbins=None)\\n\\n plt.xlabel(nm.keylabels(plotkey))\\n plt.xlim([-10,410])\\n\\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n # alpha\\n plt.subplot(Nrows, Ncols, (17,18))\\n\\n bindefs = np.array([-2.15,-1.85,-1.55,-1.25,-0.95])\\n\\n plotkey = 'alpha'\\n Nbins = 10\\n nm.plot_modelparametercollections_addhist(None,parametercollection_AGN[oo][plotkey],\\n None,stat_AGN[oo][plotkey],\\n SFcol,AGNcol,LW,bindefs=None,Nbins=Nbins)\\n\\n plt.xlabel(nm.keylabels(plotkey))\\n plt.xlim([-2.2,-0.9])\\n\\n # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n plt.savefig(plotname_obj)\\n plt.clf()\\n plt.close('all')\\n # if verbose: print(' - Successfully saved figure to file')\\n if verbose: print('\\\\n done...')\",\n \"def plot_optimal_tau(results_for_exp, results_for_exp_inftau):\\n values = sp.empty((results_for_exp.shape[0], results_for_exp.shape[1]))\\n err = sp.empty((results_for_exp.shape[0], results_for_exp.shape[1], 2, 1))\\n num_trials = results_for_exp.shape[3]\\n for i, l4 in enumerate(cfg['l4_lengths']):\\n for j, l2 in enumerate(cfg['l2_lengths']):\\n r = [sp.mean(cfg['time_scales'][\\n results_for_exp[i, j, :, t] == results_for_exp[i, j, :, t].max()])\\n for t in xrange(num_trials)]\\n values[i, j] = sp.mean(r)\\n err[i, j, 0] = values[i, j] - min(r).magnitude\\n err[i, j, 1] = max(r).magnitude - values[i, j]\\n plot_param_per_l4_and_l2(values, err)\\n plot_bool_indicator_per_l4_and_l2(\\n sp.any(results_for_exp_inftau >= results_for_exp.max(axis=2), axis=2))\",\n \"def result_plotting(n_images,epoch,dataset,result_path,labels,predictions,indices):\\n \\n coord,connectivity = [],[] # List of prediction and ground truth images\\n for k in range(n_images):\\n \\n or_case = int(np.where(np.array(dataset.data.case)==indices[k])[0][0]) # Get index of case\\n \\n # Get the coordinate and connectivity data\\n coord += [dataset[or_case].coord.numpy()] \\n connectivity += [dataset[or_case].connectivity.numpy()]\\n\\n # Save npz array with the results of this iteration\\n np.savez(join(result_path,'Temp.npz'),labels=n(labels),predictions=n(predictions)\\n ,indices=n(indices),coord=n(coord),connectivity=n(connectivity))\\n\\n # Call mesh_plotter to create the figures\\n subprocess.call(['python', 'mesh_plotter.py','-p',result_path,'-e',str(epoch),'-ni',str(n_images)])\\n \\n # Send image for visualization in W&B\\n images = wandb.Image(join(result_path,'Result_'+str(epoch).zfill(3)+'.png'),caption = \\\"Epoch \\\"+str(epoch))\\n wandb.log({\\\"Prediction\\\": images})\",\n \"def magn_plot(names, values, data, model_key, plot_key=False):\\n zpicks = data['zpicks']\\n\\n # Corrected absolute magnitude M of SN.\\n M = values[0]\\n\\n dlpc, da, plot_var = zodesolve.zodesolve(names, values, zpicks, model_key, plot_key)\\n\\n # Calculating apparent magnitudes of supernovae at the simulated\\n # luminosity distances using the distance modulus formula.\\n mag = 5 * np.log10(dlpc/10) + M\\n z = plot_var['z']\\n if model_key == 'waterfall':\\n plt.figure()\\n plt.title(r'$\\\\bar \\\\Omega$ evolution in waterfall')\\n plt.xlabel('redshift')\\n plt.ylabel(r'$\\\\bar \\\\Omega$')\\n plt.plot(z, plot_var['ombar_m'], label='ombar_m vs redshift')\\n plt.plot(z, plot_var['ombar_r'], label='ombar_r vs redshift')\\n plt.plot(z, plot_var['a_ombar'], label='a_ombar vs redshift')\\n plt.plot(z, plot_var['b_ombar'], label='b_ombar vs redshift')\\n plt.plot(z, plot_var['c_ombar'], label='c_ombar vs redshift')\\n plt.plot(z, plot_var['ombar_de'], label='ombar_de vs redshift')\\n plt.legend()\\n\\n sum_om = plot_var['ombar_m'] + plot_var['ombar_r'] + plot_var['a_ombar']+ plot_var['b_ombar'] + plot_var['c_ombar'] + plot_var['c_ombar'] +plot_var['ombar_de']\\n om_m = plot_var['ombar_m']/sum_om\\n om_r = plot_var['ombar_r']/sum_om\\n om_a = plot_var['a_ombar']/sum_om\\n om_b = plot_var['b_ombar']/sum_om\\n om_c = plot_var['c_ombar']/sum_om\\n om_de = plot_var['ombar_de']/sum_om\\n\\n plt.figure()\\n plt.title(r'$\\\\Omega$ evolution in waterfall')\\n plt.xlabel('redshift')\\n plt.ylabel(r'$\\\\Omega$')\\n plt.plot(z, om_m, label = 'om_m')\\n plt.plot(z, om_r, label = 'om_r')\\n plt.plot(z, om_a, label = 'om_a')\\n plt.plot(z, om_b, label = 'om_b')\\n plt.plot(z, om_c, label = 'om_c')\\n plt.plot(z, om_de, label = 'om_de')\\n plt.legend()\\n plt.show()\\n\\n elif model_key == 'LCDM':\\n plt.figure()\\n plt.title(r'$\\\\bar \\\\Omega$ evolution in LCDM')\\n plt.xlabel('redshift')\\n plt.ylabel(r'$\\\\bar \\\\Omega$')\\n plt.plot(z, plot_var['ombar_m'], label='ombar_m vs redshift')\\n plt.plot(z, plot_var['ombar_de'], label='ombar_de vs redshift')\\n plt.legend()\\n\\n sum_om = plot_var['ombar_m'] + plot_var['ombar_de']\\n om_m = plot_var['ombar_m']/sum_om\\n om_de = plot_var['ombar_de']/sum_om\\n\\n plt.figure()\\n plt.title(r'$\\\\Omega$ evolution in LCDM')\\n plt.xlabel('redshift')\\n plt.ylabel(r'$\\\\Omega$')\\n plt.plot(z, om_m, label = 'om_m')\\n plt.plot(z, om_de, label = 'om_de')\\n plt.legend()\\n plt.show()\\n\\n elif model_key == 'exotic':\\n plt.figure()\\n plt.title(r'$\\\\bar \\\\Omega$ evolution in LCDM')\\n plt.xlabel('redshift')\\n plt.ylabel(r'$\\\\bar \\\\Omega$')\\n plt.plot(z, plot_var['ombar_m'], label='ombar_m vs redshift')\\n plt.plot(z, plot_var['ombar_r'], label='ombar_r vs redshift')\\n plt.plot(z, plot_var['ombar_de'], label='ombar_de vs redshift')\\n plt.legend()\\n\\n sum_om = plot_var['ombar_m'] + plot_var['ombar_r'] + plot_var['ombar_de']\\n om_m = plot_var['ombar_m']/sum_om\\n om_r = plot_var['ombar_r']/sum_om\\n om_de = plot_var['ombar_de']/sum_om\\n\\n plt.figure()\\n plt.title(r'$\\\\Omega$ evolution in LCDM')\\n plt.xlabel('redshift')\\n plt.ylabel(r'$\\\\Omega$')\\n plt.plot(z, om_m, label = 'om_m')\\n plt.plot(z, om_r, label = 'om_r')\\n plt.plot(z, om_de, label = 'om_de')\\n plt.legend()\\n plt.show()\\n\\n if plot_key:\\n # Plotting evolution of parameters in the model.\\n import plots\\n plots.modelcheck(mag, zpicks, plot_var, model_key)\\n\\n return mag\",\n \"def plane_plots(xpv, ypv, dicti):\\n xz = []\\n yz = []\\n\\n for k in dicti:\\n for i in range(len(dicti[k])):\\n if dicti[k][i][1] == ypv:\\n xz.append([dicti[k][i][0], dicti[k][i][2], dicti[k][i][3], dicti[k][i][5]])\\n if dicti[k][i][0] == xpv:\\n yz.append([dicti[k][i][1], dicti[k][i][2], dicti[k][i][4], dicti[k][i][5]])\\n\\n xzx, xzz, xzxv, xzzv = zip(*xz)\\n yzy, yzz, yzyv, yzzv = zip(*yz)\\n\\n axv, exv= mean_vel(xzxv, xzz)\\n ayv, eyv = mean_vel(yzyv, yzz)\\n\\n # Changes height values to distance from dermal denticles.\\n dfdd = np.array(abs(exp_h_list) - np.amin(abs(exp_h_list)))\\n xzz = np.array(abs(np.array(xzz)) - np.amin(abs(np.array(xzz))))\\n yzz = np.array(abs(np.array(yzz)) - np.amin(abs(np.array(yzz))))\\n\\n f, axarr = plt.subplots(2,2, sharey=True)\\n\\n fig = axarr[0,0].quiver(xzx, xzz, xzxv, xzzv, yzyv)\\n # Colour uses yzyv so that it matches the other plot\\n axarr[0,0].set_xlabel(\\\"x\\\")\\n axarr[0,0].set_ylabel(r\\\"Height from dd ($mm$)\\\")\\n\\n axarr[0,1].errorbar(100*axv, dfdd, xerr=100*exv, marker='o', color='g')\\n axarr[0,1].plot([0.0, 0.0], [np.amin(dfdd), np.amax(dfdd)], 'k--')\\n axarr[0,1].set_xlabel(r\\\"x-velocity ($\\\\times 10^{-2}ms^{-1}$)\\\")\\n\\n axarr[1,0].quiver(yzy, yzz, yzyv, yzzv, yzyv)\\n axarr[1,0].set_xlabel(\\\"y\\\")\\n axarr[1,0].set_ylabel(r\\\"Height from dd ($mm$)\\\")\\n\\n axarr[1,1].errorbar(100*ayv, dfdd, xerr=100*eyv, marker='o', color='b')\\n axarr[1,1].plot([0.0, 0.0], [np.amin(dfdd), np.amax(dfdd)], 'k--')\\n axarr[1,1].set_xlabel(r\\\"y-velocity ($\\\\times 10^{-2}ms^{-1}$)\\\")\\n\\n cax, kw = mpl.colorbar.make_axes([ax for ax in axarr.flat])\\n f.colorbar(fig, cax=cax, **kw)\\n cbar = mpl.colorbar.ColorbarBase(cax, norm=mpl.colors.Normalize(vmin=-0.1, vmax=0.1))\\n cbar.set_clim(-0.1,0.1)\\n f.suptitle(r\\\"$\\\\mu$-PIV for the %s (%s). Flow direction: %s\\\" %(shark_species, sample_area,\\n flow_direction))\\n plt.show()\\n\\n if w2f:\\n write_mean_to_file(dfdd, axv, ayv)\\n\\n return\",\n \"def _plot_decomposition(Result,\\r\\n title,\\r\\n savepath = False,\\r\\n savename = False,\\r\\n ylabel = \\\"Value\\\",\\r\\n xlabel = \\\"Date\\\",\\r\\n dates = False,\\r\\n test = False,\\r\\n ):\\r\\n \\r\\n fig1 = plt.figure(figsize=(9.3,9.3))\\r\\n \\r\\n plt.suptitle(title,fontsize=22,y=1)\\r\\n \\r\\n plt.subplot(4,1,1)\\r\\n plt.plot(Result.observed)\\r\\n plt.title('Observations',fontsize=18)\\r\\n if type(dates) != bool: \\r\\n for d in dates:\\r\\n plt.axvline(x=d,linestyle =\\\":\\\", color ='black')\\r\\n plt.ylabel(ylabel,fontsize=14)\\r\\n plt.xlabel(xlabel,fontsize=14)\\r\\n \\r\\n \\r\\n plt.subplot(4,1,2)\\r\\n plt.plot(Result.trend)\\r\\n plt.title('Trend',fontsize=18)\\r\\n if type(dates) != bool: \\r\\n for d in dates:\\r\\n plt.axvline(x=d,linestyle =\\\":\\\", color ='black')\\r\\n plt.ylabel(ylabel,fontsize=14)\\r\\n plt.xlabel(xlabel,fontsize=14)\\r\\n \\r\\n plt.subplot(4,1,3)\\r\\n plt.plot(Result.seasonal)\\r\\n if type(dates) != bool: \\r\\n for d in dates:\\r\\n plt.axvline(x=d,linestyle =\\\":\\\", color ='black')\\r\\n plt.title('Seasonal',fontsize=18)\\r\\n plt.ylabel(ylabel,fontsize=14)\\r\\n plt.xlabel(xlabel,fontsize=14)\\r\\n \\r\\n plt.subplot(4,1,4)\\r\\n plt.plot(Result.resid)\\r\\n if type(dates) != bool: \\r\\n for d in dates:\\r\\n plt.axvline(x=d,linestyle =\\\":\\\", color ='black')\\r\\n plt.title('Residuals',fontsize=18)\\r\\n plt.ylabel(ylabel,fontsize=14)\\r\\n plt.xlabel(xlabel,fontsize=14)\\r\\n \\r\\n fig1.tight_layout(pad=2)\\r\\n \\r\\n return fig1\",\n \"def display(self):\\r\\n \\r\\n plt.rcParams['font.size'] = 14\\r\\n plt.rcParams['axes.linewidth'] = 1.2 # 1.2 for single plot, 0.5 for all 6\\r\\n plt.rcParams['lines.linewidth'] = 20.0 # Aah, this doesn't work because line width is changed later on\\r\\n\\r\\n cwd = os.getcwd() # Gets current working directory.\\r\\n cwd = cwd.replace('\\\\\\\\', '/')\\r\\n path = cwd + directory # This is the folder all the results are stored in.\\r\\n \\r\\n if type(array_element) == str:\\r\\n dataframes = [file + array_element] # This is to pass a single csv file\\r\\n else:\\r\\n dataframes = [file + i for i in array_element] # This is a list so you can pass multiple csv files to be overlayed on the same plot.\\r\\n\\r\\n colours = ['black', 'darkred', 'darkmagenta', 'darkturquoise', 'saddlebrown'] # Array of colours for the lines.\\r\\n\\r\\n dfE = pd.read_csv(cwd + \\\"/experimental_data.csv\\\") # Reads in the experimental data as a pandas dataframe.\\r\\n\\r\\n # Rescale the x-axis of the experimental data.\\r\\n ratio_of_capacities = 272.4 / 338.313338 # experimental maximum capacity / theoretical maximum capacity\\r\\n dfE[\\\"x_theo\\\"] = ratio_of_capacities * dfE[\\\"x\\\"]\\r\\n # 'x' is the experimental x and 'x_theo' is the theoretical x.\\r\\n\\r\\n # Second derivative of enthalpy for experimental data. One w/ respect to the experimental x and one w/ respect to theoretical x.\\r\\n secder_enthalpy_experimental_x = np.gradient(np.array(dfE['Enthalpy dH/dx']), np.array(dfE['x']))\\r\\n secder_enthalpy_experimental_x_theo = np.gradient(np.array(dfE['Enthalpy dH/dx']), np.array(dfE['x_theo']))\\r\\n dfE['secder enthalpy x'] = secder_enthalpy_experimental_x\\r\\n dfE['secder enthalpy x theo'] = secder_enthalpy_experimental_x_theo\\r\\n\\r\\n # vertical shift on p.m. entropy for vibrational effect\\r\\n vibrational_shift = 0.0108 # eV K this includes being multiplied by the ratio of capacities.\\r\\n dfE[\\\"Entropy dS/dx\\\"] = (dfE[\\\"Entropy dS/dx\\\"]) - vibrational_shift\\r\\n\\r\\n # Integrates the p.m. entropy\\r\\n entropy_list_experimental = integrate.cumtrapz(dfE['Entropy dS/dx'], dfE['x'],\\r\\n initial=0) # Contains the entropy values\\r\\n dfE['Entropy'] = entropy_list_experimental\\r\\n\\r\\n dfE['x_new'] = ((dfE['x_theo'] - dfE['x_theo'].iloc[0]) * dfE['x_theo'][73]) / (dfE['x_theo'][73] - dfE['x_theo'].iloc[0]) # Rescales the line so that the experimental data starts at 0.\\r\\n dfE['x'] = ((dfE['x'] - dfE['x'].iloc[0]) * dfE['x'][73]) / (dfE['x'][73] - dfE['x'].iloc[0]) # Same as above but for experimental x axis.\\r\\n\\r\\n # Calculates the analytical solution\\r\\n points = 1000\\r\\n x_pos = np.linspace(0, 1, points) # x for p.m. entropy\\r\\n y_pos = np.linspace(0, 1, points) # y for p.m. etropy\\r\\n s_x = np.linspace(0, 1, points) # x for entropy\\r\\n s_y = np.linspace(0, 1, points) # y for entropy\\r\\n l = 0.329217689 # This must be the same as what was used in the main script\\r\\n R = -0.0000862 # eV/K.Site\\r\\n T = 288 # K\\r\\n for index, x in enumerate(x_pos):\\r\\n if x < l:\\r\\n s_y[index] = (R * (x * np.log(x / l) - (x - l) * np.log((l - x) / l))) * T\\r\\n y_pos[index] = T * R * (np.log(x / l) - np.log((l - x) / l))\\r\\n else:\\r\\n s_y[index] = (R * l * (\\r\\n (x / l - 1) * np.log(x / l - 1) + (1 - x) / l * np.log((1 - x) / l) - (1 - l) / l * np.log(\\r\\n (1 - l) / l))) * T\\r\\n y_pos[index] = T * R * (np.log(x / l - 1) - np.log(1 / l - x / l))\\r\\n\\r\\n # Calculates the single solid state entropy\\r\\n x_ent = np.linspace(0, 1, points)\\r\\n y_ent = np.linspace(0, 1, points)\\r\\n for index, x in enumerate(x_ent):\\r\\n y_ent[index] = T * R * (x * np.log(x) + (1-x) * np.log(1-x))\\r\\n \\r\\n \\\"\\\"\\\"\\r\\n #\\r\\n #\\r\\n # Create plot and formats\\r\\n #\\r\\n #\\r\\n \\\"\\\"\\\"\\r\\n \\r\\n fig, axes = plt.subplots(nrows=num_row, ncols=num_col, constrained_layout=True, squeeze=False)\\r\\n # squeeze=False is needed to prevent errors when plotting a single subplot\\r\\n plt.rc('legend', fontsize=13, handlelength=1)\\r\\n plt.rc('tick')\\r\\n lw = 1.5 # Line width\\r\\n \\r\\n plt.tick_params(bottom=True, top=True, left=True, right=True)\\r\\n plt.tick_params(labelbottom=True, labeltop=False, labelleft=True, labelright=False)\\r\\n plt.tick_params(direction='in', width=1.2, length=4.5, pad=3) # For single plot\\r\\n # plt.tick_params(direction='in', width=1, length=4.5, pad=3) # For multiple plots\\r\\n\\r\\n marker_list = ['v', '^', 'p', 'o']\\r\\n mark_size = 3 #0.7 for 6 plots\\r\\n \\r\\n colours = ['#176ba0', '#af4bce', 'orangered', '#48a11b', '#3caea3'] #'#af4bce'\\r\\n common_legend = ['400 Averaging Steps', '800 Averaging Steps', '2000 Averaging Steps']\\r\\n \\r\\n if num_col==2 and num_row==3: # This will work when using the original axes dimensions (3 rows, 2 columns)\\r\\n placement = dict([\\r\\n ('voltage', axes[0, 0]),\\r\\n ('dS/dx', axes[0, 1]),\\r\\n ('dQ/dV', axes[1, 0]),\\r\\n ('dH/dx', axes[1, 1]),\\r\\n ('S', axes[2, 0]),\\r\\n ('d/dx(dH/dx)', axes[2, 1])\\r\\n ])\\r\\n else: # If axes dimensions are different, I'm probably trying to plot one graph\\r\\n \\\"\\\"\\\"\\r\\n If plotting more than one graph, the position on the plot in the subplot can be adjusted\\r\\n by appropriately altering the axes[] parameter. For the graphs that are not being plotted, \\r\\n leave their position as axes[0, 0].\\r\\n \\\"\\\"\\\"\\r\\n placement = dict([\\r\\n ('voltage', axes[0, 0]),\\r\\n ('dS/dx', axes[0, 0]),\\r\\n ('dQ/dV', axes[0, 0]),\\r\\n ('dH/dx', axes[0, 0]),\\r\\n ('S', axes[0, 0]),\\r\\n ('d/dx(dH/dx)', axes[0, 0])\\r\\n ])\\r\\n \\r\\n # Plots all of the experimental data\\r\\n if experimental_plot == True:\\r\\n if pick_plot['voltage'] == True:\\r\\n dfE.plot(linestyle='-', color='darkgreen', lw=lw, ax=placement['voltage'], x='x_new', y='OCV')\\r\\n dfE.plot(linestyle='-', color='darkblue', lw=lw, ax=placement['voltage'], x='x', y='OCV')\\r\\n \\r\\n if pick_plot['dS/dx'] == True:\\r\\n ax2 = dfE.plot(linestyle='-', color='darkgreen', lw=lw, ax=placement['dS/dx'], x='x_new', y='Entropy dS/dx')\\r\\n dfE.plot(linestyle='-', color='darkblue', lw=lw, ax=placement['dS/dx'], x='x', y='Entropy dS/dx')\\r\\n \\r\\n if pick_plot['dQ/dV'] == True:\\r\\n dfE.plot(linestyle='-', color='darkgreen', lw=lw, ax=placement['dQ/dV'], x='OCV', y='dQdV') \\r\\n \\r\\n if pick_plot['dH/dx'] == True:\\r\\n dfE.plot(linestyle='-', color='darkgreen', lw=lw, ax=placement['dH/dx'], x='x_new', y='Enthalpy dH/dx')\\r\\n dfE.plot(linestyle='-', color='darkblue', lw=lw, ax=placement['dH/dx'], x='x', y='Enthalpy dH/dx')\\r\\n \\r\\n if pick_plot['S'] == True:\\r\\n ax5 = dfE.plot(linestyle='-', color='darkgreen', lw=lw, ax=placement['S'], x='x_new', y='Entropy')\\r\\n \\r\\n if pick_plot['d/dx(dH/dx)'] == True:\\r\\n dfE.plot(linestyle='-', color='darkgreen', lw=lw, ax=placement['d/dx(dH/dx)'], x='x_new', y='secder enthalpy x theo')\\r\\n dfE.plot(linestyle='-', color='darkblue', lw=lw, ax=placement['d/dx(dH/dx)'], x='x', y='secder enthalpy x')\\r\\n\\r\\n # Iterate through all the data to be plotted\\r\\n if simulation_plot == True:\\r\\n for count, df in enumerate(dataframes):\\r\\n df1 = pd.read_csv(path + df) # reads file into a dataframe.\\r\\n \\r\\n df1 = df1.replace(0, np.nan).dropna(axis=0, how='all') # For the rows with all '0' entries they are replaced with 'nan' and then these rows are dropped.\\r\\n df1 = df1.replace(np.nan, 0) # As some legitimate 0 entries such as 0 volts we flip back the remaining from 'nan' to 0.\\r\\n \\r\\n # Integrates the p.m. entropy\\r\\n entropy_list = integrate.cumtrapz(df1['Partial molar entropy'], df1['Total mole fraction'],\\r\\n initial=0) # Contains the entropy values\\r\\n df1['Entropy'] = entropy_list\\r\\n \\r\\n # Rescale voltage profile and p.m. enthalpy by the chain rule.\\r\\n df1[\\\"adjusted voltage\\\"] = df1[\\\"Chemical potential\\\"] * ratio_of_capacities\\r\\n df1[\\\"adjusted enthalpy\\\"] = df1[\\\"Partial molar enthalpy\\\"] * ratio_of_capacities\\r\\n df1[\\\"adjusted entropy\\\"] = df1[\\\"Partial molar entropy\\\"] * ratio_of_capacities\\r\\n df1[\\\"adjusted dq/de\\\"] = df1[\\\"dq/de\\\"] * (1/ratio_of_capacities)**2\\r\\n \\r\\n # Differentiate the p.m. enthalpy to get the second derivative.\\r\\n pm_enthalpy = np.array(df1['adjusted enthalpy'])\\r\\n mole_fraction = np.array(df1['Total mole fraction'])\\r\\n secder_enthalpy = np.gradient(pm_enthalpy, mole_fraction)\\r\\n df1['secder enthalpy'] = secder_enthalpy\\r\\n \\r\\n if pick_plot['voltage'] == True:\\r\\n ax1 = df1.plot(linestyle='-', color=colours[count], lw=lw, marker=marker_list[count], markeredgecolor=colours[count],\\r\\n markersize=mark_size, ax=placement['voltage'], x='Total mole fraction', y='adjusted voltage')\\r\\n ax1.set_xlim([0, 1])\\r\\n ax1.set_xlabel('Na content $[x]$')\\r\\n ax1.set_ylabel('Voltage $[V]$')\\r\\n ax1.legend(common_legend) \\r\\n # ax1.legend(['Experimental data (Adjusted x)', 'Raw experimental data', 'Monte Carlo data'])\\r\\n \\r\\n if pick_plot['dS/dx'] == True:\\r\\n ax2 = df1.plot(linestyle='-', color=colours[count], lw=lw, marker=marker_list[count], markeredgecolor=colours[count],\\r\\n markersize=mark_size, ax=placement['dS/dx'], x='Total mole fraction', y='adjusted entropy')\\r\\n # ax2.plot(x_pos, y_pos, linewidth=lw, color='red') # Plots the ideal p.m. entropy\\r\\n ax2.set_xlim([0, 1])\\r\\n ax2.set_xlabel('Na content $[x]$')\\r\\n ax2.set_ylabel('$\\\\\\\\frac{dS}{dx}$ $[eV K/site]$')\\r\\n ax2.legend(common_legend) \\r\\n # ax2.legend(['Experimental data (Adjusted x)', 'Raw experimental data', 'Monte Carlo data', 'Analytical solution'])\\r\\n \\r\\n if pick_plot['dQ/dV'] == True:\\r\\n ax3 = df1.plot(linestyle='-', color=colours[count], lw=lw, marker=marker_list[count], markeredgecolor=colours[count],\\r\\n markersize=mark_size, ax=placement['dQ/dV'], x='Chemical potential', y='adjusted dq/de') \\r\\n ax3.set_xlim([-0.1, 1])\\r\\n ax3.set_xlabel('Voltage $[V]$')\\r\\n ax3.set_ylabel('$\\\\\\\\frac{dQ}{dV}$ [$\\\\mathregular{eV^{-1}}$]')\\r\\n ax3.legend(common_legend)\\r\\n # ax3.legend(['Experimental data', 'Monte Carlo Data'])\\r\\n \\r\\n if pick_plot['dH/dx'] == True:\\r\\n ax4 = df1.plot(linestyle='-', color=colours[count], lw=lw, marker=marker_list[count], markeredgecolor=colours[count],\\r\\n markersize=mark_size, ax=placement['dH/dx'], x='Total mole fraction', y='adjusted enthalpy')\\r\\n ax4.set_xlim([0, 1])\\r\\n ax4.set_xlabel('Na content $[x]$')\\r\\n ax4.set_ylabel('$\\\\\\\\frac{dH}{dx}$ $[eV/site]$')\\r\\n ax4.legend(common_legend) \\r\\n # ax4.legend(['Experimental data (Adjusted x)', 'Raw experimental data', 'Monte Carlo data'])\\r\\n \\r\\n if pick_plot['d/dx(dH/dx)'] == True:\\r\\n ax5 = df1.plot(linestyle='-', color=colours[count], lw=lw, marker=marker_list[count], markeredgecolor=colours[count],\\r\\n markersize=mark_size, ax=placement['d/dx(dH/dx)'], x='Total mole fraction', y='secder enthalpy')\\r\\n ax5.set_xlim([0, 1])\\r\\n ax5.set_ylim([0, 6])\\r\\n ax5.set_xlabel('Na content $[x]$')\\r\\n ax5.set_ylabel('$\\\\\\\\frac{d^2H}{dx^2}$ $[eV/site]$')\\r\\n ax5.legend(common_legend)\\r\\n \\r\\n # ax5.legend(['Experimental data (Adjusted x)', 'Raw experimental data', 'Monte Carlo data'])\\r\\n \\r\\n if pick_plot['S'] == True:\\r\\n ax6 = df1.plot(linestyle='-', color=colours[count], lw=lw, marker=marker_list[count], markeredgecolor=colours[count],\\r\\n markersize=mark_size, ax=placement['S'], x='Total mole fraction', y='Entropy')\\r\\n \\r\\n # ax6.plot(s_x, s_y, linewidth=lw, color='red') # Plots the entropy for l=0.32...\\r\\n # ax6.plot(x_ent, y_ent, linewidth=lw, color='grey') # Plots the entropy for solid state solution.\\r\\n ax6.set_xlim([0, 1])\\r\\n ax6.set_xlabel('Na content $[x]$')\\r\\n ax6.set_ylabel('S $[eV K/site]$')\\r\\n ax6.legend(common_legend)\\r\\n # ax6.legend(['Experimental data', 'Monte Carlo data', 'Analytical solution', 'Solid state solution'], loc='upper right', bbox_to_anchor=(0.75, 0.5))\\r\\n \\r\\n \\r\\n\\r\\n # parameter_file = open(path + \\\"/Input_arguments_\\\" + uid + \\\".txt\\\", \\\"w\\\")\\r\\n # parameter_file.write(str(self.args))\\r\\n # parameter_file.close()\\r\\n\\r\\n # manager = plt.get_current_fig_manager()\\r\\n # # manager.resize(*manager.window.maxsize())\\r\\n # # fig_path = cwd + \\\"/Na_plot_results.png\\\"\\r\\n # # plt.savefig(path + \\\"/Na_monte_carlo_plot_\\\" + uid + \\\".png\\\")\\r\\n # plt.show()\\r\\n \\r\\n plt.savefig(\\\"Varying sps Overlaid Plots - dQ_dV\\\", dpi = 300)\\r\\n\\r\\n plt.show()\",\n \"def plot_data(\\n self,\\n out_dir: str = None,\\n flags: AttrDict = None,\\n therm_frac: float = 0.,\\n params: AttrDict = None,\\n ):\\n plot_data(self.data, out_dir, flags,\\n therm_frac=therm_frac, params=params)\",\n \"def plotSpectrum(inp,xrng=[],yrng=[],xlabel='',ylabel='',xlog=False,ylog=False,grid=False,\\n legend=[],legend_location='upper right',fontscale=1,legend_fontscale=1,title='',\\n color='k',colormap=None,linestyle='-',linewidth=1.5,alpha=1.,\\n show_noise=True,color_noise='k',linestyle_noise='-',linewidth_noise=1.5,alpha_noise=0.5,\\n comparison=None,color_comparison='grey',linestyle_comparison='-',linewidth_comparison=1.5,alpha_comparison=1,\\n residual=False,color_residual='m',linestyle_residual='-',linewidth_residual=1.5,alpha_residual=0.5,\\n telluric=False,color_telluric='grey',linestyle_telluric='-',linewidth_telluric=1.5,alpha_telluric=0.2,\\n features=[],mdwarf=False,ldwarf=False,tdwarf=False,young=False,binary=False,nsamples=100,\\n band=[],band_color='k',band_alpha=0.2,band_label='',band_label_position='bottom',band_width=0.1,\\n show_zero=True,stack=0.,zeropoint=0.,color_zero='k',linestyle_zero=':',linewidth_zero=1.5,alpha_zero=0.3,\\n inset=False,inset_xrange=[],inset_yrange=[],inset_position=[0.65,0.60,0.20,0.20],inset_features=False,\\n output='',multiplot=False,multipage=False,layout=[1,1],figsize=[],tight=True,\\n interactive=False,**kwargs):\\n\\n# keyword parameters (for backward compatability)\\n for k in ['showZero','showzero']: show_zero=kwargs.get(k,show_zero)\\n for k in ['showNoise','noise','uncertainty','shownoise','showuncertainty','show_uncertainty']: show_noise=kwargs.get(k,show_noise)\\n\\n for k in ['line_style','lineStyle','ls','linestyles','line_styles']: linestyle=kwargs.get(k,linestyle)\\n for k in ['line_width','lineWidth','width','lw','linewidths','line_widths']: linewidth=kwargs.get(k,linewidth)\\n for k in ['colors','colour','colours']: color=kwargs.get(k,color)\\n for k in ['colorScheme','color_scheme','colorscheme','colorMap','color_map']: colormap=kwargs.get(k,colormap)\\n\\n for k in ['colornoise','colorNoise','colorUnc','coloruncertainty','color_uncertainty','colorUncertainty']: color_noise=kwargs.get(k,color_noise)\\n for k in ['linestylenoise','line_style_noise','linestyleNoise']: linestyle_noise=kwargs.get(k,linestyle_noise)\\n for k in ['linewidthnoise','linewidthNoise','line_width_noise']: linewidth_noise=kwargs.get(k,linewidth_noise)\\n for k in ['alphanoise','alphaNoise']: alpha_noise=kwargs.get(k,alpha_noise)\\n\\n for k in ['colorzero','colorZero']: color_zero=kwargs.get(k,color_zero)\\n for k in ['linestylezero','line_style_zero','linestyleZero']: linestyle_zero=kwargs.get(k,linestyle_zero)\\n for k in ['linewidthzero','linewidthZero','line_width_zero']: linewidth_zero=kwargs.get(k,linewidth_zero)\\n for k in ['alphazero','alphaZero']: alpha_zero=kwargs.get(k,alpha_zero)\\n\\n for k in ['colorcomparison','colorComparison']: color_comparison=kwargs.get(k,color_comparison)\\n for k in ['linestyleComparison','line_style_comparison','linestylecomparison']: linestyle_comparison=kwargs.get(k,linestyle_comparison)\\n for k in ['linewidthcomparison','linewidthComparison','line_width_comparison']: linewidth_comparison=kwargs.get(k,linewidth_comparison)\\n for k in ['alphacomparison','alphaComparison']: alpha_comparison=kwargs.get(k,alpha_comparison)\\n\\n for k in ['colorresidual','colorResidual']: color_residual=kwargs.get(k,color_residual)\\n for k in ['linestyleresidual','line_style_residual','linestyleResidual']: linestyle_residual=kwargs.get(k,linestyle_residual)\\n for k in ['linewidthresidual','linewidthResidual','line_width_residual']: linewidth_residual=kwargs.get(k,linewidth_residual)\\n for k in ['alpharesidual','alphaResidual']: alpha_residual=kwargs.get(k,alpha_residual)\\n\\n for k in ['bands']: band=kwargs.get(k,band)\\n if len(band) == 2 and isinstance(band[0],list) == False: band = [band]\\n for k in ['bandcolors','bandcolor','band_colors']: band_color=kwargs.get(k,band_color)\\n for k in ['bandalphas','band_alphas','bandalpha']: band_alpha=kwargs.get(k,band_alpha)\\n for k in ['band_labels','bandlabel','bandlabels']: band_label=kwargs.get(k,band_label)\\n for k in ['band_label_positions','bandlabelposition','bandlabelpositions']: band_label_position=kwargs.get(k,band_label_position)\\n for k in ['bandwidth','bandwidths','band_widths']: band_width=kwargs.get(k,band_width)\\n for par in [band_color,band_alpha,band_label,band_label_position,band_width]:\\n if not isinstance(par,list): par = [par]*len(band)\\n if len(par) < len(band): par.extend([par[-1] for x in range(len(band)-len(par))])\\n\\n for k in ['legends','label','labels']: legend=kwargs.get(k,legend)\\n if not isinstance(legend,list): legend = [legend]\\n for k in ['legendfontscale','legendFontscale']: legend_fontscale=kwargs.get(k,legend_fontscale)\\n legend_fontscale=legend_fontscale*fontscale\\n for k in ['legendLocation','legendlocation','labelLocation','labellocation','label_location']: legend_location=kwargs.get(k,legend_location)\\n\\n for k in ['xrange','x_range','wave_range','wrange','wrng']: xrng=kwargs.get(k,xrng)\\n if not isinstance(xrng,list): xrng = [xrng]\\n for k in ['yrange','y_range','flux_range','frange','frng']: yrng=kwargs.get(k,yrng)\\n if not isinstance(yrng,list): yrng = [yrng]\\n\\n for k in ['multilayout','multiLayout','multi_layout']: layout=kwargs.get(k,layout)\\n for k in ['file','filename']: output=kwargs.get(k,output)\\n if not isinstance(output,str): output=''\\n filetype = '.pdf'\\n if output!='': filetype=output.split('.')[-1]\\n\\n if comparison != None and isinstance(comparison,splat.Spectrum) == False and isinstance(comparison,list) == False: \\n print('plotSpectrum() Warning: comparison spectrum should be a splat Spectrum object, you passed {}'.format(comparison))\\n comparison = None\\n\\n# some plotting constants\\n xlabel_default = 'Wavelength'\\n ylabel_deafult = 'Flux'\\n\\n# telluric bands in micron\\n telluric_bands = [[1.1,1.2]*u.micron,[1.3,1.5]*u.micron,[1.75,2.0]*u.micron]\\n\\n# assign features by group\\n if not isinstance(features,list): features = [features]\\n if ldwarf==True or mdwarf==True: features.extend(['k','na','feh','tio','co','h2o','h2'])\\n if tdwarf==True: features.extend(['k','ch4','h2o','h2'])\\n if young==True: features.extend(['vo'])\\n if binary==True: features.extend(['sb'])\\n\\n# clean repeats in features while maintaining order - set does not do this\\n if len(features)>0:\\n fea = []\\n for i in features:\\n if i not in fea: fea.append(i)\\n features = fea\\n\\n\\n# if a list is passed, use this list\\n splist = copy.deepcopy(inp)\\n if isinstance(splist,list) == False: splist = [splist]\\n \\n# set up for multiplot\\n if len(splist) == 1: multiplot = False\\n \\n# array of lists => force multiplot\\n elif len(splist) > 1 and isinstance(splist[0],list) == True: multiplot = True\\n else: pass\\n\\n# reformat array of spectra of multiplot is used (i.e., user forgot to set)\\n if multiplot == True and isinstance(splist[0],splat.Spectrum):\\n splist = [[s] for s in splist]\\n\\n elif multiplot == False and isinstance(splist[0],splat.Spectrum):\\n splist = [splist]\\n \\n# flatten array if multiplot is not set\\n elif multiplot == False and isinstance(splist[0],list) and len(splist) > 1:\\n splist = [[item for sublist in splist for item in sublist]] # flatten\\n else: pass\\n\\n# total number of spectra - use to assign default legends\\n allsps = [item for sublist in splist for item in sublist] # Total number of spectra\\n if len(legend) == 0: legend=[sp.name for sp in allsps]\\n if len(legend) < len(allsps):\\n legend.extend([allsps[i].name for i in range(len(legend),len(allsps)-len(legend))])\\n \\n\\n# now run a loop through the input subarrays\\n plt.close('all')\\n\\n# set up here for multiple file output\\n nplot = 1\\n if multipage == True or multiplot == True:\\n nplot = layout[0]*layout[1]\\n numpages = int(len(splist) / nplot) + 1\\n if (len(splist) % nplot == 0):\\n numpages -= 1\\n fig = []\\n \\n if multipage == True and filetype.lower() == 'pdf':\\n pdf_pages = PdfPages(output)\\n \\n if multipage == False:\\n if len(splist) > 1:\\n filebase = output.replace('.{}'.format(filetype),'')\\n files = [filebase+'{}.'.format(i+1)+filetype for i in numpy.arange(len(splist))]\\n else:\\n files = [output]\\n\\n pg_n = 0 # page counter\\n plt_n = 0 # plot per page counter\\n lg_n = 0 # legend per plot counter\\n\\n for plts,sp in enumerate(splist):\\n# set specific plot parameters\\n if not isinstance(sp[0],splat.Spectrum):\\n raise ValueError('\\\\nInput to plotSpectrum has wrong format:\\\\n\\\\n{}\\\\n\\\\n'.format(sp[0]))\\n\\n# set up plotting defaults for the list of spectra - REPLACE THIS\\n if not isinstance(zeropoint,list): zeropoint = [zeropoint]*len(sp)\\n if len(zeropoint) < len(sp): zeropoint.extend([zeropoint[-1] for x in range(len(sp)-len(zeropoint))])\\n if not isinstance(color,list): color = [color]*len(sp)\\n if len(color) < len(sp): color.extend([color[-1] for x in range(len(sp)-len(color))])\\n if not isinstance(linestyle,list): linestyle = [linestyle]*len(sp)\\n if len(linestyle) < len(sp): linestyle.extend([linestyle[-1] for x in range(len(sp)-len(linestyle))])\\n if not isinstance(linewidth,list): linewidth = [linewidth]*len(sp)\\n if len(linewidth) < len(sp): linewidth.extend([linewidth[-1] for x in range(len(sp)-len(linewidth))])\\n if not isinstance(alpha,list): alpha = [alpha]*len(sp)\\n if len(alpha) < len(sp): alpha.extend([alpha[-1] for x in range(len(sp)-len(alpha))])\\n if not isinstance(color_noise,list): color_noise = [color_noise]*len(sp)\\n if len(color_noise) < len(sp): color_noise.extend([color_noise[-1] for x in range(len(sp)-len(color_noise))])\\n if not isinstance(linestyle_noise,list): linestyle_noise = [linestyle_noise]*len(sp)\\n if len(linestyle_noise) < len(sp): linestyle_noise.extend([linestyle_noise[-1] for x in range(len(sp)-len(linestyle_noise))])\\n if not isinstance(linewidth_noise,list): linewidth_noise = [linewidth_noise]*len(sp)\\n if len(linewidth_noise) < len(sp): linewidth_noise.extend([linewidth_noise[-1] for x in range(len(sp)-len(linewidth_noise))])\\n if not isinstance(alpha_noise,list): alpha_noise = [alpha_noise]*len(sp)\\n if len(alpha_noise) < len(sp): alpha_noise.extend([alpha_noise[-1] for x in range(len(sp)-len(color_noise))])\\n if not isinstance(color_comparison,list): color_comparison = [color_comparison]*len(sp)\\n if len(color_comparison) < len(sp): color_comparison.extend([color_comparison[-1] for x in range(len(sp)-len(color_comparison))])\\n if not isinstance(linestyle_comparison,list): linestyle_comparison = [linestyle_comparison]*len(sp)\\n if len(linestyle_comparison) < len(sp): linestyle_comparison.extend([linestyle_comparison[-1] for x in range(len(sp)-len(linestyle_comparison))])\\n if not isinstance(linewidth_comparison,list): linewidth_comparison = [linewidth_comparison]*len(sp)\\n if len(linewidth_comparison) < len(sp): linewidth_comparison.extend([linewidth_comparison[-1] for x in range(len(sp)-len(linewidth_comparison))])\\n if not isinstance(alpha_comparison,list): alpha_comparison = [alpha_comparison]*len(sp)\\n if len(alpha_comparison) < len(sp): alpha_comparison.extend([alpha_comparison[-1] for x in range(len(sp)-len(alpha_comparison))])\\n\\n# settings that work if the spectrum was read in as legitmate Spectrum object\\n try:\\n xlabel = kwargs.get('xlabel','{} ({})'.format(sp[0].wave_label,sp[0].wave.unit))\\n ylabel = kwargs.get('ylabel','{} ({})'.format(sp[0].flux_label,sp[0].flux.unit))\\n except:\\n xlabel = kwargs.get('xlabel',xlabel_default)\\n ylabel = kwargs.get('ylabel',ylabel_default)\\n# initial plot range\\n bound = [numpy.nanmin(sp[0].wave.value),numpy.nanmax(sp[0].wave.value)]\\n ymax = [numpy.nanquantile(s.flux.value,0.98) for s in sp]\\n bound.extend(numpy.array([-0.02,1.3])*numpy.nanmax(ymax)+\\\\\\n numpy.array([numpy.nanmin(zeropoint),numpy.nanmax(zeropoint)+stack*(len(sp)-1)]))\\n\\n# set colormap if provided\\n if colormap != None:\\n values = numpy.arange(len(sp))\\n color_map = plt.get_cmap(colormap)\\n norm = colmap.Normalize(vmin=0, vmax=1.0*values[-1])\\n scalarMap = cm.ScalarMappable(norm=norm, cmap=color_map)\\n for i in range(len(sp)): color[i] = scalarMap.to_rgba(values[i])\\n\\n# GENERATE PLOTS\\n if multiplot == True or multipage == True:\\n plt_n = plts % nplot\\n if (plt_n == 0):\\n fig.append(plt.figure())\\n pg_n += 1\\n ax = fig[pg_n-1].add_subplot(layout[0], layout[1], plt_n+1)\\n \\n# plotting a single plot with all spectra\\n else:\\n plt.close('all')\\n plt_n = 0\\n fig = []\\n if len(figsize)>0: fig.append(plt.figure(figsize=figsize))\\n else: fig.append(plt.figure())\\n ax = fig[0].add_subplot(111)\\n \\n for ii, a in enumerate(sp):\\n# zeropoint and stack\\n flx = [i+zeropoint[ii] for i in a.flux.value]\\n if stack > 0: flx = [f + (len(sp)-ii-1)*stack for f in flx]\\n ax.plot(a.wave.value,flx,color=color[ii],linestyle=linestyle[ii], lw=linewidth[ii], alpha=alpha[ii], zorder = 10, label = legend[lg_n]) \\n\\n# add comparison\\n if comparison != None:\\n# zeropoint and stack\\n cflx = [i+zeropoint[ii] for i in comparison.flux.value]\\n if stack > 0: cflx = [f + (len(sp)-ii-1)*stack for f in cflx]\\n ax.plot(comparison.wave.value,cflx,color=color_comparison[ii],linestyle=linestyle_comparison[ii], lw=linewidth_comparison[ii], alpha=alpha_comparison[ii], zorder = 10)\\n \\n# add residual\\n if residual == True and len(sp) == 2:\\n # Save flux values from first spectrum\\n if ii == 0:\\n flx0 = [f - (len(sp)-ii-1)*stack for f in flx]\\n \\n # Subtract fluxes and plot\\n elif ii == 1:\\n res = [flx0[f_n] - f for f_n, f in enumerate(flx)]\\n ax.plot(a.wave.value, res, alpha = alpha_residual[ii], color = color_residual[ii], linsetyle=linestyle_residual[ii], lw=linewidth_residual[ii])\\n \\n # Fix bound[2] if residual goes below 0\\n if numpy.nanmin(res) < bound[2]:\\n b0 = numpy.argmin(a.wave.value[a.wave.value > bound[0]])\\n b1 = numpy.argmax(a.wave.value[a.wave.value < bound[1]])\\n bound[2] = numpy.nanmin(res[b0:b1])\\n\\n# noise\\n if show_noise == True:\\n ns = [i+zeropoint[ii] for i in a.noise.value]\\n ax.plot(a.wave.value,ns,color=color_noise[ii],linestyle=linestyle_noise[ii],alpha=alpha_noise[ii], lw=linewidth_noise[ii], zorder = 10)\\n\\n# zeropoint\\n if show_zero == True:\\n ze = numpy.ones(len(a.flux))*zeropoint[ii]\\n ax.plot(a.wave.value,ze,color=color[ii],linestyle=linestyle_zero,alpha=alpha_zero,lw=linewidth_zero, zorder = 10)\\n\\n# save maximum flux among all spectra for plotting\\n# THIS IS VERY SLOW AND IT WOULD BE BETTER TO FIND AN ALTERNATE APPROACH\\n if len(features)>0:\\n f = interp1d(a.wave,flx,bounds_error=False,fill_value=0.)\\n if ii == 0: \\n wvmax = numpy.linspace(bound[0],bound[1],nsamples)\\n flxmax = numpy.array(f(wvmax))\\n else: flxmax = numpy.maximum(flxmax,numpy.array(f(wvmax)))\\n\\n# legend counter\\n lg_n = lg_n + 1 # Increment legend\\n\\n\\n# label features\\n# THIS NEEDS TO BE FIXED WITH GRETEL'S STUFF\\n if len(features) > 0:\\n yoff = 0.02*(bound[3]-bound[2]) # label offset\\n fontsize = int((10-numpy.nanmin([(layout[0]*layout[1]-1),6]))*fontscale)\\n for ftr in features:\\n ftr = ftr.lower()\\n if ftr in FEATURE_LABELS:\\n ftrc = checkDict(ftr,FEATURE_LABELS)\\n if ftrc != False:\\n for ii,waveRng in enumerate(FEATURE_LABELS[ftrc]['wavelengths']):\\n wRng = waveRng.to(sp[0].wave.unit).value\\n# features must be contained in plot range (may change this)\\n if numpy.nanmin(wRng) > bound[0] and numpy.nanmax(wRng) < bound[1]:\\n wfeature = numpy.where(numpy.logical_and(wvmax >= numpy.nanmin(wRng),wvmax <= numpy.nanmax(wRng)))\\n if len(wvmax[wfeature]) == 0: wfeature = numpy.argmax(numpy.absolute(wvmax-numpy.nanmedian(wRng)))\\n y = numpy.nanmax(flxmax[wfeature])+yoff\\n flxmax[wfeature] = flxmax[wfeature]+3.*yoff\\n\\n if FEATURE_LABELS[ftrc]['type'] == 'band':\\n ax.plot(wRng,[y+yoff]*2,color='k',linestyle='-')\\n ax.plot([wRng[0]]*2,[y,y+yoff],color='k',linestyle='-')\\n ax.text(numpy.mean(wRng),y+1.5*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=fontsize)\\n else:\\n for w in wRng: ax.plot([w]*2,[y,y+yoff],color='k',linestyle='-')\\n ax.text(numpy.mean(wRng),y+1.5*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=fontsize)\\n bound[3] = numpy.nanmax([numpy.nanmax(flxmax)+2.*yoff,bound[3]])\\n\\n# add grid\\n if grid == True: ax.grid() \\n\\n# axis labels \\n fontsize = (numpy.round(numpy.max([13./((layout[0]*layout[1])**0.33),5]))) * fontscale\\n legend_fontsize = (13-numpy.min([(layout[0]*layout[1]-1),8])) * legend_fontscale\\n ax.set_xlabel(xlabel, fontsize = fontsize)\\n ax.set_ylabel(ylabel, fontsize = fontsize)\\n ax.tick_params(axis='x', labelsize=fontsize)\\n ax.tick_params(axis='y', labelsize=fontsize)\\n\\n# add title\\n if title!='': ax.set_title(title)\\n\\n# log scale?\\n if kwargs.get('xlog',False): ax.set_xscale('log',nonposx='clip')\\n if kwargs.get('ylog',False): ax.set_yscale('log',nonposy='clip')\\n\\n# place legend\\n if len(legend) > 0:\\n if legend_location == 'outside':\\n box = ax.get_position()\\n ax.set_position([box.x0, box.y0 + box.height * 0.15, box.width * 0.7, box.height * 0.7])\\n ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), prop={'size':legend_fontsize})\\n else:\\n ax.legend(loc=legend_location, prop={'size':legend_fontsize})\\n bound[3] = bound[3]+0.1*(bound[3]-bound[2]) # extend axis for in-plot legends\\n\\n# overplot telluric absorption\\n if telluric == True:\\n yoff = 0.02*(bound[3]-bound[2]) # label offset\\n for waveRng in telluric_bands:\\n wR = waveRng.to(sp[0].wave.unit).value\\n rect = patches.Rectangle((wR[0],bound[2]),wR[1]-wR[0],bound[3]-bound[2],facecolor=color_telluric,alpha=alpha_telluric,color=color_telluric)\\n ax.add_patch(rect)\\n ax.text(numpy.mean(wR),bound[2]+3*yoff,r'$\\\\oplus$',horizontalalignment='center',fontsize=fontsize)\\n\\n# overplot color swaths for pre-specified bands\\n if len(band) > 0:\\n for i,b in enumerate(band):\\n if not isinstance(b,list): \\n try: b = [float(b)-0.5*band_width,float(b)+0.5*band_width]\\n except:\\n print('\\\\nWarning: plotSpectrum bands variables should be array of 2-element arrays; you passed {}'.format(band))\\n b = [0.,0.]\\n rect = patches.Rectangle((b[0],bound[2]),b[1]-b[0],bound[3]-bound[2],facecolor=band_color[i],color=band_color[i],alpha=band_alpha[i])\\n ax.add_patch(rect)\\n if band_label_position[i].lower() == 'top':\\n ax.text(numpy.mean(b),bound[3]-3*yoff,band_label[i],horizontalalignment='center',fontsize=fontsize)\\n elif band_label_position[i].lower() == 'middle':\\n ax.text(numpy.mean(b),0.5*(bound[2]+bound[3]),band_label[i],horizontalalignment='center',fontsize=fontsize)\\n else:\\n ax.text(numpy.mean(b),bound[2]+3*yoff,band_label[i],horizontalalignment='center',fontsize=fontsize)\\n\\n# place inset - RIGHT NOW ONLY SETTING LIMITS WITH FIRST SPECTRUM IN LIST\\n if inset == True and len(inset_xrange) == 2:\\n ax_inset = fig[pg_n-1].add_axes(inset_position) #, axisbg='white')\\n bound2 = inset_xrange\\n if len(inset_yrange) == 0:\\n b0 = numpy.argmax(sp[0].wave.value > bound2[0])\\n b1 = numpy.argmin(sp[0].wave.value < bound2[1])\\n inset_yrange = [numpy.nanmin(sp[0].flux.value[b0:b1]),numpy.nanmax(sp[0].flux.value[b0:b1])]\\n bound2.extend(inset_yrange)\\n db = (bound2[3]-bound2[2])\\n bound2[2] = bound2[2]-0.05*db\\n bound2[3] = bound2[3]+0.05*db\\n ax_inset.axis(bound2)\\n inset_fontsize = fontsize*0.7\\n\\n for ii,a in enumerate(sp):\\n flx = [i+zeropoint[ii] for i in a.flux.value]\\n ax_inset.plot(a.wave.value,flx,color=colors[ii],linestyle=linestyle[ii],linewidth=linewidth[ii],alpha=alpha[ii]) \\n ax_inset.set_xlabel('')\\n ax_inset.set_ylabel('')\\n ax_inset.tick_params(axis='x', labelsize=inset_fontsize)\\n ax_inset.tick_params(axis='y', labelsize=inset_fontsize)\\n# ax_inset.legend()\\n\\n# inset feature labels\\n if len(inset_features) > 0:\\n yoff = 0.05*(bound2[3]-bound2[2])\\n for ftr in inset_features:\\n ftrc = checkDict(ftr,FEATURE_LABELS)\\n if ftrc != False:\\n for ii,waveRng in enumerate(FEATURE_LABELS[ftrc]['wavelengths']):\\n wRng = waveRng.to(sp[0].wave.unit).value\\n if (numpy.min(wRng) > bound2[0] and numpy.max(wRng) < bound2[1]):\\n wfeature = numpy.where(numpy.logical_and(wvmax >= numpy.nanmin(wRng),wvmax <= numpy.nanmax(wRng)))\\n if len(wvmax[wfeature]) == 0: wfeature = numpy.argmax(numpy.absolute(wvmax-numpy.nanmedian(wRng)))\\n y = numpy.nanmax(flxmax[wfeature])+yoff\\n flxmax[wfeature] = flxmax[wfeature]+3.*yoff\\n \\n if FEATURE_LABELS[ftrc]['type'] == 'band':\\n ax_inset.plot(wR,[y+yoff]*2,color='k',linestyle='-')\\n ax_inset.plot([wR[0]]*2,[y,y+yoff],color='k',linestyle='-')\\n ax_inset.text(numpy.mean(wR),y+2*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=inset_fontsize)\\n else:\\n for w in waveRng:\\n ax_inset.plot([w]*2,[y,y+yoff],color='k',linestyle='-')\\n ax_inset.text(numpy.mean(wR),y+2*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=inset_fontsize)\\n waveRng = [wR[0]-0.02,wR[1]+0.02] # for overlap\\n \\n# update offset\\n if len(inset_features) > 0: bound2[3] = numpy.nanmax([bound2[3],numpy.nanmax(flxmax)+5.*yoff])\\n ax_inset.axis(bound2)\\n\\n# finalize bounding\\n if len(xrng) > 0: bound[0:2] = xrng\\n if len(yrng) > 0: bound[2:4] = yrng\\n if isUnit(bound[0]): bound = [x.value for x in bound]\\n ax.axis(bound)\\n \\n# save to file or display\\n# ERROR HERE - CHECK WHAT FILES\\n if multipage == False:\\n if files[plts] != '' and (plts % nplot == 3 or plts == len(splist)-1):\\n if kwargs.get('tight',True) == True: \\n plt.savefig(files[plts], bbox_inches='tight')\\n else:\\n plt.savefig(files[plts])\\n if output == '' and not kwargs.get('web',False):\\n plt.show()\\n if (kwargs.get('interactive',False) != False): plt.ion()\\n else: plt.ioff()\\n\\n\\n# save figures in multipage format and write off pdf file\\n if multipage == True: \\n for pg_n in numpy.arange(numpages):\\n# fig[pg_n].text(0.5, 0.04, xlabel, ha = 'center', va = 'center')\\n# fig[pg_n].text(0.06, 0.5, ylabel, ha = 'center', va = 'center', rotation = 'vertical')\\n fig[pg_n].tight_layout\\n fig[pg_n].suptitle(title, fontsize = int(14*fontsize), fontweight = 'bold')\\n pdf_pages.savefig(fig[pg_n])\\n if filetype.lower() == 'pdf':\\n pdf_pages.close()\\n\\n plt.clf()\\n return fig\",\n \"def test4():\\n\\t\\n\\tprint('This takes a while to compute - be patient!')\\n\\t\\n\\td = np.linspace(-15000,15000,300)\\n\\t#Voigt\\n\\t#p_dict = {'Bfield':700,'rb85frac':1,'Btheta':90*np.pi/180,'lcell':75e-3,'T':84,'Dline':'D2','Elem':'Cs'}\\n\\tp_dict = {'Bfield':1000,'rb85frac':1,'Btheta':88*np.pi/180,'Bphi':00*np.pi/180,'lcell':75e-3,'T':93,'Dline':'D2','Elem':'Cs'}\\n\\tpol = np.array([1.0,0.0,0.0])\\n\\tTVx = get_spectra(d,pol,p_dict,outputs=['I_M45','I_P45','Ix','Iy','S0','Iz'])\\n\\t\\n\\tfig2 = plt.figure()\\n\\tax1a = fig2.add_subplot(411)\\n\\tax2a = fig2.add_subplot(412,sharex=ax1a)\\n\\tax3a = fig2.add_subplot(413,sharex=ax1a)\\n\\tax4a = fig2.add_subplot(414,sharex=ax1a)\\n\\t\\n\\tax1a.plot(d,TVx[0],'r',lw=2,label=r'$I_{-45}$')\\n\\tax2a.plot(d,TVx[1],'b',lw=2,label=r'$I_{+45}$')\\n\\tax3a.plot(d,TVx[2],'r',lw=2,label=r'$I_x$')\\n\\tax4a.plot(d,TVx[3],'b',lw=2,label=r'$I_y$')\\n\\tax4a.plot(d,TVx[0]+TVx[1],'r:',lw=3.5,label=r'$I_{+45}+I_{-45}$')\\n\\tax4a.plot(d,TVx[2]+TVx[3],'k:',lw=2.5,label=r'$I_x + I_y$')\\n\\tax4a.plot(d,TVx[4],'g--',lw=1.5,label='$S_0$')\\n#\\tax4a.plot(d,TVx[5],'c--',lw=2.5,label='$I_z$')\\n\\t\\n\\t\\n\\tax4a.set_xlabel('Detuning (MHz)')\\n\\tax1a.set_ylabel('I -45')\\n\\tax2a.set_ylabel('I +45')\\n\\tax3a.set_ylabel('Ix')\\n\\tax4a.set_ylabel('Iy')\\n\\t\\n\\tax4a.set_xlim(d[0],d[-1]+3000)\\n\\tax4a.legend(loc=0)\\n\\t\\n\\tplt.show()\",\n \"def plot_multisite_rms(params, phot_data, mag_col, merr_col, qc_col, plot_filename, log):\\n\\n # Plot a multi-site initial RMS diagram for reference\\n phot_statistics = np.zeros( (len(phot_data),4) )\\n (phot_statistics[:,0],werror) = plot_rms.calc_weighted_mean_2D(phot_data, mag_col, merr_col, qc_col=qc_col)\\n phot_statistics[:,1] = plot_rms.calc_weighted_rms(phot_data, phot_statistics[:,0], mag_col, merr_col, qc_col=qc_col)\\n\\n text_filename = plot_filename.replace('.png', '.txt')\\n f = open(path.join(params['red_dir'],text_filename),'w')\\n f.write('# Star_index wMean_mag RMS\\\\n')\\n for j in range(0,len(phot_statistics),1):\\n f.write(str(j)+' '+str(phot_statistics[j,0])+' '+str(phot_statistics[j,1])+'\\\\n')\\n f.close()\\n\\n fig = plt.figure(3,(10,10))\\n plt.rcParams.update({'font.size': 18})\\n mask = np.logical_and(phot_statistics[:,0] > 0.0, phot_statistics[:,1] > 0.0)\\n plt.plot(phot_statistics[mask,0], phot_statistics[mask,1], 'k.',\\n markersize=0.5, label='Weighted RMS')\\n plt.yscale('log')\\n plt.xlabel('Weighted mean mag')\\n plt.ylabel('RMS [mag]')\\n plt.grid()\\n l = plt.legend()\\n plt.tight_layout()\\n [xmin,xmax,ymin,ymax] = plt.axis()\\n plt.axis([xmin,xmax,1e-3,5.0])\\n plot_file = path.join(params['red_dir'],plot_filename)\\n plt.savefig(plot_file)\\n log.info('Output RMS plot to '+plot_filename)\\n plt.close(3)\",\n \"def plot_spectrum(spec, config):\\n for v in config.getpars():\\n plot.plot_projection(spec, v)\",\n \"def plot_coefs(results):\\n coefs_noisy = pd.concat([\\n arr_to_df(results['obj_noisy'], n_arr, 'obj'),\\n vec_to_df(results['dist_obj'], n_arr, 'obj'),\\n arr_to_df(results['pos_noisy'], n_arr, 'pos'),\\n vec_to_df(results['dist_pos'], n_arr, 'pos'),\\n arr_to_df(results['neg_noisy'], n_arr, 'neg'),\\n vec_to_df(results['dist_neg'], n_arr, 'neg')\\n ])\\n\\n xlim = (min(n_arr), max(n_arr))\\n ylim = (-1.1, 1.1)\\n\\n g = sns.FacetGrid(coefs_noisy, row = 'id', col = 'component', xlim = xlim,\\n ylim = ylim)\\n g.map(sns.pointplot, 'n', 'value', order = n_arr)\\n g.set_xticklabels(rotation = 45)\\n\\n for i, val in enumerate(results['obj_true']):\\n ax = g.axes[0, i]\\n ax.hlines(val, *ax.get_xlim())\\n for i, val in enumerate(results['pos_true']):\\n ax = g.axes[1, i]\\n ax.hlines(0, *ax.get_xlim(), linestyle = '--', color = 'red')\\n ax.hlines(val, *ax.get_xlim())\\n for i, val in enumerate(results['neg_true']):\\n ax = g.axes[2, i]\\n ax.hlines(0, *ax.get_xlim(), linestyle = '--', color = 'red')\\n ax.hlines(val, *ax.get_xlim())\",\n \"def main():\\n parser = argparse.ArgumentParser(\\n description=\\\"Generate bar plots comparing Matlab solvers to RLSO\\\"\\n )\\n parser.add_argument(\\n \\\"--path\\\", type=str, default=None, help=\\\"the path to saved testing data for RLSO\\\"\\n )\\n parser.add_argument(\\n \\\"--trials\\\",\\n type=int,\\n default=1000,\\n help=\\\"Number of test problems to use defaults to 1000\\\",\\n )\\n parser.add_argument(\\n \\\"--savestring\\\",\\n type=str,\\n default=None,\\n help=\\\"Name to save our plot as. Defaults to random int .png\\\",\\n )\\n parser.add_argument(\\n \\\"--titlestring\\\",\\n type=str,\\n default=None,\\n help=\\\"String to append to our plot title. Defaults to None\\\",\\n )\\n parser.add_argument(\\n \\\"--excludeinter\\\",\\n type=bool,\\n default=True,\\n help=\\\"Exclude interior point method form testing. Reasons Convex only, and cannot set starting point. Default True\\\",\\n )\\n\\n args = parser.parse_args()\\n\\n if args.path is None:\\n print(\\\"Path to pickle data needed!\\\")\\n return\\n\\n pickle_savepath = args.path\\n with open(pickle_savepath, \\\"rb\\\") as pickle_file:\\n pickle_tuple = pickle.load(pickle_file)\\n\\n complex_dic = pickle_tuple[4]\\n lastbest = unravel_c_dic_lastbest(complex_dic)\\n Abx0 = generate_Abx0(complex_dic, lastbest)\\n\\n if args.trials is None:\\n trials = 1000\\n else:\\n trials = args.trials\\n if args.savestring is None:\\n save_string = str(np.random.randint(low=1e15, high=9e15)) + \\\".png\\\"\\n else:\\n save_string = args.savestring\\n\\n start = time.time()\\n print(f\\\"start time {start}\\\")\\n\\n solutions = []\\n for tuples in Abx0[:trials]:\\n solutions.append(quad_solve(tuples, printout=False))\\n end = time.time()\\n print(f\\\"Matlab run time: {end - start}\\\")\\n\\n rlso = []\\n active = []\\n inter = []\\n trust = []\\n for [x, y, z, w] in solutions:\\n rlso.append(x)\\n active.append(y)\\n inter.append(z)\\n trust.append(w)\\n title_string = args.titlestring\\n plot_box(\\n rlso,\\n active,\\n inter,\\n trust,\\n title_string,\\n save_string,\\n exclude_inter=args.excludeinter,\\n )\\n\\n return\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66833836","0.66289103","0.6578164","0.6558594","0.65089476","0.65080667","0.6504561","0.6472419","0.64677024","0.6441997","0.63957804","0.63513416","0.6350512","0.6309037","0.62910414","0.6289601","0.6281238","0.6271773","0.6265851","0.6262609","0.62506026","0.6246886","0.62439317","0.62152183","0.6215066","0.620278","0.62012637","0.6195723","0.61866933","0.61795425","0.6177988","0.61388683","0.61164165","0.6116064","0.61149067","0.61076146","0.6099175","0.60912365","0.60830194","0.6071403","0.6066102","0.60552853","0.604243","0.60404503","0.60397184","0.6039706","0.603565","0.60052884","0.59948695","0.598566","0.5982977","0.59785646","0.5951785","0.5944909","0.594234","0.59399384","0.5938838","0.59215766","0.5917417","0.5912534","0.58935964","0.5875594","0.5874114","0.5867063","0.5851534","0.58470225","0.5846304","0.58458203","0.58433205","0.58349144","0.58289057","0.5825598","0.58248556","0.58212584","0.58032703","0.5803172","0.5800707","0.57984114","0.57959086","0.57912236","0.57910115","0.5790091","0.57835674","0.5779429","0.5778493","0.5778306","0.57781196","0.5776738","0.5775314","0.577219","0.57686484","0.57637227","0.5759147","0.5758678","0.5744237","0.57441133","0.57430553","0.5741151","0.57401705","0.5739331"],"string":"[\n \"0.66833836\",\n \"0.66289103\",\n \"0.6578164\",\n \"0.6558594\",\n \"0.65089476\",\n \"0.65080667\",\n \"0.6504561\",\n \"0.6472419\",\n \"0.64677024\",\n \"0.6441997\",\n \"0.63957804\",\n \"0.63513416\",\n \"0.6350512\",\n \"0.6309037\",\n \"0.62910414\",\n \"0.6289601\",\n \"0.6281238\",\n \"0.6271773\",\n \"0.6265851\",\n \"0.6262609\",\n \"0.62506026\",\n \"0.6246886\",\n \"0.62439317\",\n \"0.62152183\",\n \"0.6215066\",\n \"0.620278\",\n \"0.62012637\",\n \"0.6195723\",\n \"0.61866933\",\n \"0.61795425\",\n \"0.6177988\",\n \"0.61388683\",\n \"0.61164165\",\n \"0.6116064\",\n \"0.61149067\",\n \"0.61076146\",\n \"0.6099175\",\n \"0.60912365\",\n \"0.60830194\",\n \"0.6071403\",\n \"0.6066102\",\n \"0.60552853\",\n \"0.604243\",\n \"0.60404503\",\n \"0.60397184\",\n \"0.6039706\",\n \"0.603565\",\n \"0.60052884\",\n \"0.59948695\",\n \"0.598566\",\n \"0.5982977\",\n \"0.59785646\",\n \"0.5951785\",\n \"0.5944909\",\n \"0.594234\",\n \"0.59399384\",\n \"0.5938838\",\n \"0.59215766\",\n \"0.5917417\",\n \"0.5912534\",\n \"0.58935964\",\n \"0.5875594\",\n \"0.5874114\",\n \"0.5867063\",\n \"0.5851534\",\n \"0.58470225\",\n \"0.5846304\",\n \"0.58458203\",\n \"0.58433205\",\n \"0.58349144\",\n \"0.58289057\",\n \"0.5825598\",\n \"0.58248556\",\n \"0.58212584\",\n \"0.58032703\",\n \"0.5803172\",\n \"0.5800707\",\n \"0.57984114\",\n \"0.57959086\",\n \"0.57912236\",\n \"0.57910115\",\n \"0.5790091\",\n \"0.57835674\",\n \"0.5779429\",\n \"0.5778493\",\n \"0.5778306\",\n \"0.57781196\",\n \"0.5776738\",\n \"0.5775314\",\n \"0.577219\",\n \"0.57686484\",\n \"0.57637227\",\n \"0.5759147\",\n \"0.5758678\",\n \"0.5744237\",\n \"0.57441133\",\n \"0.57430553\",\n \"0.5741151\",\n \"0.57401705\",\n \"0.5739331\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6415346"},"document_rank":{"kind":"string","value":"10"}}},{"rowIdx":21288,"cells":{"query":{"kind":"string","value":"plot RMSE versus parameter value for numerical experiment RMSE is calculated based on full fem output converted to LOS"},"document":{"kind":"string","value":"def plot_directory_surface_rmse(path, vals, param='Vp'):\n\n unw = '/home/scott/data/insar/cvz/t2282/geo/geo_stack282_8rlks.unw'\n incidence = '/home/scott/data/insar/cvz/t2282/aux_files/geo_incidence_8rlks.unw'\n dem = '/home/scott/data/dems/cgiar/uturuncu_1000_1000.tif'\n #surface = '/home/scott/research/models/pylith/3d/uturuncu_layered/output/step01/surface.h5'\n #geosurface = '/home/scott/research/models/pylith/scripts/geo_fem_Uz.tif'\n\n plt.figure()\n outdirs = np.sort(os.listdir(path))\n\n # Calculate rmse\n rmse = np.zeros_like(vals)\n for i,outdir in enumerate(outdirs):\n surface = os.path.join(path,outdir,'surface.h5')\n los,fem_los,residual = pu.los2pylith(surface, dem, unw, incidence)\n rmse[i] = rms_flat(residual[np.isfinite(residual)])\n\n plt.plot(vals,rmse,'b.-')\n\n # Annotate\n #plt.title(param)\n plt.xlabel('{} [km]'.format(param))\n plt.ylabel('RMSE [cm]')\n plt.legend()\n plt.show()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _plot_rmse(self, val=False):\n _, ax = plt.subplots()\n ax.plot(self.global_rmse, linewidth=3, color='blue', label='Train RMSE')\n ax.set_title('RMSE vs. Number of Iterations')\n if val is not None:\n ax.plot(self.validation_rmse, linewidth=3, color='green', label='Validation RMSE')\n ax.legend()\n plt.show()","def plot(self) -> None:\n cw_l2_data_list = list(); cw_linf_data_list = list()\n\n for model in self.model_list:\n cw_l2_data_list.append(joblib.load(model + \"/stat/mse-rmse-si-mae-cw_l2_1.pkl\"))\n\n cw_l2_attack = list(zip(self.model_list, cw_l2_data_list))\n\n for model in self.model_list:\n cw_linf_data_list.append(joblib.load(model + \"/stat/mse-rmse-si-mae-cw_inf_1.pkl\"))\n\n cw_linf_attack = list(zip(self.model_list, cw_linf_data_list))\n\n # RMSE v.s. MAE over change budget\n # There will be one graph for each manipulation\n # CW_L2 ATTACK\n for datum in cw_l2_attack:\n ran_color_list = self._random_color_picker(2)\n fig, axis_1 = plt.subplots()\n\n # Generate x_axis\n x_axis = list()\n for key in datum[1]:\n if float(key) not in x_axis:\n x_axis.append(float(key))\n\n x_axis.sort()\n\n # Sort data in datum[1]\n data_dict = self._sort_dict(x_axis, datum[1])\n\n # PLOT RMSE ON AXIS 1\n # Generate y_axis ticks for RMSE\n rmse_values = list()\n for key in data_dict:\n rmse_values.append(data_dict[key][\"rmse\"])\n\n # Generate 10 ticks for the y_axis\n y_axis_ticks = np.linspace(0.0, 0.6, num=10, endpoint=True)\n\n # Plot RMSE\n axis_1.plot(x_axis, rmse_values, color=ran_color_list[0], linestyle=\"solid\")\n axis_1.set_xlabel(\"Perturbation Budget\")\n axis_1.set_ylabel(\"Root Mean Squared Error (RMSE)\", color=ran_color_list[0])\n axis_1.set_yticks(y_axis_ticks)\n \n for tick_label, tick_line in zip(axis_1.get_yticklabels(), axis_1.get_yticklines()):\n tick_label.set_color(ran_color_list[0])\n tick_line.set_color(ran_color_list[0])\n\n # PLOT MAE ON AXIS 2\n axis_2 = axis_1.twinx()\n\n # Generate y-axis ticks for MAE\n mae_values = list()\n for key in data_dict:\n mae_values.append(data_dict[key][\"mae\"])\n\n\n # Plot MAE\n axis_2.plot(x_axis, mae_values, color=ran_color_list[1], linestyle=\"solid\")\n axis_2.set_ylabel(\"Mean Absolute Error (MAE)\", color=ran_color_list[1])\n axis_2.set_yticks(y_axis_ticks)\n \n for tick_label, tick_line in zip(axis_2.get_yticklabels(), axis_2.get_yticklines()):\n tick_label.set_color(ran_color_list[1])\n tick_line.set_color(ran_color_list[1])\n\n model_tag = datum[0].split(\"/\"); model_tag = model_tag[-1]\n plt.savefig(self.save_path + \"/{}_rmse-and-mae-as-perturbation-budget-increases-for-cw_l2-attack-on-model-{}.png\".format(self.plot_name, model_tag), \n bbox_inches=\"tight\")\n plt.close()\n\n # CW_Linf ATTACK\n for datum in cw_linf_attack:\n ran_color_list = self._random_color_picker(2)\n fig, axis_1 = plt.subplots()\n\n # Generate x_axis\n x_axis = list()\n for key in datum[1]:\n if float(key) not in x_axis:\n x_axis.append(float(key))\n\n x_axis.sort()\n\n # Sort data in datum[1]\n data_dict = self._sort_dict(x_axis, datum[1])\n\n # PLOT RMSE ON AXIS 1\n # Generate y_axis ticks for RMSE\n rmse_values = list()\n for key in data_dict:\n rmse_values.append(data_dict[key][\"rmse\"])\n\n # Plot RMSE\n axis_1.plot(x_axis, rmse_values, color=ran_color_list[0], linestyle=\"solid\")\n axis_1.set_xlabel(\"Perturbation Budget\")\n axis_1.set_ylabel(\"Root Mean Squared Error (RMSE)\", color=ran_color_list[0])\n axis_1.set_yticks(y_axis_ticks)\n\n for tick_label, tick_line in zip(axis_1.get_yticklabels(), axis_1.get_yticklines()):\n tick_label.set_color(ran_color_list[0])\n tick_line.set_color(ran_color_list[0])\n\n # PLOT MAE ON AXIS 2\n axis_2 = axis_1.twinx()\n\n # Generate y-axis ticks for MAE\n mae_values = list()\n for key in data_dict:\n mae_values.append(data_dict[key][\"mae\"])\n\n # Plot MAE\n axis_2.plot(x_axis, mae_values, color=ran_color_list[1], linestyle=\"solid\")\n axis_2.set_ylabel(\"Mean Absolute Error (MAE)\", color=ran_color_list[1])\n axis_2.set_yticks(y_axis_ticks)\n \n for tick_label, tick_line in zip(axis_2.get_yticklabels(), axis_2.get_yticklines()):\n tick_label.set_color(ran_color_list[1])\n tick_line.set_color(ran_color_list[1])\n \n model_tag = datum[0].split(\"/\"); model_tag = model_tag[-1]\n plt.savefig(self.save_path + \"/{}_rmse-and-mae-as-perturbation-budget-increases-for-cw_linf-attack-on-model-{}.png\".format(self.plot_name, model_tag),\n bbox_inches=\"tight\")\n plt.close()\n \"RMSE and MAE as Perturbation Budget increases for CW_Linf attack on model {}\".format(model_tag)\n \n # Scattter Index over the change budget\n # All the manipulations will be put on the same graph.\n # CW_L2 ATTACK\n plt.figure()\n plt.xlabel(\"Perturbation Budget\"); plt.ylabel(\"Scatter Index\")\n ran_color_list = self._random_color_picker(len(cw_l2_attack)); i = 0\n\n # Find maximum scatter index value\n scatter_values = list()\n for datum in cw_l2_attack:\n for key in datum[1]:\n scatter_values.append(datum[1][key][\"scatter_index\"])\n\n # Generate y_axis ticks; generate 10 ticks\n y_axis_ticks = np.linspace(0.0, float(Decimal(str(max(scatter_values))) + Decimal(\"0.1\")), num=10, endpoint=True)\n plt.yticks(y_axis_ticks)\n\n # Generate x_axis\n x_axis = list()\n for datum in cw_l2_attack:\n for key in datum[1]:\n if float(key) not in x_axis:\n x_axis.append(float(key))\n\n x_axis.sort()\n\n formal_names = FormalNameMap()\n for datum in cw_l2_attack:\n values = list()\n data_dict = self._sort_dict(x_axis, datum[1])\n for key in data_dict:\n values.append(data_dict[key][\"scatter_index\"])\n\n # Append values to the plot\n line_name = datum[0].split(\"/\"); line_name = line_name[-1]\n formal_name = formal_names.getformalname(line_name) if formal_names.hasname(line_name) else line_name\n if \"vanilla\" in line_name:\n plt.plot(x_axis, values, color=ran_color_list[i], linewidth=3, linestyle=self._random_linestyle(), label=formal_name)\n\n else:\n plt.plot(x_axis, values, color=ran_color_list[i], linestyle=self._random_linestyle(), label=formal_name)\n \n i += 1\n\n plt.legend()\n plt.savefig(self.save_path + \"/{}_scatter-index-as-perturbation-budget-increases-for-cw_l2-attack.png\".format(self.plot_name),\n bbox_inches=\"tight\")\n plt.close()\n\n # CW_Linf ATTACK\n plt.figure()\n plt.xlabel(\"Perturbation Budget\"); plt.ylabel(\"Scatter Index\")\n ran_color_list = self._random_color_picker(len(cw_linf_attack)); i = 0\n\n # Find maximum scatter index value\n scatter_values = list()\n for datum in cw_linf_attack:\n for key in datum[1]:\n scatter_values.append(datum[1][key][\"scatter_index\"])\n\n # Generate y_axis ticks; generate 10 ticks\n y_axis_ticks = np.linspace(0.0, float(Decimal(str(max(scatter_values))) + Decimal(\"0.1\")), num=10, endpoint=True)\n plt.yticks(y_axis_ticks)\n\n # Generate x_axis\n x_axis = list()\n for datum in cw_l2_attack:\n for key in datum[1]:\n if float(key) not in x_axis:\n x_axis.append(float(key))\n\n x_axis.sort()\n\n formal_names = FormalNameMap()\n for datum in cw_linf_attack:\n values = list()\n data_dict = self._sort_dict(x_axis, datum[1])\n for key in data_dict:\n values.append(data_dict[key][\"scatter_index\"])\n\n # Append values to the plot\n line_name = datum[0].split(\"/\"); line_name = line_name[-1]\n formal_name = formal_names.getformalname(line_name) if formal_names.hasname(line_name) else line_name\n if \"vanilla\" in line_name:\n plt.plot(x_axis, values, color=ran_color_list[i], linewidth=3, linestyle=self._random_linestyle(), label=formal_name)\n\n else: \n plt.plot(x_axis, values, color=ran_color_list[i], linestyle=self._random_linestyle(), label=formal_name)\n \n i += 1\n\n plt.legend()\n plt.savefig(self.save_path + \"/{}_scatter-index-as-perturbation-budget-increases-for-cw_linf-attack.png\".format(self.plot_name),\n bbox_inches=\"tight\")\n plt.close()","def evaluate(y_train,train_preds,y_test,test_preds,model,features):\n \n plt.figure(figsize=(3.5,3))\n train_mae = np.abs(y_train-train_preds).mean()\n test_mae = np.abs(y_test-test_preds).mean()\n print(model, split)\n print('Test MAE: %4.2f'%(test_mae))\n print('Train MAE: %4.2f'%(train_mae))\n plt.plot(y_train,train_preds,'.',c='grey',ms=3,label='Train MAE: %4.2f'%train_mae,alpha=1)\n plt.plot(y_test,test_preds,'.',c=colors[model],ms=3,label='Test MAE: %4.2f'%test_mae,alpha=1)\n #plt.title('%s: Train MAE = %.2f eV; Test MAE = %.2f eV'%(model,np.abs(y_train-train_preds).mean(),np.abs(y_test-test_preds).mean()),fontsize=10)\n\n xlim = plt.gca().get_xlim()\n ylim = plt.gca().get_ylim()\n \n alim = (min(xlim[0],ylim[0]),max(xlim[1],ylim[1]))\n\n plt.plot(alim,alim,'-k',lw=1)\n plt.gca().set_ylim(alim)\n plt.gca().set_xlim(alim)\n\n plt.xlabel('$\\Delta E$ (eV)')\n plt.ylabel('$\\Delta E$ Predicted (eV)')\n\n plt.legend(loc='best')\n\n plt.tight_layout()\n plt.savefig('./parity/'+model+'_'+features+'_'+split+'_parity.pdf')\n \n #Functionality to plot histogram of error if desired\n\n #plt.figure()\n #plt.hist(preds-y,bins=100)\n #plt.xlabel('$\\hat{y} - y$ (eV)')\n #plt.title('%s %s: MAE = %.2f eV'%(model,tt,np.abs(y-preds).mean()))\n\n #xlim = np.array(plt.gca().get_xlim())\n #xmax = np.abs(xlim).max()\n #plt.gca().set_xlim([-xmax,xmax])\n\n #plt.savefig('./output/'+model+'_'+features+'_'+split+'_'+tt+'_hist.pdf')\n\n return","def plot(self, axis = None, xlabel=True, save=True, legend=True):\n if axis is None:\n fig, axis = plt.subplots(figsize=(10,7))\n # total kernel evaluations\n kernel_evaluations = 0.5 * self.Ms*(self.Ms - 1)\n effective_R = self.minimal_R * kernel_evaluations.reshape(-1,1,1)\n\n exponents = np.zeros(len(self.epsilons))\n\n for i, eps in enumerate(self.epsilons):\n means = np.mean(effective_R[:,:self.estimations,i],axis=-1)\n upper = np.quantile(effective_R[:,:self.estimations,i],upper_percentile,axis=-1)\n lower = np.quantile(effective_R[:,:self.estimations,i],lower_percentile,axis=-1)\n errors = np.array([means - lower, upper - means])\n\n p = np.polyfit(np.log(self.Ms), np.log(means), 1)\n exponents[i] = p[0]\n axis.errorbar(self.Ms, means, yerr=errors, marker='.', ecolor=colors[i], elinewidth=3., ls='',\n capsize=6,capthick=2., color=colors[i], ms=20, label = r'$\\varepsilon_0 = {{%s}}, \\quad R \\propto M^{{%.2f}}$'%(eps, p[0]))\n\n M_fine = np.geomspace(np.min(self.Ms),np.max(self.Ms))\n\n axis.plot(M_fine, np.exp(p[1])*M_fine**p[0],'-.',color=colors[i])\n\n axis.set_xscale('log')\n axis.set_yscale('log')\n axis.grid()\n if legend:\n axis.legend()\n if xlabel:\n axis.set_xlabel(r'Data size $M$')\n axis.set_ylabel(r'Total number of shots $R$')\n axis.set_xticks(self.Ms, self.Ms)\n axis.set_title(r'$\\lambda = {{%s}}$'%(1/self.C))\n #plt.show()\n sep = 'separable' if self.margin > 0 else 'overlap'\n if save:\n plt.savefig(f'plots/binomial_experiment_{sep}_C_{self.C}.png',dpi=300,bbox_inches='tight')\n \n return exponents","def rmse (lmse) :\n return np.sqrt(2*lmse)","def plotLoss():\n # ssr\n ssr = np.log(gradientDescent(X, y)[1])\n # number of iterations \n iterations = np.log(np.arange(1, len(ssr) + 1, 1))\n # plot reduction of ssr\n plt.plot(iterations, ssr)\n # xlabel\n plt.xlabel(\"Iteration\")\n # ylabel\n plt.ylabel(\"SSR\")\n # title\n plt.title(\"Reduction of SSR by number of Iterations\")\n # show plot \n plt.show()","def make_tuning_plot_rmse(df, error_col_name=\"rmse\",\n error_title = \"Top 10% RMSE\",\n cutoff = 0.10):\n\n df = df.copy()\n\n # Get the regularizer and reset coeff\n coeff = [float(i.split(\"evidence_new_reg_\")[1]) if \"evidence\" in i else i for i in df['method_name']]\n df[\"method_name\"] = coeff\n df[\"Data\"] = convert_dataset_names(df[\"dataset\"])\n df[\"Method\"] = df[\"method_name\"]\n\n # Get appropriate datasets\n trials = 'trial_number'\n methods = 'Method'\n\n # Make area plot\n uniq_methods = set(df[\"Method\"].values)\n method_order = sorted(uniq_methods,\n key=lambda x : x if isinstance(x, float) else -1)\n method_df = []\n datasets = set()\n for data, sub_df in df.groupby(\"Data\"):\n # Add datasets\n datasets.add(data)\n rmse_sub = sub_df[error_col_name]\n methods_sub = sub_df[\"Method\"]\n trials_sub= sub_df['trial_number']\n for method_idx, method in enumerate(method_order):\n # Now summarize these lines\n bool_select = (methods_sub == method)\n\n rmse_method = rmse_sub[bool_select]\n trials_temp = trials_sub[bool_select]\n areas = []\n # create area!\n for trial, rmse_trial in zip(trials_sub, rmse_method):\n num_tested = len(rmse_trial)\n cutoff_index = int(cutoff * num_tested) - 1\n rmse_val = rmse_trial[-cutoff_index]\n to_append = {error_title: rmse_val,\n \"Regularizer Coeff, $\\lambda$\": method,\n \"method_name\": method,\n \"Data\": data,\n \"Trial\" : trial}\n method_df.append(to_append)\n method_df = pd.DataFrame(method_df)\n\n # Filter out dropout\n method_df = method_df[[i != \"dropout\" for i in\n method_df['method_name']]].reset_index()\n\n # Normalize by dataset\n for dataset in datasets:\n # Make a divison vector of ones and change it to a different value only\n # for the correct dataset of interest to set max rmse to 1\n division_factor = np.ones(len(method_df))\n indices = (method_df[\"Data\"] == dataset)\n\n # Normalize with respect to the ensemble so that this is 1\n max_val = method_df[indices].query(\"method_name == 'ensemble'\").mean()[error_title]\n\n # Take the maximum of the AVERAGE so it's normalized to 1\n division_factor[indices] = max_val\n method_df[error_title] = method_df[error_title] / division_factor\n\n method_df_evidence = method_df[[isinstance(i, float) for i in\n method_df['method_name']]].reset_index()\n method_df_ensemble = method_df[[\"ensemble\" in str(i) for i in\n method_df['method_name']]].reset_index()\n\n data_colors = {\n dataset : sns.color_palette()[index]\n for index, dataset in enumerate(datasets)\n }\n\n min_x = np.min(method_df_evidence[\"Regularizer Coeff, $\\lambda$\"])\n max_x= np.max(method_df_evidence[\"Regularizer Coeff, $\\lambda$\"])\n\n sns.lineplot(x=\"Regularizer Coeff, $\\lambda$\", y=error_title,\n hue=\"Data\", alpha=0.8, data=method_df_evidence,\n palette = data_colors)\n\n for data, subdf in method_df_ensemble.groupby(\"Data\"):\n\n color = data_colors[data]\n area = subdf[error_title].mean()\n std = subdf[error_title].std()\n plt.hlines(area, min_x, max_x, linestyle=\"--\", color=color, alpha=0.8)\n\n # Add ensemble baseline\n ensemble_line = plt.plot([], [], color='black', linestyle=\"--\",\n label=\"Ensemble\")\n # Now make ensemble plots\n plt.legend(bbox_to_anchor=(1.1, 1.05))","def residual_plots(test_data, mods, station=None, squared=False):\r\n import config\r\n learning_var = config.learning_var\r\n data = test_data.get_miniOD()\r\n mods.models[0].mod.load()\r\n pred = mods.models[0].mod.predict(test_data)\r\n test_data.miniOD = None\r\n if squared:\r\n data[test_data.get_stations_col(2015)] = (data[test_data.get_stations_col(2015)] - pred) ** 2 # /pred\r\n else:\r\n data[test_data.get_stations_col(2015)] = data[test_data.get_stations_col(2015)] - pred\r\n ind = data[data['Annee'] == 0].index\r\n data.drop(ind, inplace=True)\r\n print(data.columns.values)\r\n i = 0\r\n if station is None:\r\n ch_an = test_data.get_stations_col(2015)\r\n else:\r\n ch_an = 'End date ' + str(station)\r\n for ch in learning_var:\r\n if not (ch[0] == 'h') and not (ch in ['LV', 'MMJ', 'SD', 'poudrerie', 'verglas']):\r\n # data.boxplot(ch_an, by=ch)\r\n # if ch != 'Heure':\r\n plt.figure(i // 9)\r\n # plt.title('squared error / expectation')\r\n fig = plt.subplot(3, 3, (i % 9) + 1)\r\n i += 1\r\n # fig = plt.figure().add_subplot(111)\r\n fig.set_xlabel(ch)\r\n if squared:\r\n fig.set_ylabel('error²')\r\n else:\r\n fig.set_ylabel('error')\r\n l = []\r\n xaxis = np.unique(data[ch])\r\n print(ch, xaxis.shape)\r\n if xaxis.shape[0] < 20 or ch == 'Heure':\r\n for u in xaxis:\r\n l.append(data[ch_an][data[ch] == u])\r\n else:\r\n m = np.min(data[ch])\r\n M = np.max(data[ch])\r\n step = (M - m) / 20\r\n xaxis = np.arange(m, M, step)\r\n for u in xaxis:\r\n l.append(data[ch_an][(data[ch] >= u) * (data[ch] < u + step)])\r\n xaxis = xaxis.astype(int)\r\n # fig = plt.boxplot(ch_an, by=ch)\r\n # g = data.groupby(ch).mean()[ch_an]\r\n # v = data.groupby(ch).std()[ch_an]\r\n plt.boxplot(l, labels=xaxis)\r\n if squared:\r\n plt.ylim((0, 12))\r\n else:\r\n plt.ylim((-5, 5))\r\n # plt.plot(g, '-r')\r\n # plt.plot(g + v, ':r')\r\n # plt.plot(g - v, ':r')\r\n plt.show()","def plot_losses(train, test, mode):\n\tplt.figure()\n\tplt.plot(range(len(train)), train, 'r', label='Training')\n\tplt.plot(range(len(test)), test, 'b', label='Testing')\n\tplt.title('MSE Loss (batch type: ' + mode + ')')\n\tplt.legend()\n\tplt.show()","def plot_train_test_errors(train_errors, test_errors, lambda_str , K , path, rng):\n plt.plot(range(rng), train_errors, marker='o', label='Training Data');\n plt.plot(range(rng), test_errors, marker='v', label='Test Data');\n plt.title('ALS-WR Learning Curve, lambda = %s, K = %d'%(lambda_str, K))\n plt.xlabel('Number of Epochs');\n plt.ylabel('RMSE');\n plt.legend()\n plt.grid()\n plt.savefig(\"../results/test_train_rmse_\"+path)\n plt.show()","def measure_rmse(self):\n try:\n assert self.residuals_forecast is not None\n except AssertionError:\n self._uvts_cls_logger.exception(\"AssertionError occurred, Cannot compute RMSE! Check your object mode\")\n\n self.rmse = np.sqrt(sum(np.square(self.residuals_forecast)) / len(self.residuals_forecast))\n \"\"\"\n if self._mode == 'test':\n self.rmse_test = self.rmse\n elif self._mode == 'test and validate':\n self.rmse_val = self.rmse - self.rmse_test\n elif self._mode == 'validate':\n self.rmse_val = self.rmse\n \"\"\"","def mso_separation_task():\n input_range = np.arange(3000) #np.array([range(2000)])\n timescale=10.0\n osc1 = np.sin(input_range/timescale)\n osc2 = np.sin(2.1*input_range/timescale)\n osc3 = np.sin(3.4*input_range/timescale)\n train_target = np.column_stack((osc1, osc2, osc3))\n train_input = osc1*np.cos(osc2+2.345*osc3)\n train_input = train_input[:, None] #1d->2d\n\n machine = ESN(1, 800, leak_rate=0.5)\n print 'Starting training...'\n start = time.time()\n trainer = LinearRegressionReadout(machine)\n trainer.train(train_input[:2000], train_target[:2000])\n print 'Training Time: ', time.time() - start, 's'\n prediction = trainer.predict(train_input[2000:])\n mse = error_metrics.mse(prediction,train_target[2000:])\n nrmse = error_metrics.nrmse(prediction,train_target[2000:])\n print 'MSE: ', mse, 'NRMSE:' , nrmse\n \n plt.subplot(3,1,1)\n plt.plot(train_input[2800:3000])\n plt.title('Input')\n plt.subplot(3,1,2)\n plt.plot(train_target[2800:3000])\n plt.title('Targets')\n plt.subplot(3,1,3)\n plt.plot(prediction[800:1000])\n plt.title('Predictions')\n plt.show()\n \n return nrmse","def display_loss_values(model, figure_size = (18, 5)):\r\n\r\n # Check that the model is not a Non-Parametric model\r\n if 'kaplan' in model.name.lower() :\r\n error = \"This function cannot only take as input a Non-Parametric model\"\r\n raise NotImplementedError(error)\r\n\r\n if 'simulation' in model.name.lower() :\r\n error = \"This function cannot only take as input a simulation model\"\r\n raise NotImplementedError(error)\r\n\r\n # Extracting the loss values\r\n loss_values = model.loss_values\r\n\r\n # Extracting the norm 2 of the gradient, if it exists\r\n grad2_values = model.__dict__.get('grad2_values')\r\n if grad2_values is None:\r\n order = 1\r\n else :\r\n order = 2\r\n \r\n # Displaying the loss values bsed on the type of optimization\r\n if order == 1:\r\n title = \"Loss function values\"\r\n fig, ax = plt.subplots(figsize=figure_size)\r\n ax.plot( loss_values, color = 'blue', label = 'Loss values')\r\n ax.set_xlabel( 'Number of epochs', fontsize=10)\r\n plt.legend(fontsize=10)\r\n plt.title(title, fontsize=10)\r\n plt.show()\r\n\r\n elif order == 2:\r\n\r\n # Initializing Chart \r\n fig = plt.figure( figsize=figure_size )\r\n fig.suptitle( 'Loss function $l$ and $|| gradient ||_{L_{2}}$', \r\n fontsize=12, fontweight='bold')\r\n\r\n # Plotting loss function\r\n ax1 = fig.add_subplot(111)\r\n ax1.set_xlabel('epochs' )\r\n ax1.set_ylabel('Loss function $l$')\r\n pl1 = ax1.plot( range( len(loss_values)) , loss_values, \r\n label = 'Loss function $l$', color = 'blue', linestyle = '--')\r\n\r\n # Plotting ||grad|| values\r\n ax2 = ax1.twinx()\r\n pl2 = ax2.plot( range( len(grad2_values) ) , grad2_values ,\r\n label = '$|| gradient ||_{L_{2}}$', color = 'red')\r\n ax2.set_ylabel('$|| gradient ||_{L_{2}}$')\r\n\r\n # added these three lines\r\n pl = pl1 + pl2\r\n labs = [l.get_label() for l in pl]\r\n ax1.legend(pl, labs, loc=1)\r\n\r\n # display chart\r\n plt.show()","def train_test_error(e_train, e_test, model_params):\n\n fig = plt.figure(figsize=FIG_SIZE)\n plt.plot(model_params, e_train, label='Training Set')\n plt.plot(model_params, e_train, label='Test Set')\n plt.xlabel('Model Parameter')\n plt.ylabel('MSE of model')\n plt.legend()\n\n return fig","def plotErrors(losses, model_title ='Shallow Network, SGD, Batch Size = 10'):\n fig, axes = plt.subplots()\n\n x = np.arange(len(losses))\n\n axes.plot(x, losses)\n axes.set_ylabel(\"Loss (cross entropy)\")\n axes.set_xlabel(\"Number of iterations\")\n axes.set_title(model_title) \n\n plt.show() \n\n return None","def rmse(self):\n lam = self.lam()\n weights = lam / lam.sum()\n weighted_var = self.var() * weights\n rmse = np.sqrt(weighted_var.sum())\n return rmse","def MSE_plots(n_min, n_max, save_fig, k = [5], method = 'OLS', lamb = 1, split = False, train = 0.7, N = 1, method2 = 'OLS'):\n n = np.linspace(n_min, n_max, n_max - n_min + 1)\n errors = np.zeros((4, len(k), len(n))) # First index MSE for real FrankeFunction, MSE for the data, R2 for the real FrankeFunction, R2 for the data\n #Second index is the max order of polynomial, third index is for the n-value\n if type(k) != type([2]):\n k = [k]\n\n for j in range(N):\n #print(j)\n for i in range(len(n)):\n #print(i)\n x = np.random.uniform(0, 1, size = int(n[i]))\n y = np.random.uniform(0, 1, size = int(n[i]))\n x, y = np.meshgrid(x, y)\n\n z = FrankeFunction(x, y) + np.random.normal(0, 1, size = x.shape)\n z_real = FrankeFunction(x, y)\n\n for poly in range(len(k)):\n a = regression(x, y, z, k = k[poly], split = split, train = train)\n\n if method == 'OLS':\n beta = a.OLS()\n elif method == 'Ridge':\n beta = a.Ridge(lam = lamb)\n elif method == 'Lasso':\n beta = a.Lasso(alpha = lamb)\n elif method == 'K-fold':\n beta = a.k_cross(fold = 25, method2 = method2, lam = lamb)[0]\n\n if split == True:\n X = a.design_matrix(k = k[poly])\n X_train, X_test, z_real_train, z_real_test = a.train_test(X = X, z = z_real, train = train)\n z_tilde = a.z_tilde(X = X_test, beta = beta)\n errors[0, poly, i] += a.MSE(z_tilde, z_real_test)\n errors[1, poly, i] += a.MSE(z_tilde, a.z_test)\n errors[2, poly, i] += a.R_squared(z_tilde = z_tilde, z = z_real_test)\n errors[3, poly, i] += a.R_squared(z_tilde = z_tilde, z = a.z_test)\n else:\n z_tilde = a.z_tilde(beta = beta)\n errors[0, poly, i] += a.MSE(z_tilde, z_real)\n errors[1, poly, i] += a.MSE(z_tilde, z)\n errors[2, poly, i] += a.R_squared(z_tilde = z_tilde, z = z_real)\n errors[3, poly, i] += a.R_squared(z_tilde = z_tilde, z = z)\n\n n_mid = int(len(n)/2)\n title = ['MSE FrankeFunction', 'MSE data', 'R2 FrankeFunction', 'R2 data']\n y_label = ['MSE', 'MSE', 'R^2', 'R^2']\n errors /= N\n save_name = ['franke', 'data', 'franke', 'data']\n\n if method == 'Ridge':\n method += ' with lambda = ' + str(lamb)\n if method == 'K-fold':\n method += ' using ' + method2\n if method2 == 'Ridge' or method2 == 'Lasso':\n method += ' with lambda = ' + str(lamb)\n\n for i in range(4):\n fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 7))\n for j in range(len(k)):\n ax1.plot(n[:n_mid], errors[i, j, :n_mid], label = 'k = ' + str(k[j]))\n ax2.plot(n[n_mid:], errors[i, j, n_mid:], label = 'k = ' + str(k[j]))\n\n ax1.set_ylabel(y_label[i]); ax2.set_ylabel(y_label[i])\n ax1.set_xlabel('n'); ax2.set_xlabel('n')\n\n if split == True:\n fig.suptitle(title[i] + ' with ' + str(method) + ' with test/training split at ' + str(train) + ' and mean of ' + str(N) + ' runs.')\n else:\n fig.suptitle(title[i] + ' with ' + str(method) + ' without test/training split' + ' and mean of ' + str(N) + ' runs.')\n\n ax1.legend(); ax2.legend()\n #fig.savefig(results_dir + save_fig + method + save_name[i] + y_label[i] + '.png')\n plt.show()","def plotPredictedError():\n\tglobal normalized\n\n\twarmthPred = []\n\twarmthObserved = []\n\tcompPred = []\n\tcompObserved = []\n\tSStotalWarmth = 0\n\tSSresWarmth = 0\n\tSStotalComp = 0\n\tSSresComp = 0\n\tkeys = parser.getMappings(normalized)[0].keys()\n\tfor key in keys:\n\n\t\tif \"_\" in key:\n\t\t\twarmthAxis, compAxis = getPlotData(key)\n\t\t\twarmthPred.append(warmthAxis[3])\n\t\t\twarmthObserved.append(warmthAxis[2])\n\t\t\tcompPred.append(compAxis[3])\n\t\t\tcompObserved.append(compAxis[2])\n\n\tmeanObservedWarmth = np.mean(warmthObserved)\n\tmeanObservedComp = np.mean(compObserved)\n\tfor i in range(0, len(warmthObserved)):\n\t\tSStotalWarmth += (warmthObserved[i] - meanObservedWarmth)**2\n\t\tSSresWarmth += (warmthObserved[i] - warmthPred[i])**2\n\t\tSStotalComp += (compObserved[i] - meanObservedComp)**2\n\t\tSSresComp += (compObserved[i] - compPred[i])**2\n\n\n\tplt.axis([0, 100, 0, 100])\n\tfig = plt.figure(1)\n\tax = fig.add_subplot(111)\n\tslope, intercept, r_value, p_value, std_err = stats.linregress(warmthObserved, warmthPred)\n\tprint(r_value**2)\n\ttext = ax.text(60, 20, \"R^2 value: \" + str(r_value**2) , \\\n fontsize = 12, color = 'black')\n\tplt.title(\"Observed vs Predicted Warmth\")\n\tplt.ylabel(\"Predicted Value\")\n\tplt.xlabel(\"Observed Value\")\n\tplt.scatter(warmthObserved, warmthPred)\n\tplt.plot([0,100], [0,100])\n\tplt.show()\n\n\tfig = plt.figure(1)\n\tax = fig.add_subplot(111)\n\tslope, intercept, r_value, p_value, std_err = stats.linregress(compObserved, compPred)\n\tprint(r_value**2)\n\ttext = ax.text(60, 20, \"R^2 value: \" + str(r_value**2) , \\\n fontsize = 12, color = 'black')\n\tplt.axis([0, 100, 0, 100])\n\tplt.title(\"Observed vs Predicted Competence\")\n\tplt.ylabel(\"Predicted Value\")\n\tplt.xlabel(\"Observed Value\")\n\tplt.scatter(compObserved, compPred)\n\tplt.plot([0,100], [0,100])\n\tplt.show()","def compute_RMSE(e):\n \"\"\"Corresponds to sqrt(2*MSE)\"\"\"\n \n return np.sqrt(2*compute_MSE(e))","def fig_2_11V2(x, y, z, first_poly = 4, complexity = 10, N = 7, method = 'OLS', seed = 42, lam = 0, folds = 5, save_fig = ''):\n errors = np.zeros((4, complexity + 1))\n bias = np.zeros(complexity + 1)\n variance = np.zeros(complexity + 1)\n z_real = FrankeFunction(x, y)\n\n complx = np.arange(first_poly, first_poly + complexity + 1, 1)\n\n MSE = np.zeros(complexity + 1)\n\n for i in range(complexity + 1):\n print(i)\n model = regression(x, y, z, k = first_poly + i, split = False, seed = seed)\n\n for j in range(N):\n _, MSE_R2D2, _, _, _, _ = model.k_cross(fold = folds, method2 = method, lam = lam, random_num = True)\n errors[:, i] += np.mean(MSE_R2D2, axis = 0)\n\n errors /= N\n\n print(errors)\n\n\n plt.title(method + ' Test vs Train error in k-fold with ' + str(folds) + '-folds')\n plt.plot(complx, errors[0], 'go--', label = 'Test', color = 'blue')\n plt.plot(complx, errors[2], 'go--', label = 'Training', color = 'red')\n #plt.ylim([np.min(errors_R2[2]*1.2), np.max(errors_R2[0]*1.2)])\n plt.legend()\n plt.xlabel('Polynomial maximum order', fontsize = 14)\n plt.ylabel('MSE', fontsize = 14)\n plt.savefig(results_dir + 'tradeoff2MSE' + method + save_fig + '.png')\n\n plt.show()\n\n plt.title(method + ' Test vs Train error in k-fold with ' + str(folds) + '-folds')\n plt.xlabel('Polynomial maximum order', fontsize = 14)\n plt.ylabel('R2', fontsize = 14)\n plt.plot(complx, errors[1], 'go--', label = 'Test', color = 'blue')\n plt.plot(complx, errors[3], 'go--', label = 'Training', color = 'red')\n #plt.ylim([np.min(errors_R2[3]*1.2), np.max(errors_R2[1]*1.2)])\n plt.legend()\n plt.tight_layout()\n plt.savefig(results_dir + 'tradeoff2R2' + method + save_fig + '.png')\n plt.show()","def compute_RMSE(true_val, predicted_val, p_output=True) -> float:\n from sklearn.metrics import mean_squared_error\n rms = np.sqrt(mean_squared_error(np.array(true_val), predicted_val))\n if p_output:\n print('RMSE: {0}'.format(rms))\n return rms","def simple_rmsd(self,calc_data=\"xyzcal.px\",plot=False):\n Z = self.refl_table\n devs = flex.double()\n sqdevs = flex.double()\n for oidx in range(len(Z[\"spots_order\"])): #loop through the shoeboxes in correct order\n sidx = Z[\"spots_order\"][oidx] # index into the Miller indices\n calc = Z[calc_data][sidx][0:2]\n obs = Z['xyzobs.px.value'][sidx][0:2]\n sqdev= (calc[0]-obs[0])**2 + (calc[1]-obs[1])**2\n dev = math.sqrt(sqdev)\n devs.append(dev)\n sqdevs.append(sqdev)\n #print(\"%20s %6.2fpx\"%(Z[\"miller_index\"][sidx], dev))\n rmsd = math.sqrt(flex.mean(sqdevs))\n print (\"The rmsd is %6.2f px\"%rmsd)\n if plot:\n from matplotlib import pyplot as plt\n plt.plot(range(len(devs)),devs)\n running_range = range(15,len(devs),15)\n plt.plot(running_range, [flex.mean(devs[I-15:I]) for I in running_range], \"r-\",\n label=\"RMSD=%6.2fpx\"%math.sqrt(flex.mean(sqdevs)))\n plt.title(\"Model vs. Experimental Bragg spot position\")\n plt.xlabel(\"Spots ordered by increasing Bragg angle →\")\n plt.ylabel(\"Deviation in pixels\")\n plt.legend(loc='upper left')\n plt.show()\n return rmsd","def _plot(self, step, rewards, losses):\n plt.figure(figsize=(20, 5))\n plt.subplot(131)\n plt.title('Total Episode Reward')\n plt.plot(rewards)\n plt.subplot(132)\n plt.title('MSE Loss')\n plt.plot(losses)\n plt.show()","def actvspred(modelname, predmodel):\n predscores, actualscores, meanerr, rmsqerr = predmodel\n plt.figure()\n plt.scatter(actualscores,predscores,s=70)\n x = np.array(range(100))\n plt.plot(x,x,'g',label='optimal model')\n # make regression\n rob.globalenv[\"pred\"] = FV(predscores)\n rob.globalenv[\"act\"] = FV(actualscores)\n mult_lm = stats.lm(\"pred ~ act + 1\")\n coeffs = np.array(mult_lm.rx(\"coefficients\")[0])\n rsqrd = base.summary(mult_lm).rx(\"r.squared\")[0][0]\n y = coeffs[1]*x+coeffs[0]\n plt.plot(x,y,'k',label='our model',linewidth=2)\n plt.xlabel(\"actual lsas delta\")\n plt.ylabel(\"predicted lsas delta\")\n plt.title(modelname)\n plt.axis([0,100,0,100])\n axes = plt.axes()\n axes.grid(b=True)\n axes.text(0.05,0.8,\"meanerr: %.2f\\nrmse: %.2f\\nr: %.2f (Rsqrd: %.2f)\"%(meanerr,rmsqerr,np.sqrt(rsqrd),rsqrd),transform=axes.transAxes)\n #plt.legend()\n plt.savefig(os.path.join(outdir,\"%s_crossval.png\"%modelname),dpi=300,format=\"png\")","def plot_lr(self, show_text=True, show_moms=True):\n phase_limits = [0]\n for nb_batch, phase in zip(self.nb_batches, self.phases):\n phase_limits.append(phase_limits[-1] + nb_batch * phase.epochs)\n if not in_ipynb():\n plt.switch_backend('agg')\n np_plts = 2 if show_moms else 1\n fig, axs = plt.subplots(1,np_plts,figsize=(6*np_plts,4))\n if not show_moms: axs = [axs]\n for i in range(np_plts): axs[i].set_xlabel('iterations')\n axs[0].set_ylabel('learning rate')\n axs[0].plot(self.iterations,self.lrs)\n if show_moms:\n axs[1].set_ylabel('momentum')\n axs[1].plot(self.iterations,self.momentums)\n if show_text: \n for i, phase in enumerate(self.phases):\n text = phase.opt_fn.__name__\n if phase.wds is not None: text+='\\nwds='+str(phase.wds)\n if phase.beta is not None: text+='\\nbeta='+str(phase.beta)\n for k in range(np_plts):\n if i < len(self.phases)-1:\n draw_line(axs[k], phase_limits[i+1])\n draw_text(axs[k], (phase_limits[i]+phase_limits[i+1])/2, text) \n if not in_ipynb():\n plt.savefig(os.path.join(self.save_path, 'lr_plot.png'))","def run_rmse_check(self):\n\n # Shift the intensities to compare\n obs = self.obs.data - self.obs.data.mean()\n exp = self.exp.data - self.exp.data.mean()\n\n # Experimental RMSE2 in real space\n rmse_real = (obs - exp)\n rmse_real = rmse_real**2\n\n # Experimental RMSE2 in reciprocal space\n ftdiff = np.fft.fft2(obs.data,norm='ortho') - np.fft.fft2(exp.data,norm='ortho')\n rmse_fourier = np.real(np.abs(ftdiff)**2.)\n\n # Return\n rmse_ij = self.obs.deepcopy()\n rmse_ij.data = rmse_real\n\n rmse_kl = ModifiedImage(rmse_fourier)\n return rmse_ij, rmse_kl","def variations_plot(S0, K, B, T, N, u, d, q, M, barrier_type, option, \n MC_runs, price_tree):\n x_values = []\n pi_M = []\n pi_M_RMSE = []\n for i in range(1,MC_runs,1):\n Mi=M*i\n x_values.append([Mi])\n paths = sample_paths(S0, N, u, d, q, Mi)\n p_valid, p_invalid, p_counts = split_paths(paths, B, K, \n barrier_type, option)\n if option == 'Call':\n payoffs = np.maximum(0,p_counts[:,-1]-K)*np.exp(-1*r*T)\n elif option == 'Put':\n payoffs = np.maximum(0,K-p_counts[:,-1])*np.exp(-1*r*T)\n payoffs = list(payoffs)\n while len(payoffs) < Mi:\n payoffs.append([0])\n mean_payoff = np.mean(payoffs)[0]\n pi_M.append(mean_payoff)\n RMSE = np.sqrt(np.var(payoffs,ddof=1))/np.sqrt(Mi)\n pi_M_RMSE.append(RMSE[0])\n \n # plotting\n plt.figure(figsize=(8,6))\n plt.subplot(2, 1, 1)\n plt.plot(x_values, price_tree-1.96*np.array(pi_M_RMSE), '--', c='grey')\n plt.plot(x_values, price_tree+1.96*np.array(pi_M_RMSE), '--', c='grey')\n plt.plot(x_values, pi_M, 'o', label='price via MC')\n plt.plot(x_values, [price_tree]*len(x_values), '-', lw=3, \n label='price via tree')\n plt.legend()\n plt.title('Monte Carlo price, for increasing number of paths')\n plt.ylabel('Expected Value')\n #The following will plot the root mean square error\n plt.subplot(2, 1, 2)\n plt.plot(x_values, pi_M_RMSE, '-')\n plt.xlabel('number of paths')\n plt.ylabel('Root Mean Square Error')\n #plt.savefig('MonteCarlo_variation.png', transparent=True)\n plt.show()","def RMSE(actual, noisy):\n # print len(actual)\n # print len(noisy)\n tmp = mean_squared_error(actual, noisy)\n # print \"Tmp\", tmp\n return math.sqrt(float(tmp))\n\n # noisy_vals = []\n # actual_vals = []\n # print len(actual), actual\n # print len(noisy), noisy\n # for lid in noisy.keys():\n # noisy_vals.append(noisy.get(lid))\n # if not actual.has_key(lid):\n # print lid\n # actual_vals.append(actual.get(lid))\n\n # print len(actual_vals), actual_vals\n # print len(noisy_vals), noisy_vals","def eva_regress(y_true, y_pred):\n\n mape = MAPE(y_true, y_pred)\n vs = metrics.explained_variance_score(y_true, y_pred)\n mae = metrics.mean_absolute_error(y_true, y_pred)\n mse = metrics.mean_squared_error(y_true, y_pred)\n r2 = metrics.r2_score(y_true, y_pred)\n print('explained_variance_score:%f' % vs)\n print('mape:%f%%' % mape)\n print('mae:%f' % mae)\n print('mse:%f' % mse)\n print('rmse:%f' % np.sqrt(mse))\n print('r2:%f' % r2)","def rmse(y_true, y_pred): # -> Any:\n ...","def plot_loss(self):\n train_elbo_range = range(len(self.train_elbo_hist))\n val_elbo_range = range(len(self.val_elbo_hist))\n train_loss_range = range(len(self.train_loss_hist))\n val_loss_range = range(len(self.val_loss_hist))\n\n fig, ax = plt.subplots(2, 2)\n ax[0][0].plot(train_elbo_range, self.train_elbo_hist)\n ax[0][0].title.set_text(\"Train ELBO\")\n ax[0][1].plot(val_elbo_range, self.val_elbo_hist)\n ax[0][1].title.set_text(\"Val ELBO\")\n ax[1][0].plot(train_loss_range, self.train_loss_hist)\n ax[1][0].title.set_text(\"Train MSE\")\n ax[1][1].plot(val_loss_range, self.val_loss_hist)\n ax[1][1].title.set_text(\"Val MSE\")\n plt.tight_layout()\n plt.show()","def rmse(self):\n return (self.model_error()**2).mean()**.5","def plot_multisite_rms(params, phot_data, mag_col, merr_col, qc_col, plot_filename, log):\n\n # Plot a multi-site initial RMS diagram for reference\n phot_statistics = np.zeros( (len(phot_data),4) )\n (phot_statistics[:,0],werror) = plot_rms.calc_weighted_mean_2D(phot_data, mag_col, merr_col, qc_col=qc_col)\n phot_statistics[:,1] = plot_rms.calc_weighted_rms(phot_data, phot_statistics[:,0], mag_col, merr_col, qc_col=qc_col)\n\n text_filename = plot_filename.replace('.png', '.txt')\n f = open(path.join(params['red_dir'],text_filename),'w')\n f.write('# Star_index wMean_mag RMS\\n')\n for j in range(0,len(phot_statistics),1):\n f.write(str(j)+' '+str(phot_statistics[j,0])+' '+str(phot_statistics[j,1])+'\\n')\n f.close()\n\n fig = plt.figure(3,(10,10))\n plt.rcParams.update({'font.size': 18})\n mask = np.logical_and(phot_statistics[:,0] > 0.0, phot_statistics[:,1] > 0.0)\n plt.plot(phot_statistics[mask,0], phot_statistics[mask,1], 'k.',\n markersize=0.5, label='Weighted RMS')\n plt.yscale('log')\n plt.xlabel('Weighted mean mag')\n plt.ylabel('RMS [mag]')\n plt.grid()\n l = plt.legend()\n plt.tight_layout()\n [xmin,xmax,ymin,ymax] = plt.axis()\n plt.axis([xmin,xmax,1e-3,5.0])\n plot_file = path.join(params['red_dir'],plot_filename)\n plt.savefig(plot_file)\n log.info('Output RMS plot to '+plot_filename)\n plt.close(3)","def validate_spreads():\n fig, (ax_prior, ax2_post) = plt.subplots(\n nrows=2, figsize=figsize(aspect=1.2))\n\n # train margin-dependent Elo model\n melo = Melo(lines=np.arange(-49.5, 50.5), commutes=False, k=1e-4)\n melo.fit(league.times, league.labels1, league.labels2, league.spreads)\n\n # exact prior distribution\n outcomes = melo.training_data.value[:, np.newaxis] > melo.lines\n sf = np.mean(outcomes, axis=0)\n ax_prior.plot(melo.lines, sf, color='k')\n\n # label names\n label1 = str(league.lambda1)\n label2_list = [str(lambda2) for lambda2 in league.lambda2_list]\n\n plot_args = [\n (ax_prior, melo.first_update, 'prior'),\n (ax2_post, melo.last_update, 'posterior'),\n ]\n\n for ax, time, title in plot_args:\n for n, label2 in enumerate(label2_list):\n\n lines, sf = melo._predict(time, label1, label2)\n label = r'$\\lambda_2={}$'.format(label2)\n\n if ax.is_first_row():\n ax.plot(lines[n::6], sf[n::6], 'o', zorder=2, label=label)\n\n if ax.is_last_row():\n ax.plot(lines, sf, 'o', zorder=2, label=label)\n\n sf = skellam.sf(melo.lines, int(label1), int(label2))\n ax.plot(melo.lines, sf, color='k')\n\n leg = ax.legend(title=r'$\\lambda_1 = {}$'.format(label1),\n handletextpad=.2, loc=1)\n leg._legend_box.align = 'right'\n\n lines = np.floor(lines)\n ax.set_xticks(lines[::10])\n ax.set_xlim(lines.min(), lines.max())\n\n if ax.is_last_row():\n ax.set_xlabel('line $=$ scored $-$ allowed')\n\n ax.set_ylabel('probability to cover line')\n\n ax.annotate(title, xy=(.05, .05),\n xycoords='axes fraction', fontsize=24)\n\n set_tight(h_pad=1)","def main():\n Nrep = 8 # number of repetition of EM steps\n nm = 3 # number of mixed gaussians.\n ns = 300 # number of samples.\n \n mu, sg, lm, lm_ind, smp, L_true = generate_synthetic_data(nm, ns)\n plt.figure(1, figsize=(5,4))\n plt.clf()\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\n \n mue, sge, lme = generate_initial_state(nm, ns)\n axi = 0 # subplot number\n plt.figure(2, figsize=(12,9))\n plt.clf()\n for rep in range(Nrep):\n # E-step\n r, L_infer = e_step(smp, mue, sge, lme, nm, ns)\n axi += 1 \n ax = plt.subplot(Nrep/2, 6, axi)\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\n ax.set_title('E-step : %d' % (rep + 1))\n ax.set_yticklabels([])\n ax.set_xticklabels([])\n ax.set_ylim((-0.1, 0.3))\n\n # M-step\n mue, sge, lme = m_step(smp, r, nm, ns)\n axi += 1 \n ax = plt.subplot(Nrep/2, 6, axi)\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\n ax.set_title('M-step : %d' % (rep + 1))\n ax.set_yticklabels([])\n ax.set_xticklabels([])\n ax.set_ylim((-0.1, 0.3))\n\n # plot the ground truth for comparison\n axi += 1 \n ax = plt.subplot(Nrep/2, 6, axi)\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\n ax.set_title('grn_truth')\n ax.set_yticklabels([])\n ax.set_xticklabels([])\n ax.set_ylim((-0.1, 0.3))\n\n print('L_infer = %2.6f , L_true = %2.6f' % (L_infer, L_true))","def plot_r(f=500, d=100e-3, dr=0.01, picture_file=None, picture_formats=['png', 'pdf', 'svg']):#x_axis='r', \n import matplotlib.pyplot\n i = 0\n rs = []\n sigmas = []\n ys = []\n print \"r_soll ->\\tsigma ->\\tr\"\n datas = []\n for r in numpy.arange(0, 1+dr, dr) :\n for t in [0] :\n print \"%f\\t\" %(r),\n sigma = getSigma(r)\n print \"%f\\t\" % (sigma),\n rs.append(r)\n sigmas.append(sigma)\n v = getSynapticActivity(f=f, r=r, fireing_rate=1, duration=d, delay=t)\n #print v\n #matplotlib.pyplot.scatter(v, numpy.zeros( len(v) ) + i )\n r = vector_strength(f, v)\n print \"%f\" % (r)\n ys.append(r)\n i = i+1\n datas.append([sigma,r])\n numpy.savetxt(\"../../../Data/%.1f_%f@%i.dat\" % (getSigma(dr),dr,int(f*d)), datas) \n\n matplotlib.pyplot.figure()\n matplotlib.pyplot.xlabel('sigma')\n matplotlib.pyplot.ylabel('measured vector strength')\n matplotlib.pyplot.xlim(0, getSigma(dr))\n matplotlib.pyplot.ylim(0, 1)\n matplotlib.pyplot.grid()\n matplotlib.pyplot.scatter(sigmas,ys, marker='x', color='black')#, basex=10, basey=10, ls=\"-\"\n if(picture_file != None):\n for picture_format in picture_formats:\n matplotlib.pyplot.savefig(picture_file+'sigma_'+str(getSigma(dr))+'_'+str(int(f*d))+'.'+picture_format,format=picture_format)\n else:\n matplotlib.pyplot.show()\n\n matplotlib.pyplot.figure()\n matplotlib.pyplot.xlabel('aimed vector strength')\n matplotlib.pyplot.ylabel('measured vector strength')\n #matplotlib.pyplot.legend([\"based on %i examples / dot\" % (f*d) ], loc='best');\n matplotlib.pyplot.xlim(0, 1)\n matplotlib.pyplot.ylim(0, 1)\n matplotlib.pyplot.grid()\n\n matplotlib.pyplot.scatter(rs,ys, marker='x', color='black')\n if(picture_file != None):\n for picture_format in picture_formats:\n matplotlib.pyplot.savefig(picture_file+'_'+str(dr)+'_'+str(int(f*d))+'.'+picture_format,format=picture_format)\n else:\n matplotlib.pyplot.show()\n\n matplotlib.pyplot.close('all')\n datas = numpy.ndarray((len(datas),2), buffer=numpy.array(datas),dtype=float)\n return datas","def felm_rmse(y, X, weights, y_test, X_test):\n # Fit model and get predicted values of test data\n mod = sm.WLS(y, X, weights=weights).fit()\n pred = mod.predict(X_test)\n\n #Get residuals from test data\n res = (y_test[:] - pred.values)\n\n # Calculate ttest to check that residuals from test and train are independent\n t_stat, p_val = stats.ttest_ind(mod.resid, res, equal_var=False)\n\n # Return RMSE and t-stat from ttest\n return (np.sqrt(np.mean(res**2)), t_stat)","def _plot(self):\n # Read results\n path = self.openmc_dir / f'statepoint.{self._batches}.h5'\n x1, y1, _ = read_results('openmc', path)\n if self.code == 'serpent':\n path = self.other_dir / 'input_det0.m'\n else:\n path = self.other_dir / 'outp'\n x2, y2, sd = read_results(self.code, path)\n\n # Convert energies to eV\n x1 *= 1e6\n x2 *= 1e6\n\n # Normalize the spectra\n y1 /= np.diff(np.insert(x1, 0, self._min_energy))*sum(y1)\n y2 /= np.diff(np.insert(x2, 0, self._min_energy))*sum(y2)\n\n # Compute the relative error\n err = np.zeros_like(y2)\n idx = np.where(y2 > 0)\n err[idx] = (y1[idx] - y2[idx])/y2[idx]\n \n # Set up the figure\n fig = plt.figure(1, facecolor='w', figsize=(8,8))\n ax1 = fig.add_subplot(111)\n \n # Create a second y-axis that shares the same x-axis, keeping the first\n # axis in front\n ax2 = ax1.twinx()\n ax1.set_zorder(ax2.get_zorder() + 1)\n ax1.patch.set_visible(False)\n \n # Plot the spectra\n label = 'Serpent' if self.code == 'serpent' else 'MCNP'\n ax1.loglog(x2, y2, 'r', linewidth=1, label=label)\n ax1.loglog(x1, y1, 'b', linewidth=1, label='OpenMC', linestyle='--')\n \n # Plot the relative error and uncertainties\n ax2.semilogx(x2, err, color=(0.2, 0.8, 0.0), linewidth=1)\n ax2.semilogx(x2, 2*sd, color='k', linestyle='--', linewidth=1)\n ax2.semilogx(x2, -2*sd, color='k', linestyle='--', linewidth=1)\n \n # Set grid and tick marks\n ax1.tick_params(axis='both', which='both', direction='in', length=10)\n ax1.grid(b=False, axis='both', which='both')\n ax2.tick_params(axis='y', which='both', right=False)\n ax2.grid(b=True, which='both', axis='both', alpha=0.5, linestyle='--')\n \n # Set axes labels and limits\n ax1.set_xlim([self._min_energy, self.energy])\n ax1.set_xlabel('Energy (eV)', size=12)\n ax1.set_ylabel('Spectrum', size=12)\n ax1.legend()\n ax2.set_ylabel(\"Relative error\", size=12)\n title = f'{self.nuclide}'\n if self.thermal is not None:\n name, suffix = self.thermal.split('.')\n thermal_name = openmc.data.thermal.get_thermal_name(name)\n title += f' + {thermal_name}'\n title += f', {self.energy:.1e} eV Source'\n plt.title(title)\n \n # Save plot\n os.makedirs('plots', exist_ok=True)\n if self.name is not None:\n name = self.name\n else:\n name = f'{self.nuclide}'\n if self.thermal is not None:\n name += f'-{thermal_name}'\n name += f'-{self.energy:.1e}eV'\n if self._temperature is not None:\n name += f'-{self._temperature:.1f}K'\n plt.savefig(Path('plots') / f'{name}.png', bbox_inches='tight')\n plt.close()","def plot_inv_rv_dep(\n outpath,\n inv_RVs,\n alavs,\n alav_uncs,\n waves,\n plot_waves,\n slopes,\n intercepts,\n dense,\n norm=\"V\",\n):\n fig, ax = plt.subplots(\n len(plot_waves), figsize=(7, len(plot_waves) * 4), sharex=True\n )\n if norm != \"V\":\n norm = str(norm) + r\"\\mu m\"\n\n for j, wave in enumerate(plot_waves):\n indx = np.abs(waves - wave).argmin()\n # plot the data and the fitted line, give the dense sightlines a different color and marker\n handle1 = ax[j].errorbar(\n inv_RVs[dense][:, 0] - 1 / 3.1,\n alavs[indx][dense],\n xerr=(\n inv_RVs[dense][:, 1],\n inv_RVs[dense][:, 2],\n ),\n yerr=alav_uncs[indx][dense],\n ms=5,\n fmt=\"s\",\n color=\"magenta\",\n elinewidth=0.5,\n )\n handle2 = ax[j].errorbar(\n inv_RVs[~dense][:, 0] - 1 / 3.1,\n alavs[indx][~dense],\n xerr=(\n inv_RVs[~dense][:, 1],\n inv_RVs[~dense][:, 2],\n ),\n yerr=alav_uncs[indx][~dense],\n ms=5,\n fmt=\"ok\",\n elinewidth=0.5,\n )\n xs = np.arange(-0.155, 0.12, 0.01)\n ax[j].plot(\n xs,\n slopes[indx] * xs + intercepts[indx],\n color=\"forestgreen\",\n ls=\"-\",\n label=r\"$%5.3f\\, %+5.3f\\, [1/R(V)-1/3.1]$\"\n % (intercepts[indx], slopes[indx]),\n )\n ax[j].set_ylabel(r\"$A(\" + \"{:1.2f}\".format(wave) + \"\\mu m)/A(\" + norm + \")$\")\n ax[j].legend(loc=\"lower left\", fontsize=fs * 0.8)\n\n # add literature curves, only if normalized to A(V)\n if norm == \"V\":\n styles = [\"--\", \":\"]\n for i, cmodel in enumerate([CCM89, F19]):\n if wave > 3.3:\n continue\n yvals = []\n for xval in xs:\n ext_model = cmodel(Rv=1 / (xval + 1 / 3.1))\n yvals.append(ext_model(wave * u.micron))\n ax[j].plot(\n xs,\n yvals,\n lw=1.5,\n ls=styles[i],\n alpha=0.8,\n )\n line_handles = [\n Line2D([0], [0], color=\"tab:blue\", lw=1.5, ls=\"--\"),\n Line2D([0], [0], color=\"tab:orange\", lw=1.5, ls=\":\"),\n ]\n line_labels = [\n \"Cardelli et al. (1989)\",\n \"Fitzpatrick et al. (2019)\",\n ]\n\n # finalize the plot\n plt.xlabel(r\"$\\frac{1}{R(V)} - \\frac{1}{3.1}$\", fontsize=fs * 1.3)\n plt.subplots_adjust(hspace=0)\n handles = [handle1, handle2]\n labels = (\"dense\", \"diffuse\")\n fig.legend(handles, labels, bbox_to_anchor=(0.4, 0.19), fontsize=fs * 0.8)\n if norm == \"V\":\n fig.legend(\n line_handles, line_labels, bbox_to_anchor=(0.65, 0.8), fontsize=fs * 0.8\n )\n plt.savefig(\n outpath + \"inv_RV_dep\" + norm.split(\"\\\\\")[0] + \".pdf\", bbox_inches=\"tight\"\n )","def plot_mse(mse, lambda0, lambda1, scale, loc='lower right'):\n import matplotlib.pyplot as plt\n\n fig = plt.figure()\n ax = fig.add_subplot(211)\n ax.plot(*zip(*mse))\n plt.xlabel('$\\lambda$')\n plt.ylabel('MSE')\n plt.yticks(scale)\n\n ax = fig.add_subplot(212)\n ax.plot(*zip(*lambda0), label='$\\lambda=0$')\n plt.xlabel('Episode')\n plt.ylabel('MSE')\n ax.plot(*zip(*lambda1), label='$\\lambda=1$')\n plt.legend(loc=loc)\n\n plt.show()","def rmse(self):\n y_pred, y_true = self._finalize_labels_and_prediction()\n\n return np.sqrt(F.mse_loss(y_pred, y_true).cpu().item())","def rmse(self):\n y_pred, y_true = self._finalize_labels_and_prediction()\n\n return np.sqrt(F.mse_loss(y_pred, y_true).cpu().item())","def lm_model(x_all, y_all, print_ind = True, plot_ind = True):\n \n # data\n x_train = x_all[x_all[\"yyyymm\"] < TRAIN_DATE].iloc[:,1:].to_numpy()\n x_test = x_all[x_all[\"yyyymm\"] >= TRAIN_DATE].iloc[:,1:].to_numpy()\n y_train = y_all[y_all[\"yyyymm\"] < TRAIN_DATE].iloc[:,1].to_numpy()\n y_test = y_all[y_all[\"yyyymm\"] >= TRAIN_DATE].iloc[:,1].to_numpy()\n \n # Fit model\n X = sm.add_constant(x_train)\n lm = sm.OLS(y_train, X).fit()\n \n if print_ind:\n print(lm.summary())\n print()\n \n # test\n X_test = sm.add_constant(x_test)\n ypred = lm.predict(X_test)\n MSE = np.sum((ypred - y_test)**2) / len(y_test)\n\n # plot\n if plot_ind:\n # Residual plot\n plt.figure(figsize = (10,7))\n plt.scatter(lm.fittedvalues, lm.resid)\n plt.xlabel('Fitted Value', fontsize = 15)\n plt.ylabel('Residual', fontsize = 15)\n plt.title(\"Residual plot\", fontsize = 25)\n plt.axhline(y = 0)\n plt.show()\n \n # QQ plot\n plt.figure(figsize = (10,7))\n sm.ProbPlot(lm.resid).qqplot()\n plt.title(\"qq-plot\", fontsize = 25)\n abline(1,0)\n plt.show()\n \n # print\n if print_ind:\n print(\"Test MSE: {:.6f}\".format(MSE))\n print(\"Test MSE as % of square mean: {:.6f}\".format(MSE / (np.mean(y_test) ** 2)))\n \n \n return lm, MSE","def convergence():\n fig, axes = plt.subplots(nrows=2, figsize=figsize(aspect=1.2))\n\n # label names\n label1 = str(league.lambda1)\n label2_list = [str(lambda2) for lambda2 in league.lambda2_list]\n\n # point spread and point total subplots\n subplots = [\n (False, [-0.5, 0.5], league.spreads, 'probability spread > 0.5'),\n (True, [200.5], league.totals, 'probability total > 200.5'),\n ]\n\n for ax, (commutes, lines, values, ylabel) in zip(axes, subplots):\n\n # train margin-dependent Elo model\n melo = Melo(lines=lines, commutes=commutes, k=1e-4)\n melo.fit(league.times, league.labels1, league.labels2, values)\n\n line = lines[-1]\n\n for label2 in label2_list:\n\n # evaluation times and labels\n times = np.arange(league.times.size)[::1000]\n labels1 = times.size * [label1]\n labels2 = times.size * [label2]\n\n # observed win probability\n prob = melo.probability(times, labels1, labels2, lines=line)\n ax.plot(times, prob)\n\n # true (analytic) win probability\n if ax.is_first_row():\n prob = skellam.sf(line, int(label1), int(label2))\n ax.axhline(prob, color='k')\n else:\n prob = poisson.sf(line, int(label1) + int(label2))\n ax.axhline(prob, color='k')\n\n # axes labels\n if ax.is_last_row():\n ax.set_xlabel('Iterations')\n ax.set_ylabel(ylabel)\n\n set_tight(w_pad=.5)","def plotErr(self):\n if self.xp and self.wp:\n # plot the spectra\n w=self.ws.value(np.array(self.xp))\n self.errcurve,=self.erraxes.plot(self.xp,self.wp-w,linewidth=0.5,linestyle='',marker='o',color='b')\n if self.dxp and self.dwp:\n # plot the spectra\n dw=self.ws.value(np.array(self.dxp))\n self.delerrcurve,=self.erraxes.plot(self.dxp,self.dwp-dw,linewidth=0.5,linestyle='',marker='x',color='b')","def visualization(epochs, mse_tr, mse_te):\n plt.semilogx(epochs, mse_tr, marker=\".\", color='b', label='train error')\n plt.semilogx(epochs, mse_te, marker=\".\", color='r', label='test error')\n plt.xlabel(\"k\")\n plt.ylabel(\"rmse\")\n plt.title(\"cross validation\")\n plt.legend(loc=2)\n plt.grid(True)\n plt.savefig(\"cross_validation\")","def plot_residuals(result_file,output_fig=None,fig=None,**kwargs):\n \n \n #### Read file\n \n dic_result=file2dic(result_file)\n\n ### Get xbin range\n \n rms_val=np.append(dic_result['RMS_P'],dic_result['RMS_S'])\n x_bins=np.linspace(np.min(rms_val),np.max(rms_val),100)\n \n ### Plots\n \n if fig is None:\n fig, (ax1, ax2) = plt.subplots(2, sharex=True)\n else: \n (ax1,ax2)=fig.get_axes()\n \n ax1.hist(dic_result['RMS_P'],x_bins,edgecolor='black',**kwargs)\n ax1.set_title('RMS for %i models tested'%(len(dic_result['RMS_P'])))\n ax1.set_ylabel('P')\n ax1.tick_params('x',direction='in')\n ax2.hist(dic_result['RMS_S'],x_bins,edgecolor='black',**kwargs)\n ax2.invert_yaxis()\n ax2.set_xlabel('RMS [s]')\n ax2.set_ylabel('S')\n \n fig.subplots_adjust(hspace=0)\n plt.setp([a.get_xticklabels() for a in fig.axes[:-1]], visible=False)\n \n if output_fig:\n plt.savefig(output_fig)\n \n \n return fig","def rmse(sim, obs, dim=\"time\"):\n rmse = np.sqrt(mse(sim, obs, dim=dim))\n rmse.name = \"rmse\"\n return rmse","def ivrmse(self):\n return (self.model_error_iv()**2).mean()**.5","def RMSE(y,yhat):\r\n return(np.sqrt(MSE(y,yhat)))","def plot4(self, plog=False):\n\n probs = pd.read_csv(self.probfile)\n\n plt.rc('font', size=14)\n fig, ax = plt.subplots()\n plt.plot(self.ds.freq, self.snr, 'k-', alpha=0.5, zorder=1)\n\n # plot the SNR range to search across when finding snr_modes\n for idx, line in enumerate(self.ds.mode_id['f0']):\n w = np.exp(self.ds.mode_id['w0'][idx])\n plt.axvline(x=line-w, color='b', linestyle='-', alpha=0.4)\n plt.axvline(x=line+w, color='b', linestyle='-', alpha=0.4)\n\n # overplot the predicted SNR values at the modes\n plt.scatter(probs['f0'], probs['SNR_Kepler'], label='Kepler - 4yrs', alpha=1, zorder=2)\n plt.scatter(probs['f0'], probs['SNR_TESS365'], label='TESS - 1 yr', alpha=1, zorder=3)\n plt.scatter(probs['f0'], probs['SNR_TESS27'], label='TESS - 27 days', alpha=1, zorder=4)\n\n if plog:\n plt.xscale('log')\n plt.yscale('log')\n plt.xlabel(r'$\\nu$ / $\\rm \\mu Hz$')\n plt.ylabel(r'SNR')\n\n mn = min(star.ds.mode_id['f0']) -\\\n (max(star.ds.mode_id['f0'])-min(star.ds.mode_id['f0']))/7.\n mx = max(star.ds.mode_id['f0']) +\\\n (max(star.ds.mode_id['f0'])-min(star.ds.mode_id['f0']))/7.\n plt.xlim([mn,mx])\n\n plt.legend()\n plt.title('KIC ' + str(self.ds.epic))\n plt.show()\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\n 'plot4_SNR' + self.ds.epic + '.pdf')","def find_best_rmse(name, x_train, y_train, x_test, y_test, k_max=23, metric='euclidean', plot=True, debug=False):\n \"\"\"\n :param k_max: maximum number of k to test for\n :param plot: True if matplotlib plot should be created\n :param debug: print additional info about accuracy test results\n :return: best k and best accuracy for given training and test set with features (k < k_max)\n \"\"\"\n\n # Go through all k between k=1 and k=k_max-1 and find best_k and best_a\n # rsmes = np.zeros(k_max) # Write rsmes for each k into here for plot to work...\n\n rmse_val = [] # to store rmse values for different k\n for k in range(1, k_max):\n model = neighbors.KNeighborsRegressor(n_neighbors=k, metric=metric)\n model.fit(x_train, y_train) # fit the model\n pred = model.predict(x_test) # make prediction on test set\n rsme = sqrt(mean_squared_error(y_test, pred)) # calculate rmse\n\n if k == 1:\n best_rmse = rsme\n best_k = k\n elif rsme < best_rmse:\n best_rmse = rsme\n best_k = k\n\n rmse_val.append(rsme) # store rmse values\n if debug:\n print('RMSE value for k=', k, 'is:', rsme)\n\n if plot:\n t = range(1, k_max)\n plt.plot(t, rmse_val[0:k_max - 1], '--', label=name)\n plt.xticks(t)\n plt.xlabel('# neighbours (k)')\n plt.ylabel('Root Mean Squared Error')\n plt.scatter(best_k, best_rmse)\n plt.legend()\n return best_rmse, best_k","def plot_spectrum(data, name, fig):\n\n det = data.detectors[name]\n val = det.tallies\n\n E = [line[0] for line in det.grids['E']]\n Emax = det.grids['E'][-1][1]\n\n dE = np.roll(E, -1) - E\n dE[-1] = Emax - E[-1]\n inte = sum(val*dE)\n val = val/inte\n\n plt.figure()\n plt.loglog(E, val)\n plt.xlabel('E [MeV]')\n plt.ylabel('Normalized flux')\n plt.grid(True)\n plt.savefig(fig + '-' + name, dpi=300, bbox_inches=\"tight\")","def analyze(data):\n # perform fit\n regr_results = sm.OLS.from_formula('mosquitos ~ temperature + rainfall', data).fit()\n print(regr_results.tvalues)\n \n fig = plt.figure(figsize=(6, 9))\n\n # plot predicted vs. measured mosquito populations from fitted model \n ax0 = fig.add_subplot(3, 1, 1)\n\n parameters = regr_results.params\n predicted = (parameters['Intercept'] + \n parameters['temperature'] * data['temperature'] + \n parameters['rainfall'] * data['rainfall'])\n\n ax0.plot(predicted, data['mosquitos'], 'gd')\n\n ax0.set_xlabel('predicted mosquito population')\n ax0.set_ylabel('measured mosquito population')\n \n # plot mosquitos vs. temperature\n ax1 = fig.add_subplot(3, 1, 2)\n\n ax1.plot(data['temperature'], data['mosquitos'], 'ro')\n ax1.set_xlabel('temperature')\n ax1.set_ylabel('mosquitos')\n\n # plot mosquitos vs. rainfall\n ax2 = fig.add_subplot(3, 1, 3)\n\n ax2.plot(data['rainfall'], data['mosquitos'], 'bs')\n ax2.set_xlabel('rainfall')\n ax2.set_ylabel('mosquitos')\n \n # adjust layout of axes according to label placement\n plt.tight_layout()\n \n return fig","def plot(res,code,reactor=None,groupby='PeriodEndYrMn', hline=None):\r\n box = res.boxplot(column='ResultsValue', showfliers=False, return_type=None, by=groupby, patch_artist=False)\r\n #box['boxes'].set_facecolor('green')\r\n ind = code.strip()\r\n lab = ind if reactor is None else ind + ' ' +reactor.strip()\r\n plt.ylabel(lab)\r\n plt.xticks(rotation=60)\r\n plt.title('')\r\n if hline is not None:\r\n plt.axhline(y=hline[0], color='r', linestyle='-', label='Individual target')\r\n plt.axhline(y=hline[1], color='b', linestyle='-', label='Industry target')\r\n plt.legend()\r\n plt.tight_layout()\r\n #plt.show()\r\n fn = 'pic/'+ind+'_trend.png' if reactor is None else 'pic/'+ind+'_'+reactor.strip()+'_trend.png'\r\n plt.savefig(fn)\r\n print(fn+' is saved')","def MSE(actual, noisy):\n mean_squared_error(actual, noisy)","def plot_em_steps(smp, r, mue, sge, lme, nm, ns):\n x = np.linspace(-20, 20, 400)\n clr = 0.6\n clrs = [(1, 0.2, 0), (0, 1, 0), (0, 0.6, 1)]\n plt.hist(smp, 100, normed=1, color=(0.7, 0.7, 0.7))\n for i in range(ns):\n cl = (clr*r[0, i], clr*r[1, i], clr*r[2, i])\n plt.plot(smp[i], -0.05, '.', color=cl, markersize=2)\n for k, c in zip(range(nm), clrs):\n plt.plot(x, lme[k] * spst.norm(mue[k], sge[k]).pdf(x), color=clrs[k])","def plotDistributionWithRegression(lXs, lYs, rXs, rYs, slope, intercept, R2, pval, meanPhase, stdvPhase,out=\"\", title=\"\", xax=\"\", yax=\"\"):\n\n fig = plt.Figure(figsize=(20,20))\n fig.suptitle(title, fontsize=32)\n ax = fig.add_subplot(111)\n ax.plot(lXs,lYs)\n annotation_font = {'size':16}\n for i in rYs:\n ax.annotate(str(i),xy=(i-10,lYs[i]+10), **annotation_font)\n ax.scatter([i for i in rYs],[lYs[i] for i in rYs],color='red',marker='+', s=200)\n axis_font = {'size':'28'}\n ax.set_xlabel(xax, **axis_font)\n ax.set_ylabel(yax, **axis_font)\n ax.tick_params(labelsize=20)\n ax.set_xlim(0,lXs[-1]+10)\n ax.set_ylim(min(lYs)-10,max(lYs)+10)\n # add regression graph\n ax2 = fig.add_axes([0.55,0.55,0.3,0.3])\n # ax2.axis([0,rXs[-1],0,rYs[-1]])\n ax2.set_xlim(0,rXs[-1]+2)\n ax2.scatter([x+1 for x in rXs],rYs)\n ax2.plot([x+1 for x in rXs], [x*slope+intercept for x in rXs], color='red')\n axis_font2 = {'size':'18'}\n ax2.set_title('linear regression', **axis_font2)\n ax2.set_xlabel('#peak', **axis_font2)\n ax2.set_ylabel('positions bp', **axis_font2)\n ax2.tick_params(labelsize=16)\n ax2.text(0.5,rYs[-1]*0.95 , 'Phase={}+-{}'.format(meanPhase,stdvPhase),\n verticalalignment='top', horizontalalignment='left',\n fontsize=15)\n ax2.text(0.5,rYs[-1]*0.9, 'R2={}'.format(R2),\n verticalalignment='top', horizontalalignment='left',\n fontsize=15)\n ax2.text(0.5,rYs[-1]*0.85, 'p-value={}'.format(pval),\n verticalalignment='top', horizontalalignment='left',\n fontsize=15)\n canvas = FigureCanvasAgg(fig)\n canvas.print_figure(out, dpi=80)","def _plot(self, rewards, losses, epsilons):\n plt.figure(figsize=(20,5))\n plt.subplot(131)\n plt.title('Episodic Reward')\n plt.plot(rewards)\n plt.subplot(132)\n plt.title('TD Loss')\n plt.plot(losses)\n plt.subplot(133)\n plt.title('Epsilon')\n plt.plot(epsilons)\n plt.tight_layout()\n plt.show()","def plot_inv_RV_lit(outpath, fit_slopes, fit_intercepts, fit_stds):\n waves = np.arange(0.8, 4.01, 0.001)\n fig, ax = plt.subplots(figsize=(10, 9))\n\n for i, RV in enumerate([2.5, 3.1, 5.5]):\n # plot the extinction curve from this work\n offset = 0.1 * i\n slopes = interpolate.splev(waves, fit_slopes)\n alav = fit_intercepts(waves) + slopes * (1 / RV - 1 / 3.1)\n (line,) = ax.plot(waves, alav + offset, lw=1.5, label=r\"$R(V) = $\" + str(RV))\n stddev = interpolate.splev(waves, fit_stds)\n color = line.get_color()\n ax.fill_between(\n waves,\n alav + offset - stddev,\n alav + offset + stddev,\n color=color,\n alpha=0.2,\n edgecolor=None,\n )\n\n # plot the literature curves\n styles = [\"--\", \":\"]\n for i, cmodel in enumerate([CCM89, F19]):\n ext_model = cmodel(Rv=RV)\n (indxs,) = np.where(\n np.logical_and(\n 1 / waves >= ext_model.x_range[0], 1 / waves <= ext_model.x_range[1]\n )\n )\n yvals = ext_model(waves[indxs] * u.micron)\n ax.plot(\n waves[indxs],\n yvals + offset,\n lw=1.5,\n color=color,\n ls=styles[i],\n alpha=0.8,\n )\n\n # add text\n ax.text(3.45, 0.03, r\"$R(V) = 2.5$\", fontsize=0.8 * fs, color=\"tab:blue\")\n ax.text(3.45, 0.15, r\"$R(V) = 3.1$\", fontsize=0.8 * fs, color=\"tab:orange\")\n ax.text(3.45, 0.305, r\"$R(V) = 5.5$\", fontsize=0.8 * fs, color=\"tab:green\")\n\n # finalize and save the plot\n ax.set_xlabel(r\"$\\lambda\\ [\\mu m$]\", fontsize=1.2 * fs)\n ax.set_ylabel(r\"$A(\\lambda)/A(V)$ + offset\", fontsize=1.2 * fs)\n ax.set_xlim(0.75, 4.05)\n ax.set_ylim(-0.03, 0.98)\n handles = [\n Line2D([0], [0], color=\"k\", lw=1.5),\n Line2D([0], [0], color=\"k\", lw=1.5, ls=\"--\"),\n Line2D([0], [0], color=\"k\", lw=1.5, ls=\":\"),\n ]\n labels = [\n \"this work\",\n \"Cardelli et al. (1989)\",\n \"Fitzpatrick et al. (2019)\",\n ]\n plt.legend(handles, labels, fontsize=fs)\n plt.savefig(outpath + \"inv_RV_lit.pdf\", bbox_inches=\"tight\")\n\n # also save the plot in log scale\n plt.ylim(0.01, 1)\n plt.yscale(\"log\")\n plt.tight_layout()\n plt.savefig(outpath + \"inv_RV_lit_log.pdf\")","def RMSE(obs, sim):\n obs = obs.flatten()\n sim = sim.flatten()\n\n return np.sqrt(np.mean((obs - sim) ** 2))","def evaluate(self, X_test, y_test):\n pipeline = run()\n y_pred = pipeline.predict(X_test)\n rmse = compute_rmse(y_pred, y_test)\n print(rmse)\n return rmse","def _show_learning_rate():\n fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(6.4 * 2, 4.8))\n\n # Visualize c_prime\n c_prime_list = np.linspace(1, 100, num=11)\n x_label = f\"c'\"\n y_label = \"Minimum Clusters Size\"\n title = \"\"\n\n ax = axes[0]\n x_list = c_prime_list\n\n # MNIST\n y_list = [161, 16, 14, 15, 20, 21, 24, 27, 30, 30, 35]\n ax.plot(x_list, y_list, label=\"MNIST\")\n\n # Fashion MNIST\n y_list = [63, 12, 12, 15, 18, 19, 22, 25, 26, 28, 30]\n ax.plot(x_list, y_list, label=\"Fashion MNIST\")\n\n # 20 news groups\n y_list = [1297, 724, 221, 80, 52, 51, 54, 54, 52, 60, 60]\n ax.plot(x_list, y_list, label=\"Newsgroups\")\n\n ax.set_xlabel(x_label)\n ax.set_ylabel(y_label)\n ax.set_title(title)\n ax.legend()\n ax.set_yscale('log')\n\n # Visualize t0\n t0_list = np.linspace(1, 100, num=11)\n x_label = f\"t0\"\n y_label = \"Minimum Clusters Size\"\n title = \"\"\n\n ax = axes[1]\n x_list = t0_list\n\n # MNIST\n y_list = [16, 16, 16, 16, 16, 17, 16, 16, 16, 16, 16]\n ax.plot(x_list, y_list, label=\"MNIST\")\n\n # Fashion MNIST\n y_list = [12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12]\n ax.plot(x_list, y_list, label=\"Fashion MNIST\")\n\n # 20 news groups\n y_list = [765, 765, 767, 772, 772, 773, 789, 789, 793, 796, 799]\n ax.plot(x_list, y_list, label=\"Newsgroups\")\n\n ax.set_xlabel(x_label)\n ax.set_ylabel(y_label)\n ax.set_title(title)\n ax.legend()\n ax.set_yscale('log')\n\n plt.show()","def computeRmse(model, data, n):\n print \"RESULT_data:%s \" % ((data.map(lambda x: (x[0], x[1]))).take(50))\n predictions1 = model.predictAll(data.map(lambda x: (x[0], x[1])))\n print \"RESULT1: %s\" % predictions1\n predictionsAndRatings = predictions1.map(lambda x: ((x[0], x[1]), x[2])) \\\n .join(data.map(lambda x: ((x[0], x[1]), x[2]))) \\\n .values()\n #print \"RESULT2: %s\" % predictions1.take(11)\n return sqrt(predictionsAndRatings.map(lambda x: (x[0] - x[1]) ** 2).reduce(add) / float(n))","def calculate_rmse(x_value, target_value, model_function, fit_parameters):\n if len(target_value) != len(x_value):\n raise ValueError(\"Value length not match\")\n\n n = len(fit_parameters)\n if n == 1:\n fit_A = fit_parameters[0]\n fit_value = model_function(x_value, fit_A)\n elif n == 2:\n fit_A = fit_parameters[0]\n fit_B = fit_parameters[1]\n fit_value = model_function(x_value, fit_A, fit_B)\n elif n == 3:\n fit_A = fit_parameters[0]\n fit_B = fit_parameters[1]\n fit_C = fit_parameters[2]\n fit_value = model_function(x_value, fit_A, fit_B, fit_C)\n else:\n raise ValueError(\"Function do not support that model\")\n\n RMSE = np.sqrt(sum((target_value - fit_value)**2)/len(target_value))\n return RMSE","def test_rr_se(results):\n truese = np.asarray([2.09826858, 30.60745128, 108.51947421, 0.95693751,\n 0.6564318])\n test_se = results.params_se()\n assert test_se == pytest.approx(truese)","def plot_eos(eos_pk):\n import pylab as pl\n from aiida.orm import load_node\n eos_calc=load_node(eos_pk)\n eos_result=eos_calc.out.result\n raw_data = eos_result.dict.eos_data\n \n data = []\n for V, E, units in raw_data:\n data.append((V,E))\n \n data = np.array(data)\n params, covariance = fit_birch_murnaghan_params(data[:,0],data[:,1])\n \n vmin = data[:,0].min()\n vmax = data[:,0].max()\n vrange = np.linspace(vmin, vmax, 300)\n\n pl.plot(data[:,0],data[:,1],'o')\n pl.plot(vrange, birch_murnaghan(vrange, *params))\n\n pl.xlabel(\"Volume (ang^3)\")\n # I take the last value in the list of units assuming units do not change\n pl.ylabel(\"Energy ({})\".format(units))\n pl.show()","def plotFittingResults(self):\n _listFitQ = [tmp.getValue() for tmp in self.getDataOutput().getScatteringFitQ()]\n _listFitValues = [tmp.getValue() for tmp in self.getDataOutput().getScatteringFitValues()]\n _listExpQ = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataQ()]\n _listExpValues = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataValues()]\n\n #_listExpStdDev = None\n #if self.getDataInput().getExperimentalDataStdDev():\n # _listExpStdDev = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataStdDev()]\n #if _listExpStdDev:\n # pylab.errorbar(_listExpQ, _listExpValues, yerr=_listExpStdDev, linestyle='None', marker='o', markersize=1, label=\"Experimental Data\")\n # pylab.gca().set_yscale(\"log\", nonposy='clip')\n #else: \n # pylab.semilogy(_listExpQ, _listExpValues, linestyle='None', marker='o', markersize=5, label=\"Experimental Data\")\n\n pylab.semilogy(_listExpQ, _listExpValues, linestyle='None', marker='o', markersize=5, label=\"Experimental Data\")\n pylab.semilogy(_listFitQ, _listFitValues, label=\"Fitting curve\")\n pylab.xlabel('q')\n pylab.ylabel('I(q)')\n pylab.suptitle(\"RMax : %3.2f. Fit quality : %1.3f\" % (self.getDataInput().getRMax().getValue(), self.getDataOutput().getFitQuality().getValue()))\n pylab.legend()\n pylab.savefig(os.path.join(self.getWorkingDirectory(), \"gnomFittingResults.png\"))\n pylab.clf()","def rmse(actual, predicted):\n rms = (actual-predicted)**2\n\n # Returning the sqaure root of the root mean square\n return float(np.sqrt(rms.mean()))","def plot_errors(self):\n\n plt.title(\"Prediction Error\")\n plt.plot(self.errors)\n plt.ylabel(\"MSE (Mean Squared Error)\")\n plt.xlabel(\"Iteration\")\n plt.show()","def variations_plot(S0, K, B, T, N, u, d, q, M, barrier_type, option,\n MC_runs, price_tree):\n x_values = []\n pi_M = []\n pi_M_RMSE = []\n for i in range(1, MC_runs, 1):\n Mi = M * i\n x_values.append([Mi])\n paths = sample_paths(S0, N, u, d, q, Mi)\n p_valid, p_invalid, p_counts = split_paths(paths, B, K,\n barrier_type, option)\n if option == 'Call':\n payoffs = np.maximum(0, p_counts[:, -1] - K) * np.exp(-1 * r * T)\n elif option == 'Put':\n payoffs = np.maximum(0, K - p_counts[:, -1]) * np.exp(-1 * r * T)\n payoffs = list(payoffs)\n while len(payoffs) < Mi:\n payoffs.append([0])\n mean_payoff = np.mean(payoffs)[0]\n pi_M.append(mean_payoff)\n RMSE = np.sqrt(np.var(payoffs, ddof=1)) / np.sqrt(Mi)\n pi_M_RMSE.append(RMSE[0])\n\n # plotting\n plt.figure(figsize=(8, 6))\n plt.subplot(2, 1, 1)\n plt.plot(x_values, price_tree - 1.96 * np.array(pi_M_RMSE), '--', c='grey')\n plt.plot(x_values, price_tree + 1.96 * np.array(pi_M_RMSE), '--', c='grey')\n plt.plot(x_values, pi_M, 'o', label='price via MC')\n plt.plot(x_values, [price_tree] * len(x_values), '-', lw=3,\n label='price via tree')\n plt.legend()\n plt.title('Monte Carlo price, for increasing number of paths')\n plt.ylabel('Expected Value')\n # The following will plot the root mean square error\n plt.subplot(2, 1, 2)\n plt.plot(x_values, pi_M_RMSE, '-')\n plt.xlabel('number of paths')\n plt.ylabel('Root Mean Square Error')\n # plt.savefig('MonteCarlo_variation.png', transparent=True)\n plt.show()","def plot_candidate_design_rmse(\n response: str, num_pairs: int,\n results: pd.DataFrame) -> Dict[Tuple[float, float], plt.Axes]:\n budget_list = results['budget'].unique()\n iroas_list = results['iroas'].unique()\n axes_dict = {}\n for budget in budget_list:\n for iroas in iroas_list:\n result = results[(results['budget'] == budget)\n & (results['iroas'] == iroas)].reset_index(drop=True)\n hlines = range(\n 0,\n int(max(max(result['rmse']), max(result['rmse_cost_adjusted']))) + 1)\n\n delta = (max(result['rmse']) - min(result['rmse'])) * 0.05\n\n fig = plt.figure(figsize=(20, 10))\n ax = fig.add_subplot(1, 1, 1)\n ax.plot(\n result['pair_index'], result['rmse'], 'blue', label='RMSE')\n ax.plot(\n result['pair_index'],\n result['rmse_cost_adjusted'],\n 'red',\n label='Cost adjusted RMSE')\n ax.set_xlim(\n min(result['pair_index']) - 1,\n max(result['pair_index']) + 1)\n ax.set_ylim(\n min(result.rmse) - delta,\n max(result.rmse_cost_adjusted) + delta)\n ax.legend()\n ax.hlines(\n y=hlines,\n xmin=min(result['pair_index']),\n xmax=max(result['pair_index']),\n colors='gray',\n linestyles='dashed')\n for _, row in result.iterrows():\n ax.text(\n row.pair_index + 1, row.rmse + delta,\n '{}'.format(\n util.human_readable_number(row.experiment_response)))\n ax.set_xlabel('Pairing number')\n ax.set_ylabel('RMSE')\n ax.set_title(\n f'''RMSE of iROAS w.r.t. {response} (total pairs: {num_pairs})''')\n axes_dict[(budget, iroas)] = fig\n plt.close()\n\n return axes_dict","def plot_price_evolution_for_nr_run(nr_log):\n plt.figure(figsize=(10, 5))\n\n plt.plot(nr_log['time'], nr_log['virtual_price'], '.', label='NR')\n\n plt.legend()\n\n plt.grid()\n\n plt.title('Network Relaxation run - Grid price evolution')\n\n plt.xlabel('time [s]')\n\n plt.ylabel('price [$]')\n\n plt.show()","def cross_validation_visualization(lambdas, loss_train, loss_test):\n plt.semilogx(lambdas, loss_train, marker=\".\", color='b', label='train error')\n plt.semilogx(lambdas, loss_test, marker=\".\", color='r', label='test error')\n plt.xlabel(\"lambda\")\n plt.ylabel(\"rmse\")\n plt.title(\"cross validation\")\n plt.legend(loc=2)\n plt.grid(True)\n plt.savefig(\"cross_validation_mse\")","def plot_test_vs_validation_set(output_name, C, sigma, M, xlim=None, ylim=None, xticks=None, yticks=None):\n import matplotlib.pyplot as plt\n plt.ioff()\n plt.style.use('./latex-paper.mplstyle')\n plt.figure()\n ax = plt.axes()\n ax.yaxis.grid(True)\n\n d = pickler.load(f'categorical_K2_C{C}_sigma{sigma:.2f}_M{M}'.replace('.','_'))\n x_values = [x.n_train for x in d.xs]\n plt.plot(x_values, d.results[:,0], 'C0-', label=r'$\\mathrm{e}_{\\mathrm{val}}(m=n)$')\n plt.plot(x_values, d.results[:,1], 'C1-', label=r'$\\mathrm{e}_{\\mathrm{gen}}(m=n)$')\n\n d = pickler.load(f'categorical_LOO_C{C}_sigma{sigma:.2f}_M{M}'.replace('.','_'))\n x_values = [x.n_train for x in d.xs]\n plt.plot(x_values, d.results[:,0], 'C0--', label=r'$\\mathrm{e}_{\\mathrm{val}}(m=1)$')\n plt.plot(x_values, d.results[:,1], 'C1--', label=r'$\\mathrm{e}_{\\mathrm{gen}}(m=1)$')\n\n plt.xlabel('n')\n plt.ylabel('MSE')\n if xlim is not None:\n plt.xlim(xlim)\n if ylim is not None:\n plt.ylim(ylim)\n if xticks is not None:\n plt.xticks(xticks)\n if yticks is not None:\n plt.yticks(yticks)\n \n plt.legend(loc='best')\n simulations_framework.save_figure(output_name + f'_reps{d.n_repetitions}')","def plot_observed_predicted(y_data, y_predict, ols_line=False, model_fit=None, figsize=(15, 10), save=False, end_name_fig='', folder='Charts'): \r\n\r\n end_name_fig = end_name_fig + '_' if end_name_fig is not None else ''\r\n\r\n fig, ax = plt.subplots(figsize=figsize)\r\n ax.scatter(y_data, y_predict)\r\n \r\n if ols_line == False:\r\n ax.plot([y_data.min(), y_data.max()], [y_data.min(), y_data.max()], 'k--', lw=4)\r\n\r\n else:\r\n line_fit = sm.OLS(y_data, sm.add_constant(y_predict, prepend=True)).fit()\r\n abline_plot(model_results=line_fit, ax=ax)\r\n\r\n ax.set_title('Predicted vs Observed')\r\n ax.set_ylabel('Observed values')\r\n ax.set_xlabel('Predicted values')\r\n\r\n if save == True:\r\n plt.savefig(folder + '/predict_observed_' + end_name_fig + '.png')\r\n\r\n if model_fit is not None:\r\n \r\n fig, ax = plt.subplots(figsize=figsize)\r\n ax.scatter(y_predict, model_fit.resid_pearson)\r\n ax.hlines(0, 0, 1)\r\n ax.set_xlim(0, 1)\r\n ax.set_title('Residual Dependence Plot')\r\n ax.set_ylabel('Pearson Residuals')\r\n ax.set_xlabel('Fitted values') \r\n\r\n if save == True:\r\n plt.savefig(folder + '/pearson_residuals_' + end_name_fig + '.png')\r\n\r\n\r\n fig, ax = plt.subplots(figsize=figsize)\r\n res_dev_residuals = model_fit.resid_deviance.copy()\r\n res_dev_residuals_std = stats.zscore(res_dev_residuals)\r\n ax.hist(res_dev_residuals_std, bins=25)\r\n ax.set_title('Histogram of standardized deviance residuals')\r\n\r\n if save == True:\r\n plt.savefig(folder + '/standard_deviance_residuals_' + end_name_fig + '.png')\r\n\r\n graphics.gofplots.qqplot(res_dev_residuals, line='r')\r\n\r\n if save == True:\r\n plt.savefig(folder + '/gofplot_' + end_name_fig + '.png')","def plot_regression(e_predict, e_true, ax=None, label='', e_max=0.5):\n ax = ax or plt.gca()\n ax.scatter(e_true, e_predict, lw=0, alpha=0.5, s=10)\n ax.set_xlabel('True shear')\n ax.set_ylabel('Predicted shear')\n ax.set_xlim(0, e_max)\n ax.set_ylim(0, e_max)\n ax.plot([0, e_max], [0, e_max], 'r--')\n R2 = sklearn.metrics.r2_score(e_true, e_predict)\n ax.text(0.05, 0.9, f'{label}$R^2 = {R2:.2f}$',\n transform=ax.transAxes, fontsize=16, color='r')","def rmse(datasets):\n\n rmse = []\n for k,v in datasets.items():\n reg = linregress(v.X,v.Y)\n pred = []\n \n for i in range(v.shape[0]):\n pred.append((v.loc[i].X*reg.slope)+reg.intercept)\n pred = pd.Series(pred)\n \n rmse.append(np.sqrt(np.mean((pred-v.Y)**2)))\n \n return pd.Series(rmse)","def plot(self, figshow=None, figsave=None, figname=None):\n self.rv()\n fig, ax = plt.subplots(1,1, figsize=(8,6))\n ax.tick_params(which='major', labelsize=20, direction='in', top=True, right=True, length=6, width=1.4)\n ax.tick_params(which='minor', labelsize=20, direction='in', top=True, right=True, length=3, width=1.4)\n for axis in ['top','bottom','left','right']: ax.spines[axis].set_linewidth(2.0)\n bins = np.linspace(min(self.mcsigmarv)*0.99, max(self.mcsigmarv)*1.01, num=100)\n posty, postx, patches = ax.hist(self.mcsigmarv, bins=bins, ec='b', color='gray', density=True)\n ax.plot([self.sigmarv, self.sigmarv], [0, max(posty)], 'r')\n ax.plot([self.sigmarv+self.sigmarvperr, self.sigmarv+self.sigmarvperr], [0, max(posty)], '--r')\n ax.plot([self.sigmarv-self.sigmarvmerr, self.sigmarv-self.sigmarvmerr], [0, max(posty)], '--r')\n minorLocator = AutoMinorLocator()\n ax.xaxis.set_minor_locator(minorLocator)\n minorLocator = AutoMinorLocator()\n ax.yaxis.set_minor_locator(minorLocator)\n ax.set_xlabel(r'$\\sigma_{\\rm rms, rv}\\ [\\rm m/s]$', fontsize=20)\n ax.set_ylabel('Probability Density', fontsize=20)\n ax.annotate(r'$\\sigma_{\\rm rms,\\ RV}$', xy=(0.45, 0.9), xycoords=\"axes fraction\", fontsize=18)\n ax.annotate(r'= {:.2f} +{:.2f} -{:.2f} [m/s]'.format(self.sigmarv, self.sigmarvperr, self.sigmarvmerr), xy=(0.58, 0.9), xycoords=\"axes fraction\", fontsize=15)\n plt.tight_layout()\n if figsave==True: plt.savefig(figname) if figname is not None else plt.savefig('rvjitter.png')\n if figshow==True: plt.show()\n plt.close('all')\n return self.sigmarv, self.sigmarvperr, self.sigmarvmerr, self.mcsigmarv","def rmse(a,b):\n \n ### Import modules\n import numpy as np\n \n ### Calculate RMSE\n rmse_stat = np.sqrt(np.mean((a - b)**2))\n \n return rmse_stat","def compute_rmse(y, tx, w):\n return np.sqrt(2*compute_mse(y,tx,w))","def fit(self, plot_loss=True):\n adam = optim.Adam(self.learning_rate)\n self.svi = SVI(\n self.vae_model, \n self.vae_guide, \n adam, \n Trace_ELBO()\n )\n # encoder_nn = self.vae_encoder()\n # decoder_nn = self.vae_decoder()\n rng_key, rng_key_samp, rng_key_init = random.split(self.rng_key, 3)\n\n self.gp_predictive = Predictive(self.gp.sample, num_samples=self.batch_size)\n\n # initialise with a sample batch\n sample_batch = self.gp_predictive(rng_key=rng_key_samp, x=self.x)\n \n svi_state = self.svi.init(rng_key_init, sample_batch['y'])\n test_loss_list = []\n\n for i in range(self.num_epochs):\n rng_key, rng_key_train, rng_key_test = random.split(rng_key, 3)\n t_start = time.time()\n\n _, svi_state = self.epoch_train(rng_key_train, svi_state)\n test_loss = self.eval_test(rng_key_test, svi_state)\n test_loss_list += [test_loss]\n\n print(\n \"Epoch {}: loss = {} ({:.2f} s.)\".format(\n i, test_loss, time.time() - t_start\n )\n )\n \n if np.isnan(test_loss): break\n\n if plot_loss:\n plt.figure()\n plt.plot(np.arange(0, self.num_epochs, 1)[0:len(test_loss_list)], test_loss_list)\n plt.xlabel(\"epochs\")\n plt.ylabel(\"test error\")\n plt.savefig('src/test/plots/vae_lost.png')\n plt.show()\n plt.close()\n\n # return optimal parameters for decoder\n return self.svi.get_params(svi_state)[\"decoder$params\"]","def compute_rmse(y, tx, w):\n return np.sqrt(2 * compute_mse(y, tx, w))","def evaluate(self, X_test, y_test):\n y_pred_train = self.pipeline.predict(self.X)\n mse_train = mean_squared_error(self.y, y_pred_train)\n rmse_train = np.sqrt(mse_train)\n \n self.mlflow_log_metric('rmse_train', rmse_train)\n \n y_pred_test = self.pipeline.predict(X_test)\n mse_test = mean_squared_error(y_test, y_pred_test)\n rmse_test = np.sqrt(mse_test)\n self.mlflow_log_metric('rmse_test', rmse_test)\n \n return (round(rmse_train, 3) ,round(rmse_test, 3))","def plot_SS(H,E,C,nframes,nres,outdir,name_mod):\n\tH_av = np.zeros(nres) ; H_err = np.zeros(nres) \n\tE_av = np.zeros(nres) ; E_err = np.zeros(nres) \n\tC_av = np.zeros(nres) ; C_err = np.zeros(nres) \n\tfor ind in range(nres):\n\t\tH_av[ind] = sum(H[ind,:])/nframes ; H_err[ind] = np.std(H[ind,:])\n\t\tE_av[ind] = sum(E[ind,:])/nframes ; E_err[ind] = np.std(E[ind,:])\n\t\tC_av[ind] = sum(C[ind,:])/nframes ; C_err[ind] = np.std(C[ind,:])\n\n\tplt.clf()\n\tplt.plot(H_av,label='Helix',c='r') ; plt.errorbar(range(nres), H_av,yerr=H_err/(np.sqrt(nframes)-1), fmt='o',color='r')\n\tplt.plot(E_av,label='Beta Sheet',c='b') ; plt.errorbar(range(nres), E_av,yerr=E_err/(np.sqrt(nframes)-1), fmt='o',color='b')\n\tplt.plot(C_av,label='Coil',c='k') ; plt.errorbar(range(nres), C_av,yerr=C_err/(np.sqrt(nframes)-1), fmt='o',color='k')\n\tplt.legend(loc=1)\n\tplt.savefig(outdir+\"SS\" + name_mod + \".png\")\n\tnp.savetxt(outdir+\"SS_H_av\" + name_mod + \".npy\",[H_av,H_err])\n\tnp.savetxt(outdir+\"SS_E_av\" + name_mod + \".npy\",[E_av,E_err])\n\tnp.savetxt(outdir+\"SS_C_av\" + name_mod + \".npy\",[C_av,C_err])\n\treturn None","def plot_scan_error(dataframe, **kwargs):\n\n # Determine number of cases\n nr = len(set(dataframe[dataframe._column_names['case']].values))\n\n # Reshape in (N,Sa*Sb) matrix\n if kwargs.get('absolute', True):\n data = abs(dataframe['error']).values.reshape(dataframe.Sa * dataframe.Sb, nr)\n else:\n data = dataframe['error'].values.reshape(dataframe.Sa * dataframe.Sb, nr)\n\n # Set upper and lower tolerance limit if not set\n ltol = kwargs.get('ltol', numpy.min(data))\n utol = kwargs.get('utol', numpy.max(data))\n\n # Calculate Root Mean Squared Error\n scanmatrix = numpy.zeros((dataframe.Sa, dataframe.Sb))\n for i in range(0, nr):\n scanmatrix = scanmatrix + numpy.power(data[:, i].reshape(dataframe.Sa, dataframe.Sb), 2)\n scanmatrix = numpy.sqrt(scanmatrix / nr)\n scanmatrix[scanmatrix <= ltol] = ltol\n scanmatrix[scanmatrix >= utol] = utol\n\n # Define plotting variables\n plotvars = {\n 'title': r'LIE $\\alpha$ and $\\beta$ parameter scan for {0} cases'.format(nr),\n 'subtitle': 'Lower tolerance: {0:.2f}, upper tolerance: {1:.2f}'.format(ltol, utol),\n 'cblabel': 'RMS error (kJ/mol)',\n 'ylabel': r'$\\alpha$',\n 'xlabel': r'$\\beta$'\n }\n plotvars.update(kwargs)\n\n logger.info(\"Create dG RMSe matrix plot for Alpha/Beta parameter scan results\")\n logger.info(\n \"Create matrix plot using lower tolerance (ltol) of {0:.3f} and upper rolerance (utol) of {1:.3f}\".format(ltol,\n utol))\n\n # Prepare the plot\n return plot_matrix(scanmatrix,\n xaxis=dataframe.beta_scan_range,\n yaxis=dataframe.alpha_scan_range,\n **plotvars)","def plot_loss(training_errors, validation_errors):\n plt.xscale('Log')\n plt.xlabel('Epochs')\n plt.ylabel('Mean Actual Error')\n plt.plot(training_errors, label = \"Training Error\", \\\n color = 'blue')\n plt.plot(validation_errors, label = \"Validation Error\", \\\n color = 'red')\n plt.legend()\n # Saves plot automatically, adjust filename as needed.\n plt.savefig('reservoir_05whdens_100h_7spec_test_3.png')\n plt.show()","def calculate_rmse(p, q, limits, dx=0.01):\n if p.shape != q.shape:\n raise ValueError('Cannot calculate RMSE between two ensembles with different shapes')\n\n # Make a grid from the limits and resolution\n grid = _calculate_grid_parameters(limits, dx)\n\n # Evaluate the functions on the grid\n pe = p.gridded(grid.grid_values)[1]\n qe = q.gridded(grid.grid_values)[1]\n\n # Calculate the RMS between p and q\n rms = array_metrics.quick_rmse(pe, qe, grid.cardinality)# np.sqrt(dx * np.sum((pe - qe) ** 2))\n\n return rms","def plot_results(results_path, history, mode=\"loss\"):\n\tif mode == \"loss\":\n\t\tplt.figure(figsize=(10, 10))\n\t\tplt.plot(history[mode][1:])\n\t\tplt.plot(history[\"val_\" + mode][1:])\n\t\tplt.title(\"Model MSE \" + mode)\n\t\tplt.xlabel(\"# Epochs\")\n\t\tplt.ylabel(mode + \" score\")\n\t\tplt.legend([\"train\", \"Validation\"], loc=\"upper right\", fontsize=14)\n\t\tplt.savefig(results_path)\n\t\tplt.show()\n\telif mode == \"metric\":\n\t\tmetric_name = \"rmse\"\n\t\tplt.figure(figsize=(10, 10))\n\t\tplt.plot(history[metric_name][1:])\n\t\tplt.plot(history[\"val_\" + metric_name][1:])\n\t\tplt.title(\"Model \" + metric_name + \" metric\")\n\t\tplt.xlabel(\"# Epochs\")\n\t\tplt.ylabel(metric_name + \" score\")\n\t\tplt.legend([\"train\", \"Validation\"], loc=\"upper right\", fontsize=14)\n\t\tplt.savefig(results_path)\n\t\tplt.show()\n\telse:\n\t\tprint(\"A valid mode must be selected! Valid modes: 'loss' or 'metric'\")","def get_convergence_plot(self):\n fig, ax = plt.subplots()\n first_episode = self.get_convergence_episode()\n\n values = self.stats['return_stats']['episode_totals']\n ax.plot(np.arange(len(values)), values, color='steelblue', lw=2, alpha=.9,\n label='Return')\n ax.axvline(first_episode, color='seagreen', lw=2, label='Converged')\n ax.set_xlim(left=0, right=first_episode * 2)\n\n ax.set_title('Normalized regret = {:.3f}'.format(\n self.get_normalized_regret()))\n ax.legend()\n ax.set_ylabel('Return')\n ax.set_xlabel('Episode')\n return fig","def EPI():\n TE = np.array([4.22, 33.81, 63.39, 92.98, 122.6, 152.2, 181.7, 211.3, 240.9, 270.5])\n upper_left = np.array([697.3, 367.0, 217.5, 115.8, 51.8, 23.2, 14.8, 8.7, 6.1, 4.6])\n center = np.array([1110.2, 907.8, 813.6, 745.2, 692.8, 637.0, 564.9, 521.0, 450.2, 401.6])\n lower_right = np.array([723.0, 419.2, 224.1, 126.4, 61.8, 32.4, 15.1, 8.8, 3.9, 3.8])\n upper_center = np.array([782.2, 499.4, 279.5, 154.5, 88.6, 58.2, 43.8, 38.2, 38.2, 36.0])\n\n area = [upper_left, center, upper_center, lower_right]\n colors = [\"#1f77b4\", \"#ff7f0e\", \"#2ca02c\", \"#d62728\"]\n name = [\"Upper left area\", \"Center area\", \"Up center area\", \"Lower right area\"]\n x_new = np.linspace(4.22, 270.5, 10000)\n for i, j, k in zip(area, colors, name):\n popt, _ = curve_fit(M_xy, TE, i, p0=np.array([200, 300]))\n M0, T2 = popt[0], popt[1]\n y_new = M_xy(x_new, M0, T2)\n plt.scatter(TE, i)\n plt.plot(x_new, y_new, \"--\", c=j, label=\"Fit: %s\" % k + f\", $T_2$={T2:.2f}\")\n plt.legend(loc=\"best\")\n plt.grid()\n plt.ylabel(\"Mean Signal Intensity\")\n plt.xlabel(\"TE [ms]\")\n plt.show()","def mplot(m, xlabel='', ylabel='', title='', custom=(7,7)):\n lag = ps.lag_spatial(m.w, m.z)\n fit = ps.spreg.OLS(m.z[:, None], lag[:,None])\n\n # Customize plot\n fig = plt.figure(figsize=custom)\n ax = fig.add_subplot(111)\n\n ax.set_xlabel(xlabel)\n ax.set_ylabel(ylabel)\n fig.suptitle(title)\n\n ax.scatter(m.z, lag, s=60, color='k', alpha=.6)\n ax.plot(lag, fit.predy, color='r')\n\n ax.axvline(0, alpha=0.5)\n ax.axhline(0, alpha=0.5)\n\n return fig","def plot_beam_exp_rms(beam_exp_rms, beam_nums, sbid, fig_folder, closepack=False):\n\n title = 'Expected RMS for SBID {}'.format(sbid)\n plot_name = 'Exp_RMS.png'\n saved_fig = fig_folder+'/'+plot_name\n\n params = {'axes.labelsize': 10,\n 'axes.titlesize': 10,\n 'font.size':10}\n\n mpl.rcParams.update(params)\n\n num_interleaves = len(beam_exp_rms) // 36\n fig = plt.figure(figsize=(18, 12))\n axes = []\n if len(beam_exp_rms) > 36:\n for i in range(1,num_interleaves+1):\n ax = fig.add_subplot(2,2,i)\n axes.append(ax)\n else:\n ax = fig.add_subplot()\n axes.append(ax)\n\n beam_xpos, beam_ypos = beam_positions(closepack=closepack)\n vmin = round(np.min(beam_exp_rms), 3)\n vmax = round(np.minimum(vmin*2,np.max(beam_exp_rms)), 3)\n norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)\n\n for i in range(num_interleaves):\n print (\"Interleave\", i)\n ax = axes[i]\n for j in range(36):\n bnum = beam_nums[j]\n b_idx = i*36+bnum\n ax.scatter([beam_xpos[j]], [beam_ypos[j]], s=1500, c=[beam_exp_rms[b_idx]], cmap='GnBu', edgecolors='black', vmin=vmin, vmax=vmax)\n ax.text(beam_xpos[j], beam_ypos[j], bnum)\n\n ax.set_xlim(0,0.7)\n ax.set_ylim(0.1,1.3)\n ax.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\n ax.set_title(\"Expected RMS for Interleave \" + chr(ord('A')+i))\n\n cb = plt.colorbar(mpl.cm.ScalarMappable(cmap='GnBu', norm=norm), ax=ax)\n cb.set_label('mJy / beam')\n cb.ax.tick_params(labelsize=10)\n\n plt.suptitle(title)\n plt.savefig(saved_fig, bbox_inches='tight')\n plt.close()\n print (saved_fig, plot_name)\n\n return saved_fig","def plot():\n xvals = np.arange(-50, 250, step=0.1)\n\n fig = plt.figure()\n plt.suptitle(\"Gaussian with smooth transition to power law\")\n\n A0vals = [10, 11]\n avals = [5*10**-3, 10**-3, 5*10**-4]\n ttvals = [10., 50., 100.]\n cvals = [-0.1, -0.9, -5./3., -4.]\n offset = [-30, 0.0, 30]\n\n paramvals = [A0vals, avals, ttvals,cvals, offset]\n titles, labels = return_parameter_names()\n\n nplots = len(paramvals)\n\n for i in range(nplots):\n plt.subplot(nplots, 1, i+1)\n vals = paramvals[i]\n for j in range(len(vals)):\n pset = list(default())\n pset[i] = vals[j]\n yvals=[]\n ypower=[]\n ypeak=[]\n for x in xvals:\n yvals.append(fitfunc(x, pset))\n ypeak.append(logpeak(x,pset))\n if x > 0:\n ypower.append(logpowerlaw(x,pset))\n label = labels[i] + \"=\"+str(vals[j])\n plt.plot(xvals, yvals, label = label)\n\n plt.title(titles[i])\n plt.legend()\n\n fig.set_size_inches(15, 30)\n plt.savefig(\"graphs/misc/lightcurve_models.pdf\")\n plt.close()","def calc_rmse(pred_target, val, time_slot_length):\n pred_data = pred_target.data.loc[:, 1] # Need to add the data column in the CSVFileManager itself, rather than\n # hardcore values\n pred_length = pred_data.size(0)\n rmse_list = []\n deviation_list = []\n for j in range(0, pred_length-time_slot_length):\n se = 0\n start_time_slot = j\n end_time_slot = start_time_slot + time_slot_length\n timed_pred_data = pred_data.iloc[start_time_slot:end_time_slot, 1]\n for i in range(0, time_slot_length):\n se += math.pow((timed_pred_data[i]-val), 2)\n rmse = math.sqrt((se/time_slot_length))\n rmse_list.append(rmse)\n\n # Calculate the optimal rmse value, and the deviation of other rmse values from the optimal value\n min_rmse = min(rmse_list)\n for j in range(0, pred_length - time_slot_length):\n deviation_list.append((abs(min_rmse - rmse_list[j])/min_rmse)*100)\n return deviation_list, rmse_list","def energies():\n # Hardcoded initial values\n numsteps = 10000\n time_max = 1\n # Running the calculation in the solver class using the velocity verlet method\n # for better accuracy.\n verlet = solver(input_matrix, 'verlet', time_max, numsteps)\n output_matrix, KE, PE, AM = verlet.main()\n # Creating a simple time axis for plotting\n x = np.linspace(0, 1, numsteps+1)\n\n # Plotting kinetic energy over time\n plt.figure(1, figsize=(10, 10))\n plt.plot(x, KE)\n plt.suptitle('Total kinetic energy in the Earth-Sun system.', fontsize=24)\n plt.xlabel('time [yr]', fontsize=16)\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\n plt.legend(['KE'])\n\n # Plotting potential energy over time\n plt.figure(2, figsize=(10, 10))\n plt.plot(x, PE)\n plt.suptitle('Total potential energy in the Earth-Sun system.', fontsize=24)\n plt.xlabel('time [yr]', fontsize=16)\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\n plt.legend(['PE'])\n\n # Plotting total energy against time\n plt.figure(3, figsize=(10, 10))\n plt.plot(x, PE+KE)\n plt.suptitle('Total energy in the Earth-Sun system.', fontsize=24)\n plt.xlabel('time [yr]', fontsize=16)\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\n plt.legend(['KE+PE'])\n\n # Plotting angular momentum against time. print the amplitude to terminal\n amplitude = max(AM)-min(AM)\n print('Amplitude of angular momentum during 1 year: %g[AU²/yr²]' %(amplitude))\n plt.figure(4, figsize=(10, 10))\n plt.plot(x, AM)\n plt.suptitle('Total angular momentum in the Earth-Sun system.', fontsize=24)\n plt.xlabel('time [yr]', fontsize=16)\n plt.ylabel('energy [AU²/yr²]', fontsize=16)\n plt.legend(['AM'])\n\n # Plotting the kinetic, potential and total energy against time to see\n # how great the variations are\n plt.figure(5, figsize=(10, 10))\n plt.plot(x, PE, x, KE, x, KE+PE)\n plt.suptitle('Total energy in the Earth-Sun system.', fontsize=24)\n plt.xlabel('time [yr]', fontsize=16)\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\n plt.legend(['PE', 'KE', 'KE+PE'])\n plt.show()","def plot_LvsL(modeldata,line1='CIV1548',line2='CIII1908',plotname='./TESTPLOT.pdf',\n Zgas=False,logU=False,xid=0.3,nh=100,COratio=0.38,Mcutoff=100,\n logx=False,logy=False,logp1=False,logp2=False,fixxrange=False,fixyrange=False,\n showobs=None,noobserr=False,verbose=True):\n NFalse = 0\n freeparam = []\n inforstr = \"\"\n # - - - - - - - - - - - - - - - - - - - - - - - -\n legenddic = {}\n legenddic['Zgas'] = r'Z$_\\textrm{gas}$'\n legenddic['logUs'] = r'log$_\\textrm{10}$(U)'\n legenddic['xid'] = r'$\\xi_\\textrm{d}$'\n legenddic['nh'] = r'n$_\\textrm{H}$ / [cm$^3$]'\n legenddic['COCOsol'] = r'C/O / [C/O]$_\\textrm{sun}$'\n legenddic['mup'] = r'M$_\\textrm{cut IMF}$ / [M$_\\textrm{sun}]$'\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not Zgas:\n Zgasrange = [0.0,1.0]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' Zgas:vary, '\n freeparam.append('Zgas')\n else:\n Zgasrange = [Zgas-1e-6,Zgas+1e-6]\n inforstr = inforstr+' '+legenddic['Zgas']+'='+str(Zgas)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not logU:\n logUrange = [-5.0,0.0]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' logU:vary, '\n freeparam.append('logUs')\n else:\n logUrange = [logU-0.1,logU+0.1]\n inforstr = inforstr+' '+legenddic['logUs']+'='+str(logU)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not xid:\n xidrange = [0.0,0.6]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' xid:vary, '\n freeparam.append('xid')\n else:\n xidrange = [xid-0.01,xid+0.01]\n inforstr = inforstr+' '+legenddic['xid']+'='+str(xid)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not nh:\n nhrange = [0.0,1.0e6]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' nH:vary, '\n freeparam.append('nh')\n else:\n nhrange = [nh-1.0,nh+1.0]\n inforstr = inforstr+' '+legenddic['nh']+'='+str(nh)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not COratio:\n COratiorange = [0.0,2.0]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' C/O:vary, '\n freeparam.append('COCOsol')\n else:\n COratiorange = [COratio-0.001,COratio+0.001]\n inforstr = inforstr+' '+legenddic['COCOsol']+'='+str(COratio)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not Mcutoff:\n Mcutoffrange = [0.0,400.0]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' Mcutoff:vary, '\n freeparam.append('mup')\n else:\n Mcutoffrange = [Mcutoff-1.0,Mcutoff+1.0]\n inforstr = inforstr+' '+legenddic['mup']+'='+str(Mcutoff)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n\n if NFalse != 2:\n sys.exit(' Two and only two of the model parameters (Zgas,logU,xid,nh,COratio,Mcutoff) '\n 'should be set to Flase to define the model grid; however it appears '+str(NFalse)+\n ' parameters where not set')\n\n goodent = np.where( (modeldata['Zgas'] > Zgasrange[0]) & (modeldata['Zgas'] < Zgasrange[1]) &\n (modeldata['logUs'] > logUrange[0]) & (modeldata['logUs'] < logUrange[1]) &\n (modeldata['xid'] > xidrange[0]) & (modeldata['xid'] < xidrange[1]) &\n (modeldata['nh'] > nhrange[0]) & (modeldata['nh'] < nhrange[1]) &\n (modeldata['COCOsol'] > COratiorange[0]) & (modeldata['COCOsol'] < COratiorange[1]) &\n (modeldata['mup'] > Mcutoffrange[0]) & (modeldata['mup'] < Mcutoffrange[1]) )\n\n Ngoodent = len(goodent[0])\n\n if Ngoodent > 1:\n if verbose: print(' - Getting data for '+str(Ngoodent)+' data points satisfying model selection ')\n param1 = modeldata[freeparam[0]][goodent]\n if logp1:\n param1 = np.log10(param1)\n\n param2 = modeldata[freeparam[1]][goodent]\n if logp2:\n param2 = np.log10(param2)\n\n lum1 = modeldata[line1][goodent]\n lum2 = modeldata[line2][goodent]\n else:\n if verbose: print(' WARNING: Less than 2 model grid points to plot; no output generated')\n return\n\n # - - - - - - - - - - - PLOTTING - - - - - - - - - - -\n if verbose: print(' - Setting up and generating plot')\n plotname = plotname\n fig = plt.figure(figsize=(9, 5))\n fig.subplots_adjust(wspace=0.1, hspace=0.1,left=0.1, right=0.99, bottom=0.10, top=0.95)\n Fsize = 10\n lthick = 1\n marksize = 3\n plt.rc('text', usetex=True)\n plt.rc('font', family='serif',size=Fsize)\n plt.rc('xtick', labelsize=Fsize)\n plt.rc('ytick', labelsize=Fsize)\n plt.clf()\n plt.ioff()\n plt.title(inforstr[:-2],fontsize=Fsize)\n\n margin = 0.1\n dx = np.abs(np.max(lum1)-np.min(lum1))\n dy = np.abs(np.max(lum2)-np.min(lum2))\n\n\n if fixxrange:\n xrange = fixxrange\n else:\n if logx:\n xrange = [np.min(lum1)-np.min(lum1)/2.,np.max(lum1)+np.max(lum1)/2.]\n else:\n xrange = [np.min(lum1)-dx*margin,np.max(lum1)+dx*margin]\n\n if fixyrange:\n yrange = fixyrange\n else:\n if logy:\n yrange = [np.min(lum2)-np.min(lum2)/2.,np.max(lum2)+np.max(lum2)/2.]\n else:\n yrange = [np.min(lum2)-dy*margin,np.max(lum2)+dy*margin]\n\n # ------------ PARAM1 ------------\n cmap = plt.cm.get_cmap('winter')\n cmin = np.min(param1)\n cmax = np.max(param1)\n colnorm = matplotlib.colors.Normalize(vmin=cmin,vmax=cmax)\n cmaparr = np.linspace(cmin, cmax, 30) #cmax-cmin)\n mm = plt.cm.ScalarMappable(cmap=cmap)\n mm.set_array(cmaparr)\n cb1 = plt.colorbar(mm)#shrink=0.25\n\n pstr1 = legenddic[freeparam[0]]\n if logp1:\n pstr1 = r'log$_\\textrm{10}$('+pstr1+')'\n\n cb1.set_label(pstr1+' (outer circle) - Fixed: black line')\n\n for p1 in np.unique(param1):\n p1col = cmap(colnorm(p1))\n p1ent = np.where(param1 == p1)\n\n plt.plot(lum1[p1ent],lum2[p1ent],'-',lw=lthick, color='k',zorder=1)\n\n plt.errorbar(lum1[p1ent],lum2[p1ent],xerr=None,yerr=None,\n marker='o',lw=0, markersize=marksize*3,\n markerfacecolor=p1col,ecolor=p1col,markeredgecolor = 'k',zorder=10)\n\n # ------------ PARAM2 ------------\n cmap = plt.cm.get_cmap('spring')\n cmin = np.min(param2)\n cmax = np.max(param2)\n colnorm = matplotlib.colors.Normalize(vmin=cmin,vmax=cmax)\n cmaparr = np.linspace(cmin, cmax, 30) #cmax-cmin)\n mm = plt.cm.ScalarMappable(cmap=cmap)\n mm.set_array(cmaparr)\n cb2 = plt.colorbar(mm)#shrink=0.25\n\n pstr2 = legenddic[freeparam[1]]\n if logp2:\n pstr2 = 'log10('+pstr2+')'\n\n cb2.set_label(pstr2+' (inner circle) - Fixed: gray line')\n\n for p2 in np.unique(param2):\n p2col = cmap(colnorm(p2))\n p2ent = np.where(param2 == p2)\n\n plt.plot(lum1[p2ent],lum2[p2ent],'-',lw=lthick, color='gray',zorder=2)\n\n plt.errorbar(lum1[p2ent],lum2[p2ent],xerr=None,yerr=None,\n marker='o',lw=0, markersize=marksize*1.5,\n markerfacecolor=p2col,ecolor=p2col,markeredgecolor = 'k',zorder=20)\n\n if showobs != None:\n for ii, objid in enumerate(showobs[:,0]):\n if (showobs[:,7][ii] > xrange[0]) & (showobs[:,7][ii] < xrange[1]) & \\\n (showobs[:,9][ii] > yrange[0]) & (showobs[:,9][ii] < yrange[1]):\n\n if noobserr:\n obsxerr = None\n obsyerr = None\n else:\n obsxerr = showobs[:,8][ii]\n obsyerr = showobs[:,10][ii]\n plt.errorbar(showobs[:,7][ii],showobs[:,9][ii],xerr=obsxerr,yerr=obsyerr,\n marker='*',lw=lthick, markersize=marksize*2,\n markerfacecolor='k',ecolor='k',markeredgecolor = 'k',zorder=30)\n\n plt.xlabel(r'L$_\\textrm{'+line1+r'}$ / [3.826$\\times$1e33 erg/s]/[Msun/yr]')\n plt.ylabel(r'L$_\\textrm{'+line2+r'}$ / [3.826$\\times$1e33 erg/s]/[Msun/yr]')\n\n plt.xlim(xrange)\n plt.ylim(yrange)\n\n if logx:\n plt.xscale('log')\n if logy:\n plt.yscale('log')\n\n #--------- LEGEND ---------\n # plt.errorbar(-1,-1,xerr=None,yerr=None,fmt='o',lw=lthick,ecolor='white', markersize=marksize*2,\n # markerfacecolor='white',markeredgecolor = 'k',label='Ground-based spec')\n #\n # leg = plt.legend(fancybox=True, loc='upper center',prop={'size':Fsize},ncol=1,numpoints=1)\n # #bbox_to_anchor=(1.25, 1.03)) # add the legend\n # leg.get_frame().set_alpha(0.7)\n #--------------------------\n\n if verbose: print(' Saving plot to'+plotname)\n plt.savefig(plotname)\n plt.clf()\n plt.close('all')","def get_stability_plot(self):\n fig, ax = plt.subplots()\n first_episode = self.get_convergence_episode()\n\n values = self.stats['return_stats']['episode_totals']\n _, _, (y_lower, _) = self._moving_average(\n values, window=_ROLLING_WINDOW, p=_CONFIDENCE_LEVEL)\n episodes = np.arange(len(values))\n unstable_episodes = np.where(\n np.logical_and(values < y_lower[-1], episodes > first_episode))[0]\n\n ax.plot(episodes, values, color='steelblue', lw=2, alpha=.9,\n label='Return')\n for i, episode in enumerate(unstable_episodes):\n ax.axvline(episode, color='salmon', lw=2,\n label='Unstable' if i == 0 else None)\n ax.axvline(first_episode, color='seagreen', lw=2, label='Converged')\n\n ax.set_title('Normalized instability = {:.3f}%'.format(\n self.get_normalized_instability() * 100.))\n ax.legend()\n ax.set_ylabel('Return')\n ax.set_xlabel('Episode')\n return fig","def scree_plot(self, ev):\n plt.scatter(range(1,len(ev)+1), ev)\n plt.plot(range(1,len(ev)+1), ev)\n plt.title(\"Scree Plot\")\n plt.xlabel(\"Factors\")\n plt.ylabel(\"Eigenvalue\")\n plt.grid()\n plt.show()","def evaluate(self, X_test, y_test):\n \n y_pred = self.pipeline.predict(X_test)\n test_rmse = compute_rmse(y_pred, y_test)\n print(\"test rmse:\", test_rmse)\n return test_rmse"],"string":"[\n \"def _plot_rmse(self, val=False):\\n _, ax = plt.subplots()\\n ax.plot(self.global_rmse, linewidth=3, color='blue', label='Train RMSE')\\n ax.set_title('RMSE vs. Number of Iterations')\\n if val is not None:\\n ax.plot(self.validation_rmse, linewidth=3, color='green', label='Validation RMSE')\\n ax.legend()\\n plt.show()\",\n \"def plot(self) -> None:\\n cw_l2_data_list = list(); cw_linf_data_list = list()\\n\\n for model in self.model_list:\\n cw_l2_data_list.append(joblib.load(model + \\\"/stat/mse-rmse-si-mae-cw_l2_1.pkl\\\"))\\n\\n cw_l2_attack = list(zip(self.model_list, cw_l2_data_list))\\n\\n for model in self.model_list:\\n cw_linf_data_list.append(joblib.load(model + \\\"/stat/mse-rmse-si-mae-cw_inf_1.pkl\\\"))\\n\\n cw_linf_attack = list(zip(self.model_list, cw_linf_data_list))\\n\\n # RMSE v.s. MAE over change budget\\n # There will be one graph for each manipulation\\n # CW_L2 ATTACK\\n for datum in cw_l2_attack:\\n ran_color_list = self._random_color_picker(2)\\n fig, axis_1 = plt.subplots()\\n\\n # Generate x_axis\\n x_axis = list()\\n for key in datum[1]:\\n if float(key) not in x_axis:\\n x_axis.append(float(key))\\n\\n x_axis.sort()\\n\\n # Sort data in datum[1]\\n data_dict = self._sort_dict(x_axis, datum[1])\\n\\n # PLOT RMSE ON AXIS 1\\n # Generate y_axis ticks for RMSE\\n rmse_values = list()\\n for key in data_dict:\\n rmse_values.append(data_dict[key][\\\"rmse\\\"])\\n\\n # Generate 10 ticks for the y_axis\\n y_axis_ticks = np.linspace(0.0, 0.6, num=10, endpoint=True)\\n\\n # Plot RMSE\\n axis_1.plot(x_axis, rmse_values, color=ran_color_list[0], linestyle=\\\"solid\\\")\\n axis_1.set_xlabel(\\\"Perturbation Budget\\\")\\n axis_1.set_ylabel(\\\"Root Mean Squared Error (RMSE)\\\", color=ran_color_list[0])\\n axis_1.set_yticks(y_axis_ticks)\\n \\n for tick_label, tick_line in zip(axis_1.get_yticklabels(), axis_1.get_yticklines()):\\n tick_label.set_color(ran_color_list[0])\\n tick_line.set_color(ran_color_list[0])\\n\\n # PLOT MAE ON AXIS 2\\n axis_2 = axis_1.twinx()\\n\\n # Generate y-axis ticks for MAE\\n mae_values = list()\\n for key in data_dict:\\n mae_values.append(data_dict[key][\\\"mae\\\"])\\n\\n\\n # Plot MAE\\n axis_2.plot(x_axis, mae_values, color=ran_color_list[1], linestyle=\\\"solid\\\")\\n axis_2.set_ylabel(\\\"Mean Absolute Error (MAE)\\\", color=ran_color_list[1])\\n axis_2.set_yticks(y_axis_ticks)\\n \\n for tick_label, tick_line in zip(axis_2.get_yticklabels(), axis_2.get_yticklines()):\\n tick_label.set_color(ran_color_list[1])\\n tick_line.set_color(ran_color_list[1])\\n\\n model_tag = datum[0].split(\\\"/\\\"); model_tag = model_tag[-1]\\n plt.savefig(self.save_path + \\\"/{}_rmse-and-mae-as-perturbation-budget-increases-for-cw_l2-attack-on-model-{}.png\\\".format(self.plot_name, model_tag), \\n bbox_inches=\\\"tight\\\")\\n plt.close()\\n\\n # CW_Linf ATTACK\\n for datum in cw_linf_attack:\\n ran_color_list = self._random_color_picker(2)\\n fig, axis_1 = plt.subplots()\\n\\n # Generate x_axis\\n x_axis = list()\\n for key in datum[1]:\\n if float(key) not in x_axis:\\n x_axis.append(float(key))\\n\\n x_axis.sort()\\n\\n # Sort data in datum[1]\\n data_dict = self._sort_dict(x_axis, datum[1])\\n\\n # PLOT RMSE ON AXIS 1\\n # Generate y_axis ticks for RMSE\\n rmse_values = list()\\n for key in data_dict:\\n rmse_values.append(data_dict[key][\\\"rmse\\\"])\\n\\n # Plot RMSE\\n axis_1.plot(x_axis, rmse_values, color=ran_color_list[0], linestyle=\\\"solid\\\")\\n axis_1.set_xlabel(\\\"Perturbation Budget\\\")\\n axis_1.set_ylabel(\\\"Root Mean Squared Error (RMSE)\\\", color=ran_color_list[0])\\n axis_1.set_yticks(y_axis_ticks)\\n\\n for tick_label, tick_line in zip(axis_1.get_yticklabels(), axis_1.get_yticklines()):\\n tick_label.set_color(ran_color_list[0])\\n tick_line.set_color(ran_color_list[0])\\n\\n # PLOT MAE ON AXIS 2\\n axis_2 = axis_1.twinx()\\n\\n # Generate y-axis ticks for MAE\\n mae_values = list()\\n for key in data_dict:\\n mae_values.append(data_dict[key][\\\"mae\\\"])\\n\\n # Plot MAE\\n axis_2.plot(x_axis, mae_values, color=ran_color_list[1], linestyle=\\\"solid\\\")\\n axis_2.set_ylabel(\\\"Mean Absolute Error (MAE)\\\", color=ran_color_list[1])\\n axis_2.set_yticks(y_axis_ticks)\\n \\n for tick_label, tick_line in zip(axis_2.get_yticklabels(), axis_2.get_yticklines()):\\n tick_label.set_color(ran_color_list[1])\\n tick_line.set_color(ran_color_list[1])\\n \\n model_tag = datum[0].split(\\\"/\\\"); model_tag = model_tag[-1]\\n plt.savefig(self.save_path + \\\"/{}_rmse-and-mae-as-perturbation-budget-increases-for-cw_linf-attack-on-model-{}.png\\\".format(self.plot_name, model_tag),\\n bbox_inches=\\\"tight\\\")\\n plt.close()\\n \\\"RMSE and MAE as Perturbation Budget increases for CW_Linf attack on model {}\\\".format(model_tag)\\n \\n # Scattter Index over the change budget\\n # All the manipulations will be put on the same graph.\\n # CW_L2 ATTACK\\n plt.figure()\\n plt.xlabel(\\\"Perturbation Budget\\\"); plt.ylabel(\\\"Scatter Index\\\")\\n ran_color_list = self._random_color_picker(len(cw_l2_attack)); i = 0\\n\\n # Find maximum scatter index value\\n scatter_values = list()\\n for datum in cw_l2_attack:\\n for key in datum[1]:\\n scatter_values.append(datum[1][key][\\\"scatter_index\\\"])\\n\\n # Generate y_axis ticks; generate 10 ticks\\n y_axis_ticks = np.linspace(0.0, float(Decimal(str(max(scatter_values))) + Decimal(\\\"0.1\\\")), num=10, endpoint=True)\\n plt.yticks(y_axis_ticks)\\n\\n # Generate x_axis\\n x_axis = list()\\n for datum in cw_l2_attack:\\n for key in datum[1]:\\n if float(key) not in x_axis:\\n x_axis.append(float(key))\\n\\n x_axis.sort()\\n\\n formal_names = FormalNameMap()\\n for datum in cw_l2_attack:\\n values = list()\\n data_dict = self._sort_dict(x_axis, datum[1])\\n for key in data_dict:\\n values.append(data_dict[key][\\\"scatter_index\\\"])\\n\\n # Append values to the plot\\n line_name = datum[0].split(\\\"/\\\"); line_name = line_name[-1]\\n formal_name = formal_names.getformalname(line_name) if formal_names.hasname(line_name) else line_name\\n if \\\"vanilla\\\" in line_name:\\n plt.plot(x_axis, values, color=ran_color_list[i], linewidth=3, linestyle=self._random_linestyle(), label=formal_name)\\n\\n else:\\n plt.plot(x_axis, values, color=ran_color_list[i], linestyle=self._random_linestyle(), label=formal_name)\\n \\n i += 1\\n\\n plt.legend()\\n plt.savefig(self.save_path + \\\"/{}_scatter-index-as-perturbation-budget-increases-for-cw_l2-attack.png\\\".format(self.plot_name),\\n bbox_inches=\\\"tight\\\")\\n plt.close()\\n\\n # CW_Linf ATTACK\\n plt.figure()\\n plt.xlabel(\\\"Perturbation Budget\\\"); plt.ylabel(\\\"Scatter Index\\\")\\n ran_color_list = self._random_color_picker(len(cw_linf_attack)); i = 0\\n\\n # Find maximum scatter index value\\n scatter_values = list()\\n for datum in cw_linf_attack:\\n for key in datum[1]:\\n scatter_values.append(datum[1][key][\\\"scatter_index\\\"])\\n\\n # Generate y_axis ticks; generate 10 ticks\\n y_axis_ticks = np.linspace(0.0, float(Decimal(str(max(scatter_values))) + Decimal(\\\"0.1\\\")), num=10, endpoint=True)\\n plt.yticks(y_axis_ticks)\\n\\n # Generate x_axis\\n x_axis = list()\\n for datum in cw_l2_attack:\\n for key in datum[1]:\\n if float(key) not in x_axis:\\n x_axis.append(float(key))\\n\\n x_axis.sort()\\n\\n formal_names = FormalNameMap()\\n for datum in cw_linf_attack:\\n values = list()\\n data_dict = self._sort_dict(x_axis, datum[1])\\n for key in data_dict:\\n values.append(data_dict[key][\\\"scatter_index\\\"])\\n\\n # Append values to the plot\\n line_name = datum[0].split(\\\"/\\\"); line_name = line_name[-1]\\n formal_name = formal_names.getformalname(line_name) if formal_names.hasname(line_name) else line_name\\n if \\\"vanilla\\\" in line_name:\\n plt.plot(x_axis, values, color=ran_color_list[i], linewidth=3, linestyle=self._random_linestyle(), label=formal_name)\\n\\n else: \\n plt.plot(x_axis, values, color=ran_color_list[i], linestyle=self._random_linestyle(), label=formal_name)\\n \\n i += 1\\n\\n plt.legend()\\n plt.savefig(self.save_path + \\\"/{}_scatter-index-as-perturbation-budget-increases-for-cw_linf-attack.png\\\".format(self.plot_name),\\n bbox_inches=\\\"tight\\\")\\n plt.close()\",\n \"def evaluate(y_train,train_preds,y_test,test_preds,model,features):\\n \\n plt.figure(figsize=(3.5,3))\\n train_mae = np.abs(y_train-train_preds).mean()\\n test_mae = np.abs(y_test-test_preds).mean()\\n print(model, split)\\n print('Test MAE: %4.2f'%(test_mae))\\n print('Train MAE: %4.2f'%(train_mae))\\n plt.plot(y_train,train_preds,'.',c='grey',ms=3,label='Train MAE: %4.2f'%train_mae,alpha=1)\\n plt.plot(y_test,test_preds,'.',c=colors[model],ms=3,label='Test MAE: %4.2f'%test_mae,alpha=1)\\n #plt.title('%s: Train MAE = %.2f eV; Test MAE = %.2f eV'%(model,np.abs(y_train-train_preds).mean(),np.abs(y_test-test_preds).mean()),fontsize=10)\\n\\n xlim = plt.gca().get_xlim()\\n ylim = plt.gca().get_ylim()\\n \\n alim = (min(xlim[0],ylim[0]),max(xlim[1],ylim[1]))\\n\\n plt.plot(alim,alim,'-k',lw=1)\\n plt.gca().set_ylim(alim)\\n plt.gca().set_xlim(alim)\\n\\n plt.xlabel('$\\\\Delta E$ (eV)')\\n plt.ylabel('$\\\\Delta E$ Predicted (eV)')\\n\\n plt.legend(loc='best')\\n\\n plt.tight_layout()\\n plt.savefig('./parity/'+model+'_'+features+'_'+split+'_parity.pdf')\\n \\n #Functionality to plot histogram of error if desired\\n\\n #plt.figure()\\n #plt.hist(preds-y,bins=100)\\n #plt.xlabel('$\\\\hat{y} - y$ (eV)')\\n #plt.title('%s %s: MAE = %.2f eV'%(model,tt,np.abs(y-preds).mean()))\\n\\n #xlim = np.array(plt.gca().get_xlim())\\n #xmax = np.abs(xlim).max()\\n #plt.gca().set_xlim([-xmax,xmax])\\n\\n #plt.savefig('./output/'+model+'_'+features+'_'+split+'_'+tt+'_hist.pdf')\\n\\n return\",\n \"def plot(self, axis = None, xlabel=True, save=True, legend=True):\\n if axis is None:\\n fig, axis = plt.subplots(figsize=(10,7))\\n # total kernel evaluations\\n kernel_evaluations = 0.5 * self.Ms*(self.Ms - 1)\\n effective_R = self.minimal_R * kernel_evaluations.reshape(-1,1,1)\\n\\n exponents = np.zeros(len(self.epsilons))\\n\\n for i, eps in enumerate(self.epsilons):\\n means = np.mean(effective_R[:,:self.estimations,i],axis=-1)\\n upper = np.quantile(effective_R[:,:self.estimations,i],upper_percentile,axis=-1)\\n lower = np.quantile(effective_R[:,:self.estimations,i],lower_percentile,axis=-1)\\n errors = np.array([means - lower, upper - means])\\n\\n p = np.polyfit(np.log(self.Ms), np.log(means), 1)\\n exponents[i] = p[0]\\n axis.errorbar(self.Ms, means, yerr=errors, marker='.', ecolor=colors[i], elinewidth=3., ls='',\\n capsize=6,capthick=2., color=colors[i], ms=20, label = r'$\\\\varepsilon_0 = {{%s}}, \\\\quad R \\\\propto M^{{%.2f}}$'%(eps, p[0]))\\n\\n M_fine = np.geomspace(np.min(self.Ms),np.max(self.Ms))\\n\\n axis.plot(M_fine, np.exp(p[1])*M_fine**p[0],'-.',color=colors[i])\\n\\n axis.set_xscale('log')\\n axis.set_yscale('log')\\n axis.grid()\\n if legend:\\n axis.legend()\\n if xlabel:\\n axis.set_xlabel(r'Data size $M$')\\n axis.set_ylabel(r'Total number of shots $R$')\\n axis.set_xticks(self.Ms, self.Ms)\\n axis.set_title(r'$\\\\lambda = {{%s}}$'%(1/self.C))\\n #plt.show()\\n sep = 'separable' if self.margin > 0 else 'overlap'\\n if save:\\n plt.savefig(f'plots/binomial_experiment_{sep}_C_{self.C}.png',dpi=300,bbox_inches='tight')\\n \\n return exponents\",\n \"def rmse (lmse) :\\n return np.sqrt(2*lmse)\",\n \"def plotLoss():\\n # ssr\\n ssr = np.log(gradientDescent(X, y)[1])\\n # number of iterations \\n iterations = np.log(np.arange(1, len(ssr) + 1, 1))\\n # plot reduction of ssr\\n plt.plot(iterations, ssr)\\n # xlabel\\n plt.xlabel(\\\"Iteration\\\")\\n # ylabel\\n plt.ylabel(\\\"SSR\\\")\\n # title\\n plt.title(\\\"Reduction of SSR by number of Iterations\\\")\\n # show plot \\n plt.show()\",\n \"def make_tuning_plot_rmse(df, error_col_name=\\\"rmse\\\",\\n error_title = \\\"Top 10% RMSE\\\",\\n cutoff = 0.10):\\n\\n df = df.copy()\\n\\n # Get the regularizer and reset coeff\\n coeff = [float(i.split(\\\"evidence_new_reg_\\\")[1]) if \\\"evidence\\\" in i else i for i in df['method_name']]\\n df[\\\"method_name\\\"] = coeff\\n df[\\\"Data\\\"] = convert_dataset_names(df[\\\"dataset\\\"])\\n df[\\\"Method\\\"] = df[\\\"method_name\\\"]\\n\\n # Get appropriate datasets\\n trials = 'trial_number'\\n methods = 'Method'\\n\\n # Make area plot\\n uniq_methods = set(df[\\\"Method\\\"].values)\\n method_order = sorted(uniq_methods,\\n key=lambda x : x if isinstance(x, float) else -1)\\n method_df = []\\n datasets = set()\\n for data, sub_df in df.groupby(\\\"Data\\\"):\\n # Add datasets\\n datasets.add(data)\\n rmse_sub = sub_df[error_col_name]\\n methods_sub = sub_df[\\\"Method\\\"]\\n trials_sub= sub_df['trial_number']\\n for method_idx, method in enumerate(method_order):\\n # Now summarize these lines\\n bool_select = (methods_sub == method)\\n\\n rmse_method = rmse_sub[bool_select]\\n trials_temp = trials_sub[bool_select]\\n areas = []\\n # create area!\\n for trial, rmse_trial in zip(trials_sub, rmse_method):\\n num_tested = len(rmse_trial)\\n cutoff_index = int(cutoff * num_tested) - 1\\n rmse_val = rmse_trial[-cutoff_index]\\n to_append = {error_title: rmse_val,\\n \\\"Regularizer Coeff, $\\\\lambda$\\\": method,\\n \\\"method_name\\\": method,\\n \\\"Data\\\": data,\\n \\\"Trial\\\" : trial}\\n method_df.append(to_append)\\n method_df = pd.DataFrame(method_df)\\n\\n # Filter out dropout\\n method_df = method_df[[i != \\\"dropout\\\" for i in\\n method_df['method_name']]].reset_index()\\n\\n # Normalize by dataset\\n for dataset in datasets:\\n # Make a divison vector of ones and change it to a different value only\\n # for the correct dataset of interest to set max rmse to 1\\n division_factor = np.ones(len(method_df))\\n indices = (method_df[\\\"Data\\\"] == dataset)\\n\\n # Normalize with respect to the ensemble so that this is 1\\n max_val = method_df[indices].query(\\\"method_name == 'ensemble'\\\").mean()[error_title]\\n\\n # Take the maximum of the AVERAGE so it's normalized to 1\\n division_factor[indices] = max_val\\n method_df[error_title] = method_df[error_title] / division_factor\\n\\n method_df_evidence = method_df[[isinstance(i, float) for i in\\n method_df['method_name']]].reset_index()\\n method_df_ensemble = method_df[[\\\"ensemble\\\" in str(i) for i in\\n method_df['method_name']]].reset_index()\\n\\n data_colors = {\\n dataset : sns.color_palette()[index]\\n for index, dataset in enumerate(datasets)\\n }\\n\\n min_x = np.min(method_df_evidence[\\\"Regularizer Coeff, $\\\\lambda$\\\"])\\n max_x= np.max(method_df_evidence[\\\"Regularizer Coeff, $\\\\lambda$\\\"])\\n\\n sns.lineplot(x=\\\"Regularizer Coeff, $\\\\lambda$\\\", y=error_title,\\n hue=\\\"Data\\\", alpha=0.8, data=method_df_evidence,\\n palette = data_colors)\\n\\n for data, subdf in method_df_ensemble.groupby(\\\"Data\\\"):\\n\\n color = data_colors[data]\\n area = subdf[error_title].mean()\\n std = subdf[error_title].std()\\n plt.hlines(area, min_x, max_x, linestyle=\\\"--\\\", color=color, alpha=0.8)\\n\\n # Add ensemble baseline\\n ensemble_line = plt.plot([], [], color='black', linestyle=\\\"--\\\",\\n label=\\\"Ensemble\\\")\\n # Now make ensemble plots\\n plt.legend(bbox_to_anchor=(1.1, 1.05))\",\n \"def residual_plots(test_data, mods, station=None, squared=False):\\r\\n import config\\r\\n learning_var = config.learning_var\\r\\n data = test_data.get_miniOD()\\r\\n mods.models[0].mod.load()\\r\\n pred = mods.models[0].mod.predict(test_data)\\r\\n test_data.miniOD = None\\r\\n if squared:\\r\\n data[test_data.get_stations_col(2015)] = (data[test_data.get_stations_col(2015)] - pred) ** 2 # /pred\\r\\n else:\\r\\n data[test_data.get_stations_col(2015)] = data[test_data.get_stations_col(2015)] - pred\\r\\n ind = data[data['Annee'] == 0].index\\r\\n data.drop(ind, inplace=True)\\r\\n print(data.columns.values)\\r\\n i = 0\\r\\n if station is None:\\r\\n ch_an = test_data.get_stations_col(2015)\\r\\n else:\\r\\n ch_an = 'End date ' + str(station)\\r\\n for ch in learning_var:\\r\\n if not (ch[0] == 'h') and not (ch in ['LV', 'MMJ', 'SD', 'poudrerie', 'verglas']):\\r\\n # data.boxplot(ch_an, by=ch)\\r\\n # if ch != 'Heure':\\r\\n plt.figure(i // 9)\\r\\n # plt.title('squared error / expectation')\\r\\n fig = plt.subplot(3, 3, (i % 9) + 1)\\r\\n i += 1\\r\\n # fig = plt.figure().add_subplot(111)\\r\\n fig.set_xlabel(ch)\\r\\n if squared:\\r\\n fig.set_ylabel('error²')\\r\\n else:\\r\\n fig.set_ylabel('error')\\r\\n l = []\\r\\n xaxis = np.unique(data[ch])\\r\\n print(ch, xaxis.shape)\\r\\n if xaxis.shape[0] < 20 or ch == 'Heure':\\r\\n for u in xaxis:\\r\\n l.append(data[ch_an][data[ch] == u])\\r\\n else:\\r\\n m = np.min(data[ch])\\r\\n M = np.max(data[ch])\\r\\n step = (M - m) / 20\\r\\n xaxis = np.arange(m, M, step)\\r\\n for u in xaxis:\\r\\n l.append(data[ch_an][(data[ch] >= u) * (data[ch] < u + step)])\\r\\n xaxis = xaxis.astype(int)\\r\\n # fig = plt.boxplot(ch_an, by=ch)\\r\\n # g = data.groupby(ch).mean()[ch_an]\\r\\n # v = data.groupby(ch).std()[ch_an]\\r\\n plt.boxplot(l, labels=xaxis)\\r\\n if squared:\\r\\n plt.ylim((0, 12))\\r\\n else:\\r\\n plt.ylim((-5, 5))\\r\\n # plt.plot(g, '-r')\\r\\n # plt.plot(g + v, ':r')\\r\\n # plt.plot(g - v, ':r')\\r\\n plt.show()\",\n \"def plot_losses(train, test, mode):\\n\\tplt.figure()\\n\\tplt.plot(range(len(train)), train, 'r', label='Training')\\n\\tplt.plot(range(len(test)), test, 'b', label='Testing')\\n\\tplt.title('MSE Loss (batch type: ' + mode + ')')\\n\\tplt.legend()\\n\\tplt.show()\",\n \"def plot_train_test_errors(train_errors, test_errors, lambda_str , K , path, rng):\\n plt.plot(range(rng), train_errors, marker='o', label='Training Data');\\n plt.plot(range(rng), test_errors, marker='v', label='Test Data');\\n plt.title('ALS-WR Learning Curve, lambda = %s, K = %d'%(lambda_str, K))\\n plt.xlabel('Number of Epochs');\\n plt.ylabel('RMSE');\\n plt.legend()\\n plt.grid()\\n plt.savefig(\\\"../results/test_train_rmse_\\\"+path)\\n plt.show()\",\n \"def measure_rmse(self):\\n try:\\n assert self.residuals_forecast is not None\\n except AssertionError:\\n self._uvts_cls_logger.exception(\\\"AssertionError occurred, Cannot compute RMSE! Check your object mode\\\")\\n\\n self.rmse = np.sqrt(sum(np.square(self.residuals_forecast)) / len(self.residuals_forecast))\\n \\\"\\\"\\\"\\n if self._mode == 'test':\\n self.rmse_test = self.rmse\\n elif self._mode == 'test and validate':\\n self.rmse_val = self.rmse - self.rmse_test\\n elif self._mode == 'validate':\\n self.rmse_val = self.rmse\\n \\\"\\\"\\\"\",\n \"def mso_separation_task():\\n input_range = np.arange(3000) #np.array([range(2000)])\\n timescale=10.0\\n osc1 = np.sin(input_range/timescale)\\n osc2 = np.sin(2.1*input_range/timescale)\\n osc3 = np.sin(3.4*input_range/timescale)\\n train_target = np.column_stack((osc1, osc2, osc3))\\n train_input = osc1*np.cos(osc2+2.345*osc3)\\n train_input = train_input[:, None] #1d->2d\\n\\n machine = ESN(1, 800, leak_rate=0.5)\\n print 'Starting training...'\\n start = time.time()\\n trainer = LinearRegressionReadout(machine)\\n trainer.train(train_input[:2000], train_target[:2000])\\n print 'Training Time: ', time.time() - start, 's'\\n prediction = trainer.predict(train_input[2000:])\\n mse = error_metrics.mse(prediction,train_target[2000:])\\n nrmse = error_metrics.nrmse(prediction,train_target[2000:])\\n print 'MSE: ', mse, 'NRMSE:' , nrmse\\n \\n plt.subplot(3,1,1)\\n plt.plot(train_input[2800:3000])\\n plt.title('Input')\\n plt.subplot(3,1,2)\\n plt.plot(train_target[2800:3000])\\n plt.title('Targets')\\n plt.subplot(3,1,3)\\n plt.plot(prediction[800:1000])\\n plt.title('Predictions')\\n plt.show()\\n \\n return nrmse\",\n \"def display_loss_values(model, figure_size = (18, 5)):\\r\\n\\r\\n # Check that the model is not a Non-Parametric model\\r\\n if 'kaplan' in model.name.lower() :\\r\\n error = \\\"This function cannot only take as input a Non-Parametric model\\\"\\r\\n raise NotImplementedError(error)\\r\\n\\r\\n if 'simulation' in model.name.lower() :\\r\\n error = \\\"This function cannot only take as input a simulation model\\\"\\r\\n raise NotImplementedError(error)\\r\\n\\r\\n # Extracting the loss values\\r\\n loss_values = model.loss_values\\r\\n\\r\\n # Extracting the norm 2 of the gradient, if it exists\\r\\n grad2_values = model.__dict__.get('grad2_values')\\r\\n if grad2_values is None:\\r\\n order = 1\\r\\n else :\\r\\n order = 2\\r\\n \\r\\n # Displaying the loss values bsed on the type of optimization\\r\\n if order == 1:\\r\\n title = \\\"Loss function values\\\"\\r\\n fig, ax = plt.subplots(figsize=figure_size)\\r\\n ax.plot( loss_values, color = 'blue', label = 'Loss values')\\r\\n ax.set_xlabel( 'Number of epochs', fontsize=10)\\r\\n plt.legend(fontsize=10)\\r\\n plt.title(title, fontsize=10)\\r\\n plt.show()\\r\\n\\r\\n elif order == 2:\\r\\n\\r\\n # Initializing Chart \\r\\n fig = plt.figure( figsize=figure_size )\\r\\n fig.suptitle( 'Loss function $l$ and $|| gradient ||_{L_{2}}$', \\r\\n fontsize=12, fontweight='bold')\\r\\n\\r\\n # Plotting loss function\\r\\n ax1 = fig.add_subplot(111)\\r\\n ax1.set_xlabel('epochs' )\\r\\n ax1.set_ylabel('Loss function $l$')\\r\\n pl1 = ax1.plot( range( len(loss_values)) , loss_values, \\r\\n label = 'Loss function $l$', color = 'blue', linestyle = '--')\\r\\n\\r\\n # Plotting ||grad|| values\\r\\n ax2 = ax1.twinx()\\r\\n pl2 = ax2.plot( range( len(grad2_values) ) , grad2_values ,\\r\\n label = '$|| gradient ||_{L_{2}}$', color = 'red')\\r\\n ax2.set_ylabel('$|| gradient ||_{L_{2}}$')\\r\\n\\r\\n # added these three lines\\r\\n pl = pl1 + pl2\\r\\n labs = [l.get_label() for l in pl]\\r\\n ax1.legend(pl, labs, loc=1)\\r\\n\\r\\n # display chart\\r\\n plt.show()\",\n \"def train_test_error(e_train, e_test, model_params):\\n\\n fig = plt.figure(figsize=FIG_SIZE)\\n plt.plot(model_params, e_train, label='Training Set')\\n plt.plot(model_params, e_train, label='Test Set')\\n plt.xlabel('Model Parameter')\\n plt.ylabel('MSE of model')\\n plt.legend()\\n\\n return fig\",\n \"def plotErrors(losses, model_title ='Shallow Network, SGD, Batch Size = 10'):\\n fig, axes = plt.subplots()\\n\\n x = np.arange(len(losses))\\n\\n axes.plot(x, losses)\\n axes.set_ylabel(\\\"Loss (cross entropy)\\\")\\n axes.set_xlabel(\\\"Number of iterations\\\")\\n axes.set_title(model_title) \\n\\n plt.show() \\n\\n return None\",\n \"def rmse(self):\\n lam = self.lam()\\n weights = lam / lam.sum()\\n weighted_var = self.var() * weights\\n rmse = np.sqrt(weighted_var.sum())\\n return rmse\",\n \"def MSE_plots(n_min, n_max, save_fig, k = [5], method = 'OLS', lamb = 1, split = False, train = 0.7, N = 1, method2 = 'OLS'):\\n n = np.linspace(n_min, n_max, n_max - n_min + 1)\\n errors = np.zeros((4, len(k), len(n))) # First index MSE for real FrankeFunction, MSE for the data, R2 for the real FrankeFunction, R2 for the data\\n #Second index is the max order of polynomial, third index is for the n-value\\n if type(k) != type([2]):\\n k = [k]\\n\\n for j in range(N):\\n #print(j)\\n for i in range(len(n)):\\n #print(i)\\n x = np.random.uniform(0, 1, size = int(n[i]))\\n y = np.random.uniform(0, 1, size = int(n[i]))\\n x, y = np.meshgrid(x, y)\\n\\n z = FrankeFunction(x, y) + np.random.normal(0, 1, size = x.shape)\\n z_real = FrankeFunction(x, y)\\n\\n for poly in range(len(k)):\\n a = regression(x, y, z, k = k[poly], split = split, train = train)\\n\\n if method == 'OLS':\\n beta = a.OLS()\\n elif method == 'Ridge':\\n beta = a.Ridge(lam = lamb)\\n elif method == 'Lasso':\\n beta = a.Lasso(alpha = lamb)\\n elif method == 'K-fold':\\n beta = a.k_cross(fold = 25, method2 = method2, lam = lamb)[0]\\n\\n if split == True:\\n X = a.design_matrix(k = k[poly])\\n X_train, X_test, z_real_train, z_real_test = a.train_test(X = X, z = z_real, train = train)\\n z_tilde = a.z_tilde(X = X_test, beta = beta)\\n errors[0, poly, i] += a.MSE(z_tilde, z_real_test)\\n errors[1, poly, i] += a.MSE(z_tilde, a.z_test)\\n errors[2, poly, i] += a.R_squared(z_tilde = z_tilde, z = z_real_test)\\n errors[3, poly, i] += a.R_squared(z_tilde = z_tilde, z = a.z_test)\\n else:\\n z_tilde = a.z_tilde(beta = beta)\\n errors[0, poly, i] += a.MSE(z_tilde, z_real)\\n errors[1, poly, i] += a.MSE(z_tilde, z)\\n errors[2, poly, i] += a.R_squared(z_tilde = z_tilde, z = z_real)\\n errors[3, poly, i] += a.R_squared(z_tilde = z_tilde, z = z)\\n\\n n_mid = int(len(n)/2)\\n title = ['MSE FrankeFunction', 'MSE data', 'R2 FrankeFunction', 'R2 data']\\n y_label = ['MSE', 'MSE', 'R^2', 'R^2']\\n errors /= N\\n save_name = ['franke', 'data', 'franke', 'data']\\n\\n if method == 'Ridge':\\n method += ' with lambda = ' + str(lamb)\\n if method == 'K-fold':\\n method += ' using ' + method2\\n if method2 == 'Ridge' or method2 == 'Lasso':\\n method += ' with lambda = ' + str(lamb)\\n\\n for i in range(4):\\n fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 7))\\n for j in range(len(k)):\\n ax1.plot(n[:n_mid], errors[i, j, :n_mid], label = 'k = ' + str(k[j]))\\n ax2.plot(n[n_mid:], errors[i, j, n_mid:], label = 'k = ' + str(k[j]))\\n\\n ax1.set_ylabel(y_label[i]); ax2.set_ylabel(y_label[i])\\n ax1.set_xlabel('n'); ax2.set_xlabel('n')\\n\\n if split == True:\\n fig.suptitle(title[i] + ' with ' + str(method) + ' with test/training split at ' + str(train) + ' and mean of ' + str(N) + ' runs.')\\n else:\\n fig.suptitle(title[i] + ' with ' + str(method) + ' without test/training split' + ' and mean of ' + str(N) + ' runs.')\\n\\n ax1.legend(); ax2.legend()\\n #fig.savefig(results_dir + save_fig + method + save_name[i] + y_label[i] + '.png')\\n plt.show()\",\n \"def plotPredictedError():\\n\\tglobal normalized\\n\\n\\twarmthPred = []\\n\\twarmthObserved = []\\n\\tcompPred = []\\n\\tcompObserved = []\\n\\tSStotalWarmth = 0\\n\\tSSresWarmth = 0\\n\\tSStotalComp = 0\\n\\tSSresComp = 0\\n\\tkeys = parser.getMappings(normalized)[0].keys()\\n\\tfor key in keys:\\n\\n\\t\\tif \\\"_\\\" in key:\\n\\t\\t\\twarmthAxis, compAxis = getPlotData(key)\\n\\t\\t\\twarmthPred.append(warmthAxis[3])\\n\\t\\t\\twarmthObserved.append(warmthAxis[2])\\n\\t\\t\\tcompPred.append(compAxis[3])\\n\\t\\t\\tcompObserved.append(compAxis[2])\\n\\n\\tmeanObservedWarmth = np.mean(warmthObserved)\\n\\tmeanObservedComp = np.mean(compObserved)\\n\\tfor i in range(0, len(warmthObserved)):\\n\\t\\tSStotalWarmth += (warmthObserved[i] - meanObservedWarmth)**2\\n\\t\\tSSresWarmth += (warmthObserved[i] - warmthPred[i])**2\\n\\t\\tSStotalComp += (compObserved[i] - meanObservedComp)**2\\n\\t\\tSSresComp += (compObserved[i] - compPred[i])**2\\n\\n\\n\\tplt.axis([0, 100, 0, 100])\\n\\tfig = plt.figure(1)\\n\\tax = fig.add_subplot(111)\\n\\tslope, intercept, r_value, p_value, std_err = stats.linregress(warmthObserved, warmthPred)\\n\\tprint(r_value**2)\\n\\ttext = ax.text(60, 20, \\\"R^2 value: \\\" + str(r_value**2) , \\\\\\n fontsize = 12, color = 'black')\\n\\tplt.title(\\\"Observed vs Predicted Warmth\\\")\\n\\tplt.ylabel(\\\"Predicted Value\\\")\\n\\tplt.xlabel(\\\"Observed Value\\\")\\n\\tplt.scatter(warmthObserved, warmthPred)\\n\\tplt.plot([0,100], [0,100])\\n\\tplt.show()\\n\\n\\tfig = plt.figure(1)\\n\\tax = fig.add_subplot(111)\\n\\tslope, intercept, r_value, p_value, std_err = stats.linregress(compObserved, compPred)\\n\\tprint(r_value**2)\\n\\ttext = ax.text(60, 20, \\\"R^2 value: \\\" + str(r_value**2) , \\\\\\n fontsize = 12, color = 'black')\\n\\tplt.axis([0, 100, 0, 100])\\n\\tplt.title(\\\"Observed vs Predicted Competence\\\")\\n\\tplt.ylabel(\\\"Predicted Value\\\")\\n\\tplt.xlabel(\\\"Observed Value\\\")\\n\\tplt.scatter(compObserved, compPred)\\n\\tplt.plot([0,100], [0,100])\\n\\tplt.show()\",\n \"def compute_RMSE(e):\\n \\\"\\\"\\\"Corresponds to sqrt(2*MSE)\\\"\\\"\\\"\\n \\n return np.sqrt(2*compute_MSE(e))\",\n \"def fig_2_11V2(x, y, z, first_poly = 4, complexity = 10, N = 7, method = 'OLS', seed = 42, lam = 0, folds = 5, save_fig = ''):\\n errors = np.zeros((4, complexity + 1))\\n bias = np.zeros(complexity + 1)\\n variance = np.zeros(complexity + 1)\\n z_real = FrankeFunction(x, y)\\n\\n complx = np.arange(first_poly, first_poly + complexity + 1, 1)\\n\\n MSE = np.zeros(complexity + 1)\\n\\n for i in range(complexity + 1):\\n print(i)\\n model = regression(x, y, z, k = first_poly + i, split = False, seed = seed)\\n\\n for j in range(N):\\n _, MSE_R2D2, _, _, _, _ = model.k_cross(fold = folds, method2 = method, lam = lam, random_num = True)\\n errors[:, i] += np.mean(MSE_R2D2, axis = 0)\\n\\n errors /= N\\n\\n print(errors)\\n\\n\\n plt.title(method + ' Test vs Train error in k-fold with ' + str(folds) + '-folds')\\n plt.plot(complx, errors[0], 'go--', label = 'Test', color = 'blue')\\n plt.plot(complx, errors[2], 'go--', label = 'Training', color = 'red')\\n #plt.ylim([np.min(errors_R2[2]*1.2), np.max(errors_R2[0]*1.2)])\\n plt.legend()\\n plt.xlabel('Polynomial maximum order', fontsize = 14)\\n plt.ylabel('MSE', fontsize = 14)\\n plt.savefig(results_dir + 'tradeoff2MSE' + method + save_fig + '.png')\\n\\n plt.show()\\n\\n plt.title(method + ' Test vs Train error in k-fold with ' + str(folds) + '-folds')\\n plt.xlabel('Polynomial maximum order', fontsize = 14)\\n plt.ylabel('R2', fontsize = 14)\\n plt.plot(complx, errors[1], 'go--', label = 'Test', color = 'blue')\\n plt.plot(complx, errors[3], 'go--', label = 'Training', color = 'red')\\n #plt.ylim([np.min(errors_R2[3]*1.2), np.max(errors_R2[1]*1.2)])\\n plt.legend()\\n plt.tight_layout()\\n plt.savefig(results_dir + 'tradeoff2R2' + method + save_fig + '.png')\\n plt.show()\",\n \"def compute_RMSE(true_val, predicted_val, p_output=True) -> float:\\n from sklearn.metrics import mean_squared_error\\n rms = np.sqrt(mean_squared_error(np.array(true_val), predicted_val))\\n if p_output:\\n print('RMSE: {0}'.format(rms))\\n return rms\",\n \"def simple_rmsd(self,calc_data=\\\"xyzcal.px\\\",plot=False):\\n Z = self.refl_table\\n devs = flex.double()\\n sqdevs = flex.double()\\n for oidx in range(len(Z[\\\"spots_order\\\"])): #loop through the shoeboxes in correct order\\n sidx = Z[\\\"spots_order\\\"][oidx] # index into the Miller indices\\n calc = Z[calc_data][sidx][0:2]\\n obs = Z['xyzobs.px.value'][sidx][0:2]\\n sqdev= (calc[0]-obs[0])**2 + (calc[1]-obs[1])**2\\n dev = math.sqrt(sqdev)\\n devs.append(dev)\\n sqdevs.append(sqdev)\\n #print(\\\"%20s %6.2fpx\\\"%(Z[\\\"miller_index\\\"][sidx], dev))\\n rmsd = math.sqrt(flex.mean(sqdevs))\\n print (\\\"The rmsd is %6.2f px\\\"%rmsd)\\n if plot:\\n from matplotlib import pyplot as plt\\n plt.plot(range(len(devs)),devs)\\n running_range = range(15,len(devs),15)\\n plt.plot(running_range, [flex.mean(devs[I-15:I]) for I in running_range], \\\"r-\\\",\\n label=\\\"RMSD=%6.2fpx\\\"%math.sqrt(flex.mean(sqdevs)))\\n plt.title(\\\"Model vs. Experimental Bragg spot position\\\")\\n plt.xlabel(\\\"Spots ordered by increasing Bragg angle →\\\")\\n plt.ylabel(\\\"Deviation in pixels\\\")\\n plt.legend(loc='upper left')\\n plt.show()\\n return rmsd\",\n \"def _plot(self, step, rewards, losses):\\n plt.figure(figsize=(20, 5))\\n plt.subplot(131)\\n plt.title('Total Episode Reward')\\n plt.plot(rewards)\\n plt.subplot(132)\\n plt.title('MSE Loss')\\n plt.plot(losses)\\n plt.show()\",\n \"def actvspred(modelname, predmodel):\\n predscores, actualscores, meanerr, rmsqerr = predmodel\\n plt.figure()\\n plt.scatter(actualscores,predscores,s=70)\\n x = np.array(range(100))\\n plt.plot(x,x,'g',label='optimal model')\\n # make regression\\n rob.globalenv[\\\"pred\\\"] = FV(predscores)\\n rob.globalenv[\\\"act\\\"] = FV(actualscores)\\n mult_lm = stats.lm(\\\"pred ~ act + 1\\\")\\n coeffs = np.array(mult_lm.rx(\\\"coefficients\\\")[0])\\n rsqrd = base.summary(mult_lm).rx(\\\"r.squared\\\")[0][0]\\n y = coeffs[1]*x+coeffs[0]\\n plt.plot(x,y,'k',label='our model',linewidth=2)\\n plt.xlabel(\\\"actual lsas delta\\\")\\n plt.ylabel(\\\"predicted lsas delta\\\")\\n plt.title(modelname)\\n plt.axis([0,100,0,100])\\n axes = plt.axes()\\n axes.grid(b=True)\\n axes.text(0.05,0.8,\\\"meanerr: %.2f\\\\nrmse: %.2f\\\\nr: %.2f (Rsqrd: %.2f)\\\"%(meanerr,rmsqerr,np.sqrt(rsqrd),rsqrd),transform=axes.transAxes)\\n #plt.legend()\\n plt.savefig(os.path.join(outdir,\\\"%s_crossval.png\\\"%modelname),dpi=300,format=\\\"png\\\")\",\n \"def plot_lr(self, show_text=True, show_moms=True):\\n phase_limits = [0]\\n for nb_batch, phase in zip(self.nb_batches, self.phases):\\n phase_limits.append(phase_limits[-1] + nb_batch * phase.epochs)\\n if not in_ipynb():\\n plt.switch_backend('agg')\\n np_plts = 2 if show_moms else 1\\n fig, axs = plt.subplots(1,np_plts,figsize=(6*np_plts,4))\\n if not show_moms: axs = [axs]\\n for i in range(np_plts): axs[i].set_xlabel('iterations')\\n axs[0].set_ylabel('learning rate')\\n axs[0].plot(self.iterations,self.lrs)\\n if show_moms:\\n axs[1].set_ylabel('momentum')\\n axs[1].plot(self.iterations,self.momentums)\\n if show_text: \\n for i, phase in enumerate(self.phases):\\n text = phase.opt_fn.__name__\\n if phase.wds is not None: text+='\\\\nwds='+str(phase.wds)\\n if phase.beta is not None: text+='\\\\nbeta='+str(phase.beta)\\n for k in range(np_plts):\\n if i < len(self.phases)-1:\\n draw_line(axs[k], phase_limits[i+1])\\n draw_text(axs[k], (phase_limits[i]+phase_limits[i+1])/2, text) \\n if not in_ipynb():\\n plt.savefig(os.path.join(self.save_path, 'lr_plot.png'))\",\n \"def run_rmse_check(self):\\n\\n # Shift the intensities to compare\\n obs = self.obs.data - self.obs.data.mean()\\n exp = self.exp.data - self.exp.data.mean()\\n\\n # Experimental RMSE2 in real space\\n rmse_real = (obs - exp)\\n rmse_real = rmse_real**2\\n\\n # Experimental RMSE2 in reciprocal space\\n ftdiff = np.fft.fft2(obs.data,norm='ortho') - np.fft.fft2(exp.data,norm='ortho')\\n rmse_fourier = np.real(np.abs(ftdiff)**2.)\\n\\n # Return\\n rmse_ij = self.obs.deepcopy()\\n rmse_ij.data = rmse_real\\n\\n rmse_kl = ModifiedImage(rmse_fourier)\\n return rmse_ij, rmse_kl\",\n \"def variations_plot(S0, K, B, T, N, u, d, q, M, barrier_type, option, \\n MC_runs, price_tree):\\n x_values = []\\n pi_M = []\\n pi_M_RMSE = []\\n for i in range(1,MC_runs,1):\\n Mi=M*i\\n x_values.append([Mi])\\n paths = sample_paths(S0, N, u, d, q, Mi)\\n p_valid, p_invalid, p_counts = split_paths(paths, B, K, \\n barrier_type, option)\\n if option == 'Call':\\n payoffs = np.maximum(0,p_counts[:,-1]-K)*np.exp(-1*r*T)\\n elif option == 'Put':\\n payoffs = np.maximum(0,K-p_counts[:,-1])*np.exp(-1*r*T)\\n payoffs = list(payoffs)\\n while len(payoffs) < Mi:\\n payoffs.append([0])\\n mean_payoff = np.mean(payoffs)[0]\\n pi_M.append(mean_payoff)\\n RMSE = np.sqrt(np.var(payoffs,ddof=1))/np.sqrt(Mi)\\n pi_M_RMSE.append(RMSE[0])\\n \\n # plotting\\n plt.figure(figsize=(8,6))\\n plt.subplot(2, 1, 1)\\n plt.plot(x_values, price_tree-1.96*np.array(pi_M_RMSE), '--', c='grey')\\n plt.plot(x_values, price_tree+1.96*np.array(pi_M_RMSE), '--', c='grey')\\n plt.plot(x_values, pi_M, 'o', label='price via MC')\\n plt.plot(x_values, [price_tree]*len(x_values), '-', lw=3, \\n label='price via tree')\\n plt.legend()\\n plt.title('Monte Carlo price, for increasing number of paths')\\n plt.ylabel('Expected Value')\\n #The following will plot the root mean square error\\n plt.subplot(2, 1, 2)\\n plt.plot(x_values, pi_M_RMSE, '-')\\n plt.xlabel('number of paths')\\n plt.ylabel('Root Mean Square Error')\\n #plt.savefig('MonteCarlo_variation.png', transparent=True)\\n plt.show()\",\n \"def RMSE(actual, noisy):\\n # print len(actual)\\n # print len(noisy)\\n tmp = mean_squared_error(actual, noisy)\\n # print \\\"Tmp\\\", tmp\\n return math.sqrt(float(tmp))\\n\\n # noisy_vals = []\\n # actual_vals = []\\n # print len(actual), actual\\n # print len(noisy), noisy\\n # for lid in noisy.keys():\\n # noisy_vals.append(noisy.get(lid))\\n # if not actual.has_key(lid):\\n # print lid\\n # actual_vals.append(actual.get(lid))\\n\\n # print len(actual_vals), actual_vals\\n # print len(noisy_vals), noisy_vals\",\n \"def eva_regress(y_true, y_pred):\\n\\n mape = MAPE(y_true, y_pred)\\n vs = metrics.explained_variance_score(y_true, y_pred)\\n mae = metrics.mean_absolute_error(y_true, y_pred)\\n mse = metrics.mean_squared_error(y_true, y_pred)\\n r2 = metrics.r2_score(y_true, y_pred)\\n print('explained_variance_score:%f' % vs)\\n print('mape:%f%%' % mape)\\n print('mae:%f' % mae)\\n print('mse:%f' % mse)\\n print('rmse:%f' % np.sqrt(mse))\\n print('r2:%f' % r2)\",\n \"def rmse(y_true, y_pred): # -> Any:\\n ...\",\n \"def plot_loss(self):\\n train_elbo_range = range(len(self.train_elbo_hist))\\n val_elbo_range = range(len(self.val_elbo_hist))\\n train_loss_range = range(len(self.train_loss_hist))\\n val_loss_range = range(len(self.val_loss_hist))\\n\\n fig, ax = plt.subplots(2, 2)\\n ax[0][0].plot(train_elbo_range, self.train_elbo_hist)\\n ax[0][0].title.set_text(\\\"Train ELBO\\\")\\n ax[0][1].plot(val_elbo_range, self.val_elbo_hist)\\n ax[0][1].title.set_text(\\\"Val ELBO\\\")\\n ax[1][0].plot(train_loss_range, self.train_loss_hist)\\n ax[1][0].title.set_text(\\\"Train MSE\\\")\\n ax[1][1].plot(val_loss_range, self.val_loss_hist)\\n ax[1][1].title.set_text(\\\"Val MSE\\\")\\n plt.tight_layout()\\n plt.show()\",\n \"def rmse(self):\\n return (self.model_error()**2).mean()**.5\",\n \"def plot_multisite_rms(params, phot_data, mag_col, merr_col, qc_col, plot_filename, log):\\n\\n # Plot a multi-site initial RMS diagram for reference\\n phot_statistics = np.zeros( (len(phot_data),4) )\\n (phot_statistics[:,0],werror) = plot_rms.calc_weighted_mean_2D(phot_data, mag_col, merr_col, qc_col=qc_col)\\n phot_statistics[:,1] = plot_rms.calc_weighted_rms(phot_data, phot_statistics[:,0], mag_col, merr_col, qc_col=qc_col)\\n\\n text_filename = plot_filename.replace('.png', '.txt')\\n f = open(path.join(params['red_dir'],text_filename),'w')\\n f.write('# Star_index wMean_mag RMS\\\\n')\\n for j in range(0,len(phot_statistics),1):\\n f.write(str(j)+' '+str(phot_statistics[j,0])+' '+str(phot_statistics[j,1])+'\\\\n')\\n f.close()\\n\\n fig = plt.figure(3,(10,10))\\n plt.rcParams.update({'font.size': 18})\\n mask = np.logical_and(phot_statistics[:,0] > 0.0, phot_statistics[:,1] > 0.0)\\n plt.plot(phot_statistics[mask,0], phot_statistics[mask,1], 'k.',\\n markersize=0.5, label='Weighted RMS')\\n plt.yscale('log')\\n plt.xlabel('Weighted mean mag')\\n plt.ylabel('RMS [mag]')\\n plt.grid()\\n l = plt.legend()\\n plt.tight_layout()\\n [xmin,xmax,ymin,ymax] = plt.axis()\\n plt.axis([xmin,xmax,1e-3,5.0])\\n plot_file = path.join(params['red_dir'],plot_filename)\\n plt.savefig(plot_file)\\n log.info('Output RMS plot to '+plot_filename)\\n plt.close(3)\",\n \"def validate_spreads():\\n fig, (ax_prior, ax2_post) = plt.subplots(\\n nrows=2, figsize=figsize(aspect=1.2))\\n\\n # train margin-dependent Elo model\\n melo = Melo(lines=np.arange(-49.5, 50.5), commutes=False, k=1e-4)\\n melo.fit(league.times, league.labels1, league.labels2, league.spreads)\\n\\n # exact prior distribution\\n outcomes = melo.training_data.value[:, np.newaxis] > melo.lines\\n sf = np.mean(outcomes, axis=0)\\n ax_prior.plot(melo.lines, sf, color='k')\\n\\n # label names\\n label1 = str(league.lambda1)\\n label2_list = [str(lambda2) for lambda2 in league.lambda2_list]\\n\\n plot_args = [\\n (ax_prior, melo.first_update, 'prior'),\\n (ax2_post, melo.last_update, 'posterior'),\\n ]\\n\\n for ax, time, title in plot_args:\\n for n, label2 in enumerate(label2_list):\\n\\n lines, sf = melo._predict(time, label1, label2)\\n label = r'$\\\\lambda_2={}$'.format(label2)\\n\\n if ax.is_first_row():\\n ax.plot(lines[n::6], sf[n::6], 'o', zorder=2, label=label)\\n\\n if ax.is_last_row():\\n ax.plot(lines, sf, 'o', zorder=2, label=label)\\n\\n sf = skellam.sf(melo.lines, int(label1), int(label2))\\n ax.plot(melo.lines, sf, color='k')\\n\\n leg = ax.legend(title=r'$\\\\lambda_1 = {}$'.format(label1),\\n handletextpad=.2, loc=1)\\n leg._legend_box.align = 'right'\\n\\n lines = np.floor(lines)\\n ax.set_xticks(lines[::10])\\n ax.set_xlim(lines.min(), lines.max())\\n\\n if ax.is_last_row():\\n ax.set_xlabel('line $=$ scored $-$ allowed')\\n\\n ax.set_ylabel('probability to cover line')\\n\\n ax.annotate(title, xy=(.05, .05),\\n xycoords='axes fraction', fontsize=24)\\n\\n set_tight(h_pad=1)\",\n \"def main():\\n Nrep = 8 # number of repetition of EM steps\\n nm = 3 # number of mixed gaussians.\\n ns = 300 # number of samples.\\n \\n mu, sg, lm, lm_ind, smp, L_true = generate_synthetic_data(nm, ns)\\n plt.figure(1, figsize=(5,4))\\n plt.clf()\\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\\n \\n mue, sge, lme = generate_initial_state(nm, ns)\\n axi = 0 # subplot number\\n plt.figure(2, figsize=(12,9))\\n plt.clf()\\n for rep in range(Nrep):\\n # E-step\\n r, L_infer = e_step(smp, mue, sge, lme, nm, ns)\\n axi += 1 \\n ax = plt.subplot(Nrep/2, 6, axi)\\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\\n ax.set_title('E-step : %d' % (rep + 1))\\n ax.set_yticklabels([])\\n ax.set_xticklabels([])\\n ax.set_ylim((-0.1, 0.3))\\n\\n # M-step\\n mue, sge, lme = m_step(smp, r, nm, ns)\\n axi += 1 \\n ax = plt.subplot(Nrep/2, 6, axi)\\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\\n ax.set_title('M-step : %d' % (rep + 1))\\n ax.set_yticklabels([])\\n ax.set_xticklabels([])\\n ax.set_ylim((-0.1, 0.3))\\n\\n # plot the ground truth for comparison\\n axi += 1 \\n ax = plt.subplot(Nrep/2, 6, axi)\\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\\n ax.set_title('grn_truth')\\n ax.set_yticklabels([])\\n ax.set_xticklabels([])\\n ax.set_ylim((-0.1, 0.3))\\n\\n print('L_infer = %2.6f , L_true = %2.6f' % (L_infer, L_true))\",\n \"def plot_r(f=500, d=100e-3, dr=0.01, picture_file=None, picture_formats=['png', 'pdf', 'svg']):#x_axis='r', \\n import matplotlib.pyplot\\n i = 0\\n rs = []\\n sigmas = []\\n ys = []\\n print \\\"r_soll ->\\\\tsigma ->\\\\tr\\\"\\n datas = []\\n for r in numpy.arange(0, 1+dr, dr) :\\n for t in [0] :\\n print \\\"%f\\\\t\\\" %(r),\\n sigma = getSigma(r)\\n print \\\"%f\\\\t\\\" % (sigma),\\n rs.append(r)\\n sigmas.append(sigma)\\n v = getSynapticActivity(f=f, r=r, fireing_rate=1, duration=d, delay=t)\\n #print v\\n #matplotlib.pyplot.scatter(v, numpy.zeros( len(v) ) + i )\\n r = vector_strength(f, v)\\n print \\\"%f\\\" % (r)\\n ys.append(r)\\n i = i+1\\n datas.append([sigma,r])\\n numpy.savetxt(\\\"../../../Data/%.1f_%f@%i.dat\\\" % (getSigma(dr),dr,int(f*d)), datas) \\n\\n matplotlib.pyplot.figure()\\n matplotlib.pyplot.xlabel('sigma')\\n matplotlib.pyplot.ylabel('measured vector strength')\\n matplotlib.pyplot.xlim(0, getSigma(dr))\\n matplotlib.pyplot.ylim(0, 1)\\n matplotlib.pyplot.grid()\\n matplotlib.pyplot.scatter(sigmas,ys, marker='x', color='black')#, basex=10, basey=10, ls=\\\"-\\\"\\n if(picture_file != None):\\n for picture_format in picture_formats:\\n matplotlib.pyplot.savefig(picture_file+'sigma_'+str(getSigma(dr))+'_'+str(int(f*d))+'.'+picture_format,format=picture_format)\\n else:\\n matplotlib.pyplot.show()\\n\\n matplotlib.pyplot.figure()\\n matplotlib.pyplot.xlabel('aimed vector strength')\\n matplotlib.pyplot.ylabel('measured vector strength')\\n #matplotlib.pyplot.legend([\\\"based on %i examples / dot\\\" % (f*d) ], loc='best');\\n matplotlib.pyplot.xlim(0, 1)\\n matplotlib.pyplot.ylim(0, 1)\\n matplotlib.pyplot.grid()\\n\\n matplotlib.pyplot.scatter(rs,ys, marker='x', color='black')\\n if(picture_file != None):\\n for picture_format in picture_formats:\\n matplotlib.pyplot.savefig(picture_file+'_'+str(dr)+'_'+str(int(f*d))+'.'+picture_format,format=picture_format)\\n else:\\n matplotlib.pyplot.show()\\n\\n matplotlib.pyplot.close('all')\\n datas = numpy.ndarray((len(datas),2), buffer=numpy.array(datas),dtype=float)\\n return datas\",\n \"def felm_rmse(y, X, weights, y_test, X_test):\\n # Fit model and get predicted values of test data\\n mod = sm.WLS(y, X, weights=weights).fit()\\n pred = mod.predict(X_test)\\n\\n #Get residuals from test data\\n res = (y_test[:] - pred.values)\\n\\n # Calculate ttest to check that residuals from test and train are independent\\n t_stat, p_val = stats.ttest_ind(mod.resid, res, equal_var=False)\\n\\n # Return RMSE and t-stat from ttest\\n return (np.sqrt(np.mean(res**2)), t_stat)\",\n \"def _plot(self):\\n # Read results\\n path = self.openmc_dir / f'statepoint.{self._batches}.h5'\\n x1, y1, _ = read_results('openmc', path)\\n if self.code == 'serpent':\\n path = self.other_dir / 'input_det0.m'\\n else:\\n path = self.other_dir / 'outp'\\n x2, y2, sd = read_results(self.code, path)\\n\\n # Convert energies to eV\\n x1 *= 1e6\\n x2 *= 1e6\\n\\n # Normalize the spectra\\n y1 /= np.diff(np.insert(x1, 0, self._min_energy))*sum(y1)\\n y2 /= np.diff(np.insert(x2, 0, self._min_energy))*sum(y2)\\n\\n # Compute the relative error\\n err = np.zeros_like(y2)\\n idx = np.where(y2 > 0)\\n err[idx] = (y1[idx] - y2[idx])/y2[idx]\\n \\n # Set up the figure\\n fig = plt.figure(1, facecolor='w', figsize=(8,8))\\n ax1 = fig.add_subplot(111)\\n \\n # Create a second y-axis that shares the same x-axis, keeping the first\\n # axis in front\\n ax2 = ax1.twinx()\\n ax1.set_zorder(ax2.get_zorder() + 1)\\n ax1.patch.set_visible(False)\\n \\n # Plot the spectra\\n label = 'Serpent' if self.code == 'serpent' else 'MCNP'\\n ax1.loglog(x2, y2, 'r', linewidth=1, label=label)\\n ax1.loglog(x1, y1, 'b', linewidth=1, label='OpenMC', linestyle='--')\\n \\n # Plot the relative error and uncertainties\\n ax2.semilogx(x2, err, color=(0.2, 0.8, 0.0), linewidth=1)\\n ax2.semilogx(x2, 2*sd, color='k', linestyle='--', linewidth=1)\\n ax2.semilogx(x2, -2*sd, color='k', linestyle='--', linewidth=1)\\n \\n # Set grid and tick marks\\n ax1.tick_params(axis='both', which='both', direction='in', length=10)\\n ax1.grid(b=False, axis='both', which='both')\\n ax2.tick_params(axis='y', which='both', right=False)\\n ax2.grid(b=True, which='both', axis='both', alpha=0.5, linestyle='--')\\n \\n # Set axes labels and limits\\n ax1.set_xlim([self._min_energy, self.energy])\\n ax1.set_xlabel('Energy (eV)', size=12)\\n ax1.set_ylabel('Spectrum', size=12)\\n ax1.legend()\\n ax2.set_ylabel(\\\"Relative error\\\", size=12)\\n title = f'{self.nuclide}'\\n if self.thermal is not None:\\n name, suffix = self.thermal.split('.')\\n thermal_name = openmc.data.thermal.get_thermal_name(name)\\n title += f' + {thermal_name}'\\n title += f', {self.energy:.1e} eV Source'\\n plt.title(title)\\n \\n # Save plot\\n os.makedirs('plots', exist_ok=True)\\n if self.name is not None:\\n name = self.name\\n else:\\n name = f'{self.nuclide}'\\n if self.thermal is not None:\\n name += f'-{thermal_name}'\\n name += f'-{self.energy:.1e}eV'\\n if self._temperature is not None:\\n name += f'-{self._temperature:.1f}K'\\n plt.savefig(Path('plots') / f'{name}.png', bbox_inches='tight')\\n plt.close()\",\n \"def plot_inv_rv_dep(\\n outpath,\\n inv_RVs,\\n alavs,\\n alav_uncs,\\n waves,\\n plot_waves,\\n slopes,\\n intercepts,\\n dense,\\n norm=\\\"V\\\",\\n):\\n fig, ax = plt.subplots(\\n len(plot_waves), figsize=(7, len(plot_waves) * 4), sharex=True\\n )\\n if norm != \\\"V\\\":\\n norm = str(norm) + r\\\"\\\\mu m\\\"\\n\\n for j, wave in enumerate(plot_waves):\\n indx = np.abs(waves - wave).argmin()\\n # plot the data and the fitted line, give the dense sightlines a different color and marker\\n handle1 = ax[j].errorbar(\\n inv_RVs[dense][:, 0] - 1 / 3.1,\\n alavs[indx][dense],\\n xerr=(\\n inv_RVs[dense][:, 1],\\n inv_RVs[dense][:, 2],\\n ),\\n yerr=alav_uncs[indx][dense],\\n ms=5,\\n fmt=\\\"s\\\",\\n color=\\\"magenta\\\",\\n elinewidth=0.5,\\n )\\n handle2 = ax[j].errorbar(\\n inv_RVs[~dense][:, 0] - 1 / 3.1,\\n alavs[indx][~dense],\\n xerr=(\\n inv_RVs[~dense][:, 1],\\n inv_RVs[~dense][:, 2],\\n ),\\n yerr=alav_uncs[indx][~dense],\\n ms=5,\\n fmt=\\\"ok\\\",\\n elinewidth=0.5,\\n )\\n xs = np.arange(-0.155, 0.12, 0.01)\\n ax[j].plot(\\n xs,\\n slopes[indx] * xs + intercepts[indx],\\n color=\\\"forestgreen\\\",\\n ls=\\\"-\\\",\\n label=r\\\"$%5.3f\\\\, %+5.3f\\\\, [1/R(V)-1/3.1]$\\\"\\n % (intercepts[indx], slopes[indx]),\\n )\\n ax[j].set_ylabel(r\\\"$A(\\\" + \\\"{:1.2f}\\\".format(wave) + \\\"\\\\mu m)/A(\\\" + norm + \\\")$\\\")\\n ax[j].legend(loc=\\\"lower left\\\", fontsize=fs * 0.8)\\n\\n # add literature curves, only if normalized to A(V)\\n if norm == \\\"V\\\":\\n styles = [\\\"--\\\", \\\":\\\"]\\n for i, cmodel in enumerate([CCM89, F19]):\\n if wave > 3.3:\\n continue\\n yvals = []\\n for xval in xs:\\n ext_model = cmodel(Rv=1 / (xval + 1 / 3.1))\\n yvals.append(ext_model(wave * u.micron))\\n ax[j].plot(\\n xs,\\n yvals,\\n lw=1.5,\\n ls=styles[i],\\n alpha=0.8,\\n )\\n line_handles = [\\n Line2D([0], [0], color=\\\"tab:blue\\\", lw=1.5, ls=\\\"--\\\"),\\n Line2D([0], [0], color=\\\"tab:orange\\\", lw=1.5, ls=\\\":\\\"),\\n ]\\n line_labels = [\\n \\\"Cardelli et al. (1989)\\\",\\n \\\"Fitzpatrick et al. (2019)\\\",\\n ]\\n\\n # finalize the plot\\n plt.xlabel(r\\\"$\\\\frac{1}{R(V)} - \\\\frac{1}{3.1}$\\\", fontsize=fs * 1.3)\\n plt.subplots_adjust(hspace=0)\\n handles = [handle1, handle2]\\n labels = (\\\"dense\\\", \\\"diffuse\\\")\\n fig.legend(handles, labels, bbox_to_anchor=(0.4, 0.19), fontsize=fs * 0.8)\\n if norm == \\\"V\\\":\\n fig.legend(\\n line_handles, line_labels, bbox_to_anchor=(0.65, 0.8), fontsize=fs * 0.8\\n )\\n plt.savefig(\\n outpath + \\\"inv_RV_dep\\\" + norm.split(\\\"\\\\\\\\\\\")[0] + \\\".pdf\\\", bbox_inches=\\\"tight\\\"\\n )\",\n \"def plot_mse(mse, lambda0, lambda1, scale, loc='lower right'):\\n import matplotlib.pyplot as plt\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(211)\\n ax.plot(*zip(*mse))\\n plt.xlabel('$\\\\lambda$')\\n plt.ylabel('MSE')\\n plt.yticks(scale)\\n\\n ax = fig.add_subplot(212)\\n ax.plot(*zip(*lambda0), label='$\\\\lambda=0$')\\n plt.xlabel('Episode')\\n plt.ylabel('MSE')\\n ax.plot(*zip(*lambda1), label='$\\\\lambda=1$')\\n plt.legend(loc=loc)\\n\\n plt.show()\",\n \"def rmse(self):\\n y_pred, y_true = self._finalize_labels_and_prediction()\\n\\n return np.sqrt(F.mse_loss(y_pred, y_true).cpu().item())\",\n \"def rmse(self):\\n y_pred, y_true = self._finalize_labels_and_prediction()\\n\\n return np.sqrt(F.mse_loss(y_pred, y_true).cpu().item())\",\n \"def lm_model(x_all, y_all, print_ind = True, plot_ind = True):\\n \\n # data\\n x_train = x_all[x_all[\\\"yyyymm\\\"] < TRAIN_DATE].iloc[:,1:].to_numpy()\\n x_test = x_all[x_all[\\\"yyyymm\\\"] >= TRAIN_DATE].iloc[:,1:].to_numpy()\\n y_train = y_all[y_all[\\\"yyyymm\\\"] < TRAIN_DATE].iloc[:,1].to_numpy()\\n y_test = y_all[y_all[\\\"yyyymm\\\"] >= TRAIN_DATE].iloc[:,1].to_numpy()\\n \\n # Fit model\\n X = sm.add_constant(x_train)\\n lm = sm.OLS(y_train, X).fit()\\n \\n if print_ind:\\n print(lm.summary())\\n print()\\n \\n # test\\n X_test = sm.add_constant(x_test)\\n ypred = lm.predict(X_test)\\n MSE = np.sum((ypred - y_test)**2) / len(y_test)\\n\\n # plot\\n if plot_ind:\\n # Residual plot\\n plt.figure(figsize = (10,7))\\n plt.scatter(lm.fittedvalues, lm.resid)\\n plt.xlabel('Fitted Value', fontsize = 15)\\n plt.ylabel('Residual', fontsize = 15)\\n plt.title(\\\"Residual plot\\\", fontsize = 25)\\n plt.axhline(y = 0)\\n plt.show()\\n \\n # QQ plot\\n plt.figure(figsize = (10,7))\\n sm.ProbPlot(lm.resid).qqplot()\\n plt.title(\\\"qq-plot\\\", fontsize = 25)\\n abline(1,0)\\n plt.show()\\n \\n # print\\n if print_ind:\\n print(\\\"Test MSE: {:.6f}\\\".format(MSE))\\n print(\\\"Test MSE as % of square mean: {:.6f}\\\".format(MSE / (np.mean(y_test) ** 2)))\\n \\n \\n return lm, MSE\",\n \"def convergence():\\n fig, axes = plt.subplots(nrows=2, figsize=figsize(aspect=1.2))\\n\\n # label names\\n label1 = str(league.lambda1)\\n label2_list = [str(lambda2) for lambda2 in league.lambda2_list]\\n\\n # point spread and point total subplots\\n subplots = [\\n (False, [-0.5, 0.5], league.spreads, 'probability spread > 0.5'),\\n (True, [200.5], league.totals, 'probability total > 200.5'),\\n ]\\n\\n for ax, (commutes, lines, values, ylabel) in zip(axes, subplots):\\n\\n # train margin-dependent Elo model\\n melo = Melo(lines=lines, commutes=commutes, k=1e-4)\\n melo.fit(league.times, league.labels1, league.labels2, values)\\n\\n line = lines[-1]\\n\\n for label2 in label2_list:\\n\\n # evaluation times and labels\\n times = np.arange(league.times.size)[::1000]\\n labels1 = times.size * [label1]\\n labels2 = times.size * [label2]\\n\\n # observed win probability\\n prob = melo.probability(times, labels1, labels2, lines=line)\\n ax.plot(times, prob)\\n\\n # true (analytic) win probability\\n if ax.is_first_row():\\n prob = skellam.sf(line, int(label1), int(label2))\\n ax.axhline(prob, color='k')\\n else:\\n prob = poisson.sf(line, int(label1) + int(label2))\\n ax.axhline(prob, color='k')\\n\\n # axes labels\\n if ax.is_last_row():\\n ax.set_xlabel('Iterations')\\n ax.set_ylabel(ylabel)\\n\\n set_tight(w_pad=.5)\",\n \"def plotErr(self):\\n if self.xp and self.wp:\\n # plot the spectra\\n w=self.ws.value(np.array(self.xp))\\n self.errcurve,=self.erraxes.plot(self.xp,self.wp-w,linewidth=0.5,linestyle='',marker='o',color='b')\\n if self.dxp and self.dwp:\\n # plot the spectra\\n dw=self.ws.value(np.array(self.dxp))\\n self.delerrcurve,=self.erraxes.plot(self.dxp,self.dwp-dw,linewidth=0.5,linestyle='',marker='x',color='b')\",\n \"def visualization(epochs, mse_tr, mse_te):\\n plt.semilogx(epochs, mse_tr, marker=\\\".\\\", color='b', label='train error')\\n plt.semilogx(epochs, mse_te, marker=\\\".\\\", color='r', label='test error')\\n plt.xlabel(\\\"k\\\")\\n plt.ylabel(\\\"rmse\\\")\\n plt.title(\\\"cross validation\\\")\\n plt.legend(loc=2)\\n plt.grid(True)\\n plt.savefig(\\\"cross_validation\\\")\",\n \"def plot_residuals(result_file,output_fig=None,fig=None,**kwargs):\\n \\n \\n #### Read file\\n \\n dic_result=file2dic(result_file)\\n\\n ### Get xbin range\\n \\n rms_val=np.append(dic_result['RMS_P'],dic_result['RMS_S'])\\n x_bins=np.linspace(np.min(rms_val),np.max(rms_val),100)\\n \\n ### Plots\\n \\n if fig is None:\\n fig, (ax1, ax2) = plt.subplots(2, sharex=True)\\n else: \\n (ax1,ax2)=fig.get_axes()\\n \\n ax1.hist(dic_result['RMS_P'],x_bins,edgecolor='black',**kwargs)\\n ax1.set_title('RMS for %i models tested'%(len(dic_result['RMS_P'])))\\n ax1.set_ylabel('P')\\n ax1.tick_params('x',direction='in')\\n ax2.hist(dic_result['RMS_S'],x_bins,edgecolor='black',**kwargs)\\n ax2.invert_yaxis()\\n ax2.set_xlabel('RMS [s]')\\n ax2.set_ylabel('S')\\n \\n fig.subplots_adjust(hspace=0)\\n plt.setp([a.get_xticklabels() for a in fig.axes[:-1]], visible=False)\\n \\n if output_fig:\\n plt.savefig(output_fig)\\n \\n \\n return fig\",\n \"def rmse(sim, obs, dim=\\\"time\\\"):\\n rmse = np.sqrt(mse(sim, obs, dim=dim))\\n rmse.name = \\\"rmse\\\"\\n return rmse\",\n \"def ivrmse(self):\\n return (self.model_error_iv()**2).mean()**.5\",\n \"def RMSE(y,yhat):\\r\\n return(np.sqrt(MSE(y,yhat)))\",\n \"def plot4(self, plog=False):\\n\\n probs = pd.read_csv(self.probfile)\\n\\n plt.rc('font', size=14)\\n fig, ax = plt.subplots()\\n plt.plot(self.ds.freq, self.snr, 'k-', alpha=0.5, zorder=1)\\n\\n # plot the SNR range to search across when finding snr_modes\\n for idx, line in enumerate(self.ds.mode_id['f0']):\\n w = np.exp(self.ds.mode_id['w0'][idx])\\n plt.axvline(x=line-w, color='b', linestyle='-', alpha=0.4)\\n plt.axvline(x=line+w, color='b', linestyle='-', alpha=0.4)\\n\\n # overplot the predicted SNR values at the modes\\n plt.scatter(probs['f0'], probs['SNR_Kepler'], label='Kepler - 4yrs', alpha=1, zorder=2)\\n plt.scatter(probs['f0'], probs['SNR_TESS365'], label='TESS - 1 yr', alpha=1, zorder=3)\\n plt.scatter(probs['f0'], probs['SNR_TESS27'], label='TESS - 27 days', alpha=1, zorder=4)\\n\\n if plog:\\n plt.xscale('log')\\n plt.yscale('log')\\n plt.xlabel(r'$\\\\nu$ / $\\\\rm \\\\mu Hz$')\\n plt.ylabel(r'SNR')\\n\\n mn = min(star.ds.mode_id['f0']) -\\\\\\n (max(star.ds.mode_id['f0'])-min(star.ds.mode_id['f0']))/7.\\n mx = max(star.ds.mode_id['f0']) +\\\\\\n (max(star.ds.mode_id['f0'])-min(star.ds.mode_id['f0']))/7.\\n plt.xlim([mn,mx])\\n\\n plt.legend()\\n plt.title('KIC ' + str(self.ds.epic))\\n plt.show()\\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\\\\n 'plot4_SNR' + self.ds.epic + '.pdf')\",\n \"def find_best_rmse(name, x_train, y_train, x_test, y_test, k_max=23, metric='euclidean', plot=True, debug=False):\\n \\\"\\\"\\\"\\n :param k_max: maximum number of k to test for\\n :param plot: True if matplotlib plot should be created\\n :param debug: print additional info about accuracy test results\\n :return: best k and best accuracy for given training and test set with features (k < k_max)\\n \\\"\\\"\\\"\\n\\n # Go through all k between k=1 and k=k_max-1 and find best_k and best_a\\n # rsmes = np.zeros(k_max) # Write rsmes for each k into here for plot to work...\\n\\n rmse_val = [] # to store rmse values for different k\\n for k in range(1, k_max):\\n model = neighbors.KNeighborsRegressor(n_neighbors=k, metric=metric)\\n model.fit(x_train, y_train) # fit the model\\n pred = model.predict(x_test) # make prediction on test set\\n rsme = sqrt(mean_squared_error(y_test, pred)) # calculate rmse\\n\\n if k == 1:\\n best_rmse = rsme\\n best_k = k\\n elif rsme < best_rmse:\\n best_rmse = rsme\\n best_k = k\\n\\n rmse_val.append(rsme) # store rmse values\\n if debug:\\n print('RMSE value for k=', k, 'is:', rsme)\\n\\n if plot:\\n t = range(1, k_max)\\n plt.plot(t, rmse_val[0:k_max - 1], '--', label=name)\\n plt.xticks(t)\\n plt.xlabel('# neighbours (k)')\\n plt.ylabel('Root Mean Squared Error')\\n plt.scatter(best_k, best_rmse)\\n plt.legend()\\n return best_rmse, best_k\",\n \"def plot_spectrum(data, name, fig):\\n\\n det = data.detectors[name]\\n val = det.tallies\\n\\n E = [line[0] for line in det.grids['E']]\\n Emax = det.grids['E'][-1][1]\\n\\n dE = np.roll(E, -1) - E\\n dE[-1] = Emax - E[-1]\\n inte = sum(val*dE)\\n val = val/inte\\n\\n plt.figure()\\n plt.loglog(E, val)\\n plt.xlabel('E [MeV]')\\n plt.ylabel('Normalized flux')\\n plt.grid(True)\\n plt.savefig(fig + '-' + name, dpi=300, bbox_inches=\\\"tight\\\")\",\n \"def analyze(data):\\n # perform fit\\n regr_results = sm.OLS.from_formula('mosquitos ~ temperature + rainfall', data).fit()\\n print(regr_results.tvalues)\\n \\n fig = plt.figure(figsize=(6, 9))\\n\\n # plot predicted vs. measured mosquito populations from fitted model \\n ax0 = fig.add_subplot(3, 1, 1)\\n\\n parameters = regr_results.params\\n predicted = (parameters['Intercept'] + \\n parameters['temperature'] * data['temperature'] + \\n parameters['rainfall'] * data['rainfall'])\\n\\n ax0.plot(predicted, data['mosquitos'], 'gd')\\n\\n ax0.set_xlabel('predicted mosquito population')\\n ax0.set_ylabel('measured mosquito population')\\n \\n # plot mosquitos vs. temperature\\n ax1 = fig.add_subplot(3, 1, 2)\\n\\n ax1.plot(data['temperature'], data['mosquitos'], 'ro')\\n ax1.set_xlabel('temperature')\\n ax1.set_ylabel('mosquitos')\\n\\n # plot mosquitos vs. rainfall\\n ax2 = fig.add_subplot(3, 1, 3)\\n\\n ax2.plot(data['rainfall'], data['mosquitos'], 'bs')\\n ax2.set_xlabel('rainfall')\\n ax2.set_ylabel('mosquitos')\\n \\n # adjust layout of axes according to label placement\\n plt.tight_layout()\\n \\n return fig\",\n \"def plot(res,code,reactor=None,groupby='PeriodEndYrMn', hline=None):\\r\\n box = res.boxplot(column='ResultsValue', showfliers=False, return_type=None, by=groupby, patch_artist=False)\\r\\n #box['boxes'].set_facecolor('green')\\r\\n ind = code.strip()\\r\\n lab = ind if reactor is None else ind + ' ' +reactor.strip()\\r\\n plt.ylabel(lab)\\r\\n plt.xticks(rotation=60)\\r\\n plt.title('')\\r\\n if hline is not None:\\r\\n plt.axhline(y=hline[0], color='r', linestyle='-', label='Individual target')\\r\\n plt.axhline(y=hline[1], color='b', linestyle='-', label='Industry target')\\r\\n plt.legend()\\r\\n plt.tight_layout()\\r\\n #plt.show()\\r\\n fn = 'pic/'+ind+'_trend.png' if reactor is None else 'pic/'+ind+'_'+reactor.strip()+'_trend.png'\\r\\n plt.savefig(fn)\\r\\n print(fn+' is saved')\",\n \"def MSE(actual, noisy):\\n mean_squared_error(actual, noisy)\",\n \"def plot_em_steps(smp, r, mue, sge, lme, nm, ns):\\n x = np.linspace(-20, 20, 400)\\n clr = 0.6\\n clrs = [(1, 0.2, 0), (0, 1, 0), (0, 0.6, 1)]\\n plt.hist(smp, 100, normed=1, color=(0.7, 0.7, 0.7))\\n for i in range(ns):\\n cl = (clr*r[0, i], clr*r[1, i], clr*r[2, i])\\n plt.plot(smp[i], -0.05, '.', color=cl, markersize=2)\\n for k, c in zip(range(nm), clrs):\\n plt.plot(x, lme[k] * spst.norm(mue[k], sge[k]).pdf(x), color=clrs[k])\",\n \"def plotDistributionWithRegression(lXs, lYs, rXs, rYs, slope, intercept, R2, pval, meanPhase, stdvPhase,out=\\\"\\\", title=\\\"\\\", xax=\\\"\\\", yax=\\\"\\\"):\\n\\n fig = plt.Figure(figsize=(20,20))\\n fig.suptitle(title, fontsize=32)\\n ax = fig.add_subplot(111)\\n ax.plot(lXs,lYs)\\n annotation_font = {'size':16}\\n for i in rYs:\\n ax.annotate(str(i),xy=(i-10,lYs[i]+10), **annotation_font)\\n ax.scatter([i for i in rYs],[lYs[i] for i in rYs],color='red',marker='+', s=200)\\n axis_font = {'size':'28'}\\n ax.set_xlabel(xax, **axis_font)\\n ax.set_ylabel(yax, **axis_font)\\n ax.tick_params(labelsize=20)\\n ax.set_xlim(0,lXs[-1]+10)\\n ax.set_ylim(min(lYs)-10,max(lYs)+10)\\n # add regression graph\\n ax2 = fig.add_axes([0.55,0.55,0.3,0.3])\\n # ax2.axis([0,rXs[-1],0,rYs[-1]])\\n ax2.set_xlim(0,rXs[-1]+2)\\n ax2.scatter([x+1 for x in rXs],rYs)\\n ax2.plot([x+1 for x in rXs], [x*slope+intercept for x in rXs], color='red')\\n axis_font2 = {'size':'18'}\\n ax2.set_title('linear regression', **axis_font2)\\n ax2.set_xlabel('#peak', **axis_font2)\\n ax2.set_ylabel('positions bp', **axis_font2)\\n ax2.tick_params(labelsize=16)\\n ax2.text(0.5,rYs[-1]*0.95 , 'Phase={}+-{}'.format(meanPhase,stdvPhase),\\n verticalalignment='top', horizontalalignment='left',\\n fontsize=15)\\n ax2.text(0.5,rYs[-1]*0.9, 'R2={}'.format(R2),\\n verticalalignment='top', horizontalalignment='left',\\n fontsize=15)\\n ax2.text(0.5,rYs[-1]*0.85, 'p-value={}'.format(pval),\\n verticalalignment='top', horizontalalignment='left',\\n fontsize=15)\\n canvas = FigureCanvasAgg(fig)\\n canvas.print_figure(out, dpi=80)\",\n \"def _plot(self, rewards, losses, epsilons):\\n plt.figure(figsize=(20,5))\\n plt.subplot(131)\\n plt.title('Episodic Reward')\\n plt.plot(rewards)\\n plt.subplot(132)\\n plt.title('TD Loss')\\n plt.plot(losses)\\n plt.subplot(133)\\n plt.title('Epsilon')\\n plt.plot(epsilons)\\n plt.tight_layout()\\n plt.show()\",\n \"def plot_inv_RV_lit(outpath, fit_slopes, fit_intercepts, fit_stds):\\n waves = np.arange(0.8, 4.01, 0.001)\\n fig, ax = plt.subplots(figsize=(10, 9))\\n\\n for i, RV in enumerate([2.5, 3.1, 5.5]):\\n # plot the extinction curve from this work\\n offset = 0.1 * i\\n slopes = interpolate.splev(waves, fit_slopes)\\n alav = fit_intercepts(waves) + slopes * (1 / RV - 1 / 3.1)\\n (line,) = ax.plot(waves, alav + offset, lw=1.5, label=r\\\"$R(V) = $\\\" + str(RV))\\n stddev = interpolate.splev(waves, fit_stds)\\n color = line.get_color()\\n ax.fill_between(\\n waves,\\n alav + offset - stddev,\\n alav + offset + stddev,\\n color=color,\\n alpha=0.2,\\n edgecolor=None,\\n )\\n\\n # plot the literature curves\\n styles = [\\\"--\\\", \\\":\\\"]\\n for i, cmodel in enumerate([CCM89, F19]):\\n ext_model = cmodel(Rv=RV)\\n (indxs,) = np.where(\\n np.logical_and(\\n 1 / waves >= ext_model.x_range[0], 1 / waves <= ext_model.x_range[1]\\n )\\n )\\n yvals = ext_model(waves[indxs] * u.micron)\\n ax.plot(\\n waves[indxs],\\n yvals + offset,\\n lw=1.5,\\n color=color,\\n ls=styles[i],\\n alpha=0.8,\\n )\\n\\n # add text\\n ax.text(3.45, 0.03, r\\\"$R(V) = 2.5$\\\", fontsize=0.8 * fs, color=\\\"tab:blue\\\")\\n ax.text(3.45, 0.15, r\\\"$R(V) = 3.1$\\\", fontsize=0.8 * fs, color=\\\"tab:orange\\\")\\n ax.text(3.45, 0.305, r\\\"$R(V) = 5.5$\\\", fontsize=0.8 * fs, color=\\\"tab:green\\\")\\n\\n # finalize and save the plot\\n ax.set_xlabel(r\\\"$\\\\lambda\\\\ [\\\\mu m$]\\\", fontsize=1.2 * fs)\\n ax.set_ylabel(r\\\"$A(\\\\lambda)/A(V)$ + offset\\\", fontsize=1.2 * fs)\\n ax.set_xlim(0.75, 4.05)\\n ax.set_ylim(-0.03, 0.98)\\n handles = [\\n Line2D([0], [0], color=\\\"k\\\", lw=1.5),\\n Line2D([0], [0], color=\\\"k\\\", lw=1.5, ls=\\\"--\\\"),\\n Line2D([0], [0], color=\\\"k\\\", lw=1.5, ls=\\\":\\\"),\\n ]\\n labels = [\\n \\\"this work\\\",\\n \\\"Cardelli et al. (1989)\\\",\\n \\\"Fitzpatrick et al. (2019)\\\",\\n ]\\n plt.legend(handles, labels, fontsize=fs)\\n plt.savefig(outpath + \\\"inv_RV_lit.pdf\\\", bbox_inches=\\\"tight\\\")\\n\\n # also save the plot in log scale\\n plt.ylim(0.01, 1)\\n plt.yscale(\\\"log\\\")\\n plt.tight_layout()\\n plt.savefig(outpath + \\\"inv_RV_lit_log.pdf\\\")\",\n \"def RMSE(obs, sim):\\n obs = obs.flatten()\\n sim = sim.flatten()\\n\\n return np.sqrt(np.mean((obs - sim) ** 2))\",\n \"def evaluate(self, X_test, y_test):\\n pipeline = run()\\n y_pred = pipeline.predict(X_test)\\n rmse = compute_rmse(y_pred, y_test)\\n print(rmse)\\n return rmse\",\n \"def _show_learning_rate():\\n fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(6.4 * 2, 4.8))\\n\\n # Visualize c_prime\\n c_prime_list = np.linspace(1, 100, num=11)\\n x_label = f\\\"c'\\\"\\n y_label = \\\"Minimum Clusters Size\\\"\\n title = \\\"\\\"\\n\\n ax = axes[0]\\n x_list = c_prime_list\\n\\n # MNIST\\n y_list = [161, 16, 14, 15, 20, 21, 24, 27, 30, 30, 35]\\n ax.plot(x_list, y_list, label=\\\"MNIST\\\")\\n\\n # Fashion MNIST\\n y_list = [63, 12, 12, 15, 18, 19, 22, 25, 26, 28, 30]\\n ax.plot(x_list, y_list, label=\\\"Fashion MNIST\\\")\\n\\n # 20 news groups\\n y_list = [1297, 724, 221, 80, 52, 51, 54, 54, 52, 60, 60]\\n ax.plot(x_list, y_list, label=\\\"Newsgroups\\\")\\n\\n ax.set_xlabel(x_label)\\n ax.set_ylabel(y_label)\\n ax.set_title(title)\\n ax.legend()\\n ax.set_yscale('log')\\n\\n # Visualize t0\\n t0_list = np.linspace(1, 100, num=11)\\n x_label = f\\\"t0\\\"\\n y_label = \\\"Minimum Clusters Size\\\"\\n title = \\\"\\\"\\n\\n ax = axes[1]\\n x_list = t0_list\\n\\n # MNIST\\n y_list = [16, 16, 16, 16, 16, 17, 16, 16, 16, 16, 16]\\n ax.plot(x_list, y_list, label=\\\"MNIST\\\")\\n\\n # Fashion MNIST\\n y_list = [12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12]\\n ax.plot(x_list, y_list, label=\\\"Fashion MNIST\\\")\\n\\n # 20 news groups\\n y_list = [765, 765, 767, 772, 772, 773, 789, 789, 793, 796, 799]\\n ax.plot(x_list, y_list, label=\\\"Newsgroups\\\")\\n\\n ax.set_xlabel(x_label)\\n ax.set_ylabel(y_label)\\n ax.set_title(title)\\n ax.legend()\\n ax.set_yscale('log')\\n\\n plt.show()\",\n \"def computeRmse(model, data, n):\\n print \\\"RESULT_data:%s \\\" % ((data.map(lambda x: (x[0], x[1]))).take(50))\\n predictions1 = model.predictAll(data.map(lambda x: (x[0], x[1])))\\n print \\\"RESULT1: %s\\\" % predictions1\\n predictionsAndRatings = predictions1.map(lambda x: ((x[0], x[1]), x[2])) \\\\\\n .join(data.map(lambda x: ((x[0], x[1]), x[2]))) \\\\\\n .values()\\n #print \\\"RESULT2: %s\\\" % predictions1.take(11)\\n return sqrt(predictionsAndRatings.map(lambda x: (x[0] - x[1]) ** 2).reduce(add) / float(n))\",\n \"def calculate_rmse(x_value, target_value, model_function, fit_parameters):\\n if len(target_value) != len(x_value):\\n raise ValueError(\\\"Value length not match\\\")\\n\\n n = len(fit_parameters)\\n if n == 1:\\n fit_A = fit_parameters[0]\\n fit_value = model_function(x_value, fit_A)\\n elif n == 2:\\n fit_A = fit_parameters[0]\\n fit_B = fit_parameters[1]\\n fit_value = model_function(x_value, fit_A, fit_B)\\n elif n == 3:\\n fit_A = fit_parameters[0]\\n fit_B = fit_parameters[1]\\n fit_C = fit_parameters[2]\\n fit_value = model_function(x_value, fit_A, fit_B, fit_C)\\n else:\\n raise ValueError(\\\"Function do not support that model\\\")\\n\\n RMSE = np.sqrt(sum((target_value - fit_value)**2)/len(target_value))\\n return RMSE\",\n \"def test_rr_se(results):\\n truese = np.asarray([2.09826858, 30.60745128, 108.51947421, 0.95693751,\\n 0.6564318])\\n test_se = results.params_se()\\n assert test_se == pytest.approx(truese)\",\n \"def plot_eos(eos_pk):\\n import pylab as pl\\n from aiida.orm import load_node\\n eos_calc=load_node(eos_pk)\\n eos_result=eos_calc.out.result\\n raw_data = eos_result.dict.eos_data\\n \\n data = []\\n for V, E, units in raw_data:\\n data.append((V,E))\\n \\n data = np.array(data)\\n params, covariance = fit_birch_murnaghan_params(data[:,0],data[:,1])\\n \\n vmin = data[:,0].min()\\n vmax = data[:,0].max()\\n vrange = np.linspace(vmin, vmax, 300)\\n\\n pl.plot(data[:,0],data[:,1],'o')\\n pl.plot(vrange, birch_murnaghan(vrange, *params))\\n\\n pl.xlabel(\\\"Volume (ang^3)\\\")\\n # I take the last value in the list of units assuming units do not change\\n pl.ylabel(\\\"Energy ({})\\\".format(units))\\n pl.show()\",\n \"def plotFittingResults(self):\\n _listFitQ = [tmp.getValue() for tmp in self.getDataOutput().getScatteringFitQ()]\\n _listFitValues = [tmp.getValue() for tmp in self.getDataOutput().getScatteringFitValues()]\\n _listExpQ = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataQ()]\\n _listExpValues = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataValues()]\\n\\n #_listExpStdDev = None\\n #if self.getDataInput().getExperimentalDataStdDev():\\n # _listExpStdDev = [tmp.getValue() for tmp in self.getDataInput().getExperimentalDataStdDev()]\\n #if _listExpStdDev:\\n # pylab.errorbar(_listExpQ, _listExpValues, yerr=_listExpStdDev, linestyle='None', marker='o', markersize=1, label=\\\"Experimental Data\\\")\\n # pylab.gca().set_yscale(\\\"log\\\", nonposy='clip')\\n #else: \\n # pylab.semilogy(_listExpQ, _listExpValues, linestyle='None', marker='o', markersize=5, label=\\\"Experimental Data\\\")\\n\\n pylab.semilogy(_listExpQ, _listExpValues, linestyle='None', marker='o', markersize=5, label=\\\"Experimental Data\\\")\\n pylab.semilogy(_listFitQ, _listFitValues, label=\\\"Fitting curve\\\")\\n pylab.xlabel('q')\\n pylab.ylabel('I(q)')\\n pylab.suptitle(\\\"RMax : %3.2f. Fit quality : %1.3f\\\" % (self.getDataInput().getRMax().getValue(), self.getDataOutput().getFitQuality().getValue()))\\n pylab.legend()\\n pylab.savefig(os.path.join(self.getWorkingDirectory(), \\\"gnomFittingResults.png\\\"))\\n pylab.clf()\",\n \"def rmse(actual, predicted):\\n rms = (actual-predicted)**2\\n\\n # Returning the sqaure root of the root mean square\\n return float(np.sqrt(rms.mean()))\",\n \"def plot_errors(self):\\n\\n plt.title(\\\"Prediction Error\\\")\\n plt.plot(self.errors)\\n plt.ylabel(\\\"MSE (Mean Squared Error)\\\")\\n plt.xlabel(\\\"Iteration\\\")\\n plt.show()\",\n \"def variations_plot(S0, K, B, T, N, u, d, q, M, barrier_type, option,\\n MC_runs, price_tree):\\n x_values = []\\n pi_M = []\\n pi_M_RMSE = []\\n for i in range(1, MC_runs, 1):\\n Mi = M * i\\n x_values.append([Mi])\\n paths = sample_paths(S0, N, u, d, q, Mi)\\n p_valid, p_invalid, p_counts = split_paths(paths, B, K,\\n barrier_type, option)\\n if option == 'Call':\\n payoffs = np.maximum(0, p_counts[:, -1] - K) * np.exp(-1 * r * T)\\n elif option == 'Put':\\n payoffs = np.maximum(0, K - p_counts[:, -1]) * np.exp(-1 * r * T)\\n payoffs = list(payoffs)\\n while len(payoffs) < Mi:\\n payoffs.append([0])\\n mean_payoff = np.mean(payoffs)[0]\\n pi_M.append(mean_payoff)\\n RMSE = np.sqrt(np.var(payoffs, ddof=1)) / np.sqrt(Mi)\\n pi_M_RMSE.append(RMSE[0])\\n\\n # plotting\\n plt.figure(figsize=(8, 6))\\n plt.subplot(2, 1, 1)\\n plt.plot(x_values, price_tree - 1.96 * np.array(pi_M_RMSE), '--', c='grey')\\n plt.plot(x_values, price_tree + 1.96 * np.array(pi_M_RMSE), '--', c='grey')\\n plt.plot(x_values, pi_M, 'o', label='price via MC')\\n plt.plot(x_values, [price_tree] * len(x_values), '-', lw=3,\\n label='price via tree')\\n plt.legend()\\n plt.title('Monte Carlo price, for increasing number of paths')\\n plt.ylabel('Expected Value')\\n # The following will plot the root mean square error\\n plt.subplot(2, 1, 2)\\n plt.plot(x_values, pi_M_RMSE, '-')\\n plt.xlabel('number of paths')\\n plt.ylabel('Root Mean Square Error')\\n # plt.savefig('MonteCarlo_variation.png', transparent=True)\\n plt.show()\",\n \"def plot_candidate_design_rmse(\\n response: str, num_pairs: int,\\n results: pd.DataFrame) -> Dict[Tuple[float, float], plt.Axes]:\\n budget_list = results['budget'].unique()\\n iroas_list = results['iroas'].unique()\\n axes_dict = {}\\n for budget in budget_list:\\n for iroas in iroas_list:\\n result = results[(results['budget'] == budget)\\n & (results['iroas'] == iroas)].reset_index(drop=True)\\n hlines = range(\\n 0,\\n int(max(max(result['rmse']), max(result['rmse_cost_adjusted']))) + 1)\\n\\n delta = (max(result['rmse']) - min(result['rmse'])) * 0.05\\n\\n fig = plt.figure(figsize=(20, 10))\\n ax = fig.add_subplot(1, 1, 1)\\n ax.plot(\\n result['pair_index'], result['rmse'], 'blue', label='RMSE')\\n ax.plot(\\n result['pair_index'],\\n result['rmse_cost_adjusted'],\\n 'red',\\n label='Cost adjusted RMSE')\\n ax.set_xlim(\\n min(result['pair_index']) - 1,\\n max(result['pair_index']) + 1)\\n ax.set_ylim(\\n min(result.rmse) - delta,\\n max(result.rmse_cost_adjusted) + delta)\\n ax.legend()\\n ax.hlines(\\n y=hlines,\\n xmin=min(result['pair_index']),\\n xmax=max(result['pair_index']),\\n colors='gray',\\n linestyles='dashed')\\n for _, row in result.iterrows():\\n ax.text(\\n row.pair_index + 1, row.rmse + delta,\\n '{}'.format(\\n util.human_readable_number(row.experiment_response)))\\n ax.set_xlabel('Pairing number')\\n ax.set_ylabel('RMSE')\\n ax.set_title(\\n f'''RMSE of iROAS w.r.t. {response} (total pairs: {num_pairs})''')\\n axes_dict[(budget, iroas)] = fig\\n plt.close()\\n\\n return axes_dict\",\n \"def plot_price_evolution_for_nr_run(nr_log):\\n plt.figure(figsize=(10, 5))\\n\\n plt.plot(nr_log['time'], nr_log['virtual_price'], '.', label='NR')\\n\\n plt.legend()\\n\\n plt.grid()\\n\\n plt.title('Network Relaxation run - Grid price evolution')\\n\\n plt.xlabel('time [s]')\\n\\n plt.ylabel('price [$]')\\n\\n plt.show()\",\n \"def cross_validation_visualization(lambdas, loss_train, loss_test):\\n plt.semilogx(lambdas, loss_train, marker=\\\".\\\", color='b', label='train error')\\n plt.semilogx(lambdas, loss_test, marker=\\\".\\\", color='r', label='test error')\\n plt.xlabel(\\\"lambda\\\")\\n plt.ylabel(\\\"rmse\\\")\\n plt.title(\\\"cross validation\\\")\\n plt.legend(loc=2)\\n plt.grid(True)\\n plt.savefig(\\\"cross_validation_mse\\\")\",\n \"def plot_test_vs_validation_set(output_name, C, sigma, M, xlim=None, ylim=None, xticks=None, yticks=None):\\n import matplotlib.pyplot as plt\\n plt.ioff()\\n plt.style.use('./latex-paper.mplstyle')\\n plt.figure()\\n ax = plt.axes()\\n ax.yaxis.grid(True)\\n\\n d = pickler.load(f'categorical_K2_C{C}_sigma{sigma:.2f}_M{M}'.replace('.','_'))\\n x_values = [x.n_train for x in d.xs]\\n plt.plot(x_values, d.results[:,0], 'C0-', label=r'$\\\\mathrm{e}_{\\\\mathrm{val}}(m=n)$')\\n plt.plot(x_values, d.results[:,1], 'C1-', label=r'$\\\\mathrm{e}_{\\\\mathrm{gen}}(m=n)$')\\n\\n d = pickler.load(f'categorical_LOO_C{C}_sigma{sigma:.2f}_M{M}'.replace('.','_'))\\n x_values = [x.n_train for x in d.xs]\\n plt.plot(x_values, d.results[:,0], 'C0--', label=r'$\\\\mathrm{e}_{\\\\mathrm{val}}(m=1)$')\\n plt.plot(x_values, d.results[:,1], 'C1--', label=r'$\\\\mathrm{e}_{\\\\mathrm{gen}}(m=1)$')\\n\\n plt.xlabel('n')\\n plt.ylabel('MSE')\\n if xlim is not None:\\n plt.xlim(xlim)\\n if ylim is not None:\\n plt.ylim(ylim)\\n if xticks is not None:\\n plt.xticks(xticks)\\n if yticks is not None:\\n plt.yticks(yticks)\\n \\n plt.legend(loc='best')\\n simulations_framework.save_figure(output_name + f'_reps{d.n_repetitions}')\",\n \"def plot_observed_predicted(y_data, y_predict, ols_line=False, model_fit=None, figsize=(15, 10), save=False, end_name_fig='', folder='Charts'): \\r\\n\\r\\n end_name_fig = end_name_fig + '_' if end_name_fig is not None else ''\\r\\n\\r\\n fig, ax = plt.subplots(figsize=figsize)\\r\\n ax.scatter(y_data, y_predict)\\r\\n \\r\\n if ols_line == False:\\r\\n ax.plot([y_data.min(), y_data.max()], [y_data.min(), y_data.max()], 'k--', lw=4)\\r\\n\\r\\n else:\\r\\n line_fit = sm.OLS(y_data, sm.add_constant(y_predict, prepend=True)).fit()\\r\\n abline_plot(model_results=line_fit, ax=ax)\\r\\n\\r\\n ax.set_title('Predicted vs Observed')\\r\\n ax.set_ylabel('Observed values')\\r\\n ax.set_xlabel('Predicted values')\\r\\n\\r\\n if save == True:\\r\\n plt.savefig(folder + '/predict_observed_' + end_name_fig + '.png')\\r\\n\\r\\n if model_fit is not None:\\r\\n \\r\\n fig, ax = plt.subplots(figsize=figsize)\\r\\n ax.scatter(y_predict, model_fit.resid_pearson)\\r\\n ax.hlines(0, 0, 1)\\r\\n ax.set_xlim(0, 1)\\r\\n ax.set_title('Residual Dependence Plot')\\r\\n ax.set_ylabel('Pearson Residuals')\\r\\n ax.set_xlabel('Fitted values') \\r\\n\\r\\n if save == True:\\r\\n plt.savefig(folder + '/pearson_residuals_' + end_name_fig + '.png')\\r\\n\\r\\n\\r\\n fig, ax = plt.subplots(figsize=figsize)\\r\\n res_dev_residuals = model_fit.resid_deviance.copy()\\r\\n res_dev_residuals_std = stats.zscore(res_dev_residuals)\\r\\n ax.hist(res_dev_residuals_std, bins=25)\\r\\n ax.set_title('Histogram of standardized deviance residuals')\\r\\n\\r\\n if save == True:\\r\\n plt.savefig(folder + '/standard_deviance_residuals_' + end_name_fig + '.png')\\r\\n\\r\\n graphics.gofplots.qqplot(res_dev_residuals, line='r')\\r\\n\\r\\n if save == True:\\r\\n plt.savefig(folder + '/gofplot_' + end_name_fig + '.png')\",\n \"def plot_regression(e_predict, e_true, ax=None, label='', e_max=0.5):\\n ax = ax or plt.gca()\\n ax.scatter(e_true, e_predict, lw=0, alpha=0.5, s=10)\\n ax.set_xlabel('True shear')\\n ax.set_ylabel('Predicted shear')\\n ax.set_xlim(0, e_max)\\n ax.set_ylim(0, e_max)\\n ax.plot([0, e_max], [0, e_max], 'r--')\\n R2 = sklearn.metrics.r2_score(e_true, e_predict)\\n ax.text(0.05, 0.9, f'{label}$R^2 = {R2:.2f}$',\\n transform=ax.transAxes, fontsize=16, color='r')\",\n \"def rmse(datasets):\\n\\n rmse = []\\n for k,v in datasets.items():\\n reg = linregress(v.X,v.Y)\\n pred = []\\n \\n for i in range(v.shape[0]):\\n pred.append((v.loc[i].X*reg.slope)+reg.intercept)\\n pred = pd.Series(pred)\\n \\n rmse.append(np.sqrt(np.mean((pred-v.Y)**2)))\\n \\n return pd.Series(rmse)\",\n \"def plot(self, figshow=None, figsave=None, figname=None):\\n self.rv()\\n fig, ax = plt.subplots(1,1, figsize=(8,6))\\n ax.tick_params(which='major', labelsize=20, direction='in', top=True, right=True, length=6, width=1.4)\\n ax.tick_params(which='minor', labelsize=20, direction='in', top=True, right=True, length=3, width=1.4)\\n for axis in ['top','bottom','left','right']: ax.spines[axis].set_linewidth(2.0)\\n bins = np.linspace(min(self.mcsigmarv)*0.99, max(self.mcsigmarv)*1.01, num=100)\\n posty, postx, patches = ax.hist(self.mcsigmarv, bins=bins, ec='b', color='gray', density=True)\\n ax.plot([self.sigmarv, self.sigmarv], [0, max(posty)], 'r')\\n ax.plot([self.sigmarv+self.sigmarvperr, self.sigmarv+self.sigmarvperr], [0, max(posty)], '--r')\\n ax.plot([self.sigmarv-self.sigmarvmerr, self.sigmarv-self.sigmarvmerr], [0, max(posty)], '--r')\\n minorLocator = AutoMinorLocator()\\n ax.xaxis.set_minor_locator(minorLocator)\\n minorLocator = AutoMinorLocator()\\n ax.yaxis.set_minor_locator(minorLocator)\\n ax.set_xlabel(r'$\\\\sigma_{\\\\rm rms, rv}\\\\ [\\\\rm m/s]$', fontsize=20)\\n ax.set_ylabel('Probability Density', fontsize=20)\\n ax.annotate(r'$\\\\sigma_{\\\\rm rms,\\\\ RV}$', xy=(0.45, 0.9), xycoords=\\\"axes fraction\\\", fontsize=18)\\n ax.annotate(r'= {:.2f} +{:.2f} -{:.2f} [m/s]'.format(self.sigmarv, self.sigmarvperr, self.sigmarvmerr), xy=(0.58, 0.9), xycoords=\\\"axes fraction\\\", fontsize=15)\\n plt.tight_layout()\\n if figsave==True: plt.savefig(figname) if figname is not None else plt.savefig('rvjitter.png')\\n if figshow==True: plt.show()\\n plt.close('all')\\n return self.sigmarv, self.sigmarvperr, self.sigmarvmerr, self.mcsigmarv\",\n \"def rmse(a,b):\\n \\n ### Import modules\\n import numpy as np\\n \\n ### Calculate RMSE\\n rmse_stat = np.sqrt(np.mean((a - b)**2))\\n \\n return rmse_stat\",\n \"def compute_rmse(y, tx, w):\\n return np.sqrt(2*compute_mse(y,tx,w))\",\n \"def fit(self, plot_loss=True):\\n adam = optim.Adam(self.learning_rate)\\n self.svi = SVI(\\n self.vae_model, \\n self.vae_guide, \\n adam, \\n Trace_ELBO()\\n )\\n # encoder_nn = self.vae_encoder()\\n # decoder_nn = self.vae_decoder()\\n rng_key, rng_key_samp, rng_key_init = random.split(self.rng_key, 3)\\n\\n self.gp_predictive = Predictive(self.gp.sample, num_samples=self.batch_size)\\n\\n # initialise with a sample batch\\n sample_batch = self.gp_predictive(rng_key=rng_key_samp, x=self.x)\\n \\n svi_state = self.svi.init(rng_key_init, sample_batch['y'])\\n test_loss_list = []\\n\\n for i in range(self.num_epochs):\\n rng_key, rng_key_train, rng_key_test = random.split(rng_key, 3)\\n t_start = time.time()\\n\\n _, svi_state = self.epoch_train(rng_key_train, svi_state)\\n test_loss = self.eval_test(rng_key_test, svi_state)\\n test_loss_list += [test_loss]\\n\\n print(\\n \\\"Epoch {}: loss = {} ({:.2f} s.)\\\".format(\\n i, test_loss, time.time() - t_start\\n )\\n )\\n \\n if np.isnan(test_loss): break\\n\\n if plot_loss:\\n plt.figure()\\n plt.plot(np.arange(0, self.num_epochs, 1)[0:len(test_loss_list)], test_loss_list)\\n plt.xlabel(\\\"epochs\\\")\\n plt.ylabel(\\\"test error\\\")\\n plt.savefig('src/test/plots/vae_lost.png')\\n plt.show()\\n plt.close()\\n\\n # return optimal parameters for decoder\\n return self.svi.get_params(svi_state)[\\\"decoder$params\\\"]\",\n \"def compute_rmse(y, tx, w):\\n return np.sqrt(2 * compute_mse(y, tx, w))\",\n \"def evaluate(self, X_test, y_test):\\n y_pred_train = self.pipeline.predict(self.X)\\n mse_train = mean_squared_error(self.y, y_pred_train)\\n rmse_train = np.sqrt(mse_train)\\n \\n self.mlflow_log_metric('rmse_train', rmse_train)\\n \\n y_pred_test = self.pipeline.predict(X_test)\\n mse_test = mean_squared_error(y_test, y_pred_test)\\n rmse_test = np.sqrt(mse_test)\\n self.mlflow_log_metric('rmse_test', rmse_test)\\n \\n return (round(rmse_train, 3) ,round(rmse_test, 3))\",\n \"def plot_SS(H,E,C,nframes,nres,outdir,name_mod):\\n\\tH_av = np.zeros(nres) ; H_err = np.zeros(nres) \\n\\tE_av = np.zeros(nres) ; E_err = np.zeros(nres) \\n\\tC_av = np.zeros(nres) ; C_err = np.zeros(nres) \\n\\tfor ind in range(nres):\\n\\t\\tH_av[ind] = sum(H[ind,:])/nframes ; H_err[ind] = np.std(H[ind,:])\\n\\t\\tE_av[ind] = sum(E[ind,:])/nframes ; E_err[ind] = np.std(E[ind,:])\\n\\t\\tC_av[ind] = sum(C[ind,:])/nframes ; C_err[ind] = np.std(C[ind,:])\\n\\n\\tplt.clf()\\n\\tplt.plot(H_av,label='Helix',c='r') ; plt.errorbar(range(nres), H_av,yerr=H_err/(np.sqrt(nframes)-1), fmt='o',color='r')\\n\\tplt.plot(E_av,label='Beta Sheet',c='b') ; plt.errorbar(range(nres), E_av,yerr=E_err/(np.sqrt(nframes)-1), fmt='o',color='b')\\n\\tplt.plot(C_av,label='Coil',c='k') ; plt.errorbar(range(nres), C_av,yerr=C_err/(np.sqrt(nframes)-1), fmt='o',color='k')\\n\\tplt.legend(loc=1)\\n\\tplt.savefig(outdir+\\\"SS\\\" + name_mod + \\\".png\\\")\\n\\tnp.savetxt(outdir+\\\"SS_H_av\\\" + name_mod + \\\".npy\\\",[H_av,H_err])\\n\\tnp.savetxt(outdir+\\\"SS_E_av\\\" + name_mod + \\\".npy\\\",[E_av,E_err])\\n\\tnp.savetxt(outdir+\\\"SS_C_av\\\" + name_mod + \\\".npy\\\",[C_av,C_err])\\n\\treturn None\",\n \"def plot_scan_error(dataframe, **kwargs):\\n\\n # Determine number of cases\\n nr = len(set(dataframe[dataframe._column_names['case']].values))\\n\\n # Reshape in (N,Sa*Sb) matrix\\n if kwargs.get('absolute', True):\\n data = abs(dataframe['error']).values.reshape(dataframe.Sa * dataframe.Sb, nr)\\n else:\\n data = dataframe['error'].values.reshape(dataframe.Sa * dataframe.Sb, nr)\\n\\n # Set upper and lower tolerance limit if not set\\n ltol = kwargs.get('ltol', numpy.min(data))\\n utol = kwargs.get('utol', numpy.max(data))\\n\\n # Calculate Root Mean Squared Error\\n scanmatrix = numpy.zeros((dataframe.Sa, dataframe.Sb))\\n for i in range(0, nr):\\n scanmatrix = scanmatrix + numpy.power(data[:, i].reshape(dataframe.Sa, dataframe.Sb), 2)\\n scanmatrix = numpy.sqrt(scanmatrix / nr)\\n scanmatrix[scanmatrix <= ltol] = ltol\\n scanmatrix[scanmatrix >= utol] = utol\\n\\n # Define plotting variables\\n plotvars = {\\n 'title': r'LIE $\\\\alpha$ and $\\\\beta$ parameter scan for {0} cases'.format(nr),\\n 'subtitle': 'Lower tolerance: {0:.2f}, upper tolerance: {1:.2f}'.format(ltol, utol),\\n 'cblabel': 'RMS error (kJ/mol)',\\n 'ylabel': r'$\\\\alpha$',\\n 'xlabel': r'$\\\\beta$'\\n }\\n plotvars.update(kwargs)\\n\\n logger.info(\\\"Create dG RMSe matrix plot for Alpha/Beta parameter scan results\\\")\\n logger.info(\\n \\\"Create matrix plot using lower tolerance (ltol) of {0:.3f} and upper rolerance (utol) of {1:.3f}\\\".format(ltol,\\n utol))\\n\\n # Prepare the plot\\n return plot_matrix(scanmatrix,\\n xaxis=dataframe.beta_scan_range,\\n yaxis=dataframe.alpha_scan_range,\\n **plotvars)\",\n \"def plot_loss(training_errors, validation_errors):\\n plt.xscale('Log')\\n plt.xlabel('Epochs')\\n plt.ylabel('Mean Actual Error')\\n plt.plot(training_errors, label = \\\"Training Error\\\", \\\\\\n color = 'blue')\\n plt.plot(validation_errors, label = \\\"Validation Error\\\", \\\\\\n color = 'red')\\n plt.legend()\\n # Saves plot automatically, adjust filename as needed.\\n plt.savefig('reservoir_05whdens_100h_7spec_test_3.png')\\n plt.show()\",\n \"def calculate_rmse(p, q, limits, dx=0.01):\\n if p.shape != q.shape:\\n raise ValueError('Cannot calculate RMSE between two ensembles with different shapes')\\n\\n # Make a grid from the limits and resolution\\n grid = _calculate_grid_parameters(limits, dx)\\n\\n # Evaluate the functions on the grid\\n pe = p.gridded(grid.grid_values)[1]\\n qe = q.gridded(grid.grid_values)[1]\\n\\n # Calculate the RMS between p and q\\n rms = array_metrics.quick_rmse(pe, qe, grid.cardinality)# np.sqrt(dx * np.sum((pe - qe) ** 2))\\n\\n return rms\",\n \"def plot_results(results_path, history, mode=\\\"loss\\\"):\\n\\tif mode == \\\"loss\\\":\\n\\t\\tplt.figure(figsize=(10, 10))\\n\\t\\tplt.plot(history[mode][1:])\\n\\t\\tplt.plot(history[\\\"val_\\\" + mode][1:])\\n\\t\\tplt.title(\\\"Model MSE \\\" + mode)\\n\\t\\tplt.xlabel(\\\"# Epochs\\\")\\n\\t\\tplt.ylabel(mode + \\\" score\\\")\\n\\t\\tplt.legend([\\\"train\\\", \\\"Validation\\\"], loc=\\\"upper right\\\", fontsize=14)\\n\\t\\tplt.savefig(results_path)\\n\\t\\tplt.show()\\n\\telif mode == \\\"metric\\\":\\n\\t\\tmetric_name = \\\"rmse\\\"\\n\\t\\tplt.figure(figsize=(10, 10))\\n\\t\\tplt.plot(history[metric_name][1:])\\n\\t\\tplt.plot(history[\\\"val_\\\" + metric_name][1:])\\n\\t\\tplt.title(\\\"Model \\\" + metric_name + \\\" metric\\\")\\n\\t\\tplt.xlabel(\\\"# Epochs\\\")\\n\\t\\tplt.ylabel(metric_name + \\\" score\\\")\\n\\t\\tplt.legend([\\\"train\\\", \\\"Validation\\\"], loc=\\\"upper right\\\", fontsize=14)\\n\\t\\tplt.savefig(results_path)\\n\\t\\tplt.show()\\n\\telse:\\n\\t\\tprint(\\\"A valid mode must be selected! Valid modes: 'loss' or 'metric'\\\")\",\n \"def get_convergence_plot(self):\\n fig, ax = plt.subplots()\\n first_episode = self.get_convergence_episode()\\n\\n values = self.stats['return_stats']['episode_totals']\\n ax.plot(np.arange(len(values)), values, color='steelblue', lw=2, alpha=.9,\\n label='Return')\\n ax.axvline(first_episode, color='seagreen', lw=2, label='Converged')\\n ax.set_xlim(left=0, right=first_episode * 2)\\n\\n ax.set_title('Normalized regret = {:.3f}'.format(\\n self.get_normalized_regret()))\\n ax.legend()\\n ax.set_ylabel('Return')\\n ax.set_xlabel('Episode')\\n return fig\",\n \"def EPI():\\n TE = np.array([4.22, 33.81, 63.39, 92.98, 122.6, 152.2, 181.7, 211.3, 240.9, 270.5])\\n upper_left = np.array([697.3, 367.0, 217.5, 115.8, 51.8, 23.2, 14.8, 8.7, 6.1, 4.6])\\n center = np.array([1110.2, 907.8, 813.6, 745.2, 692.8, 637.0, 564.9, 521.0, 450.2, 401.6])\\n lower_right = np.array([723.0, 419.2, 224.1, 126.4, 61.8, 32.4, 15.1, 8.8, 3.9, 3.8])\\n upper_center = np.array([782.2, 499.4, 279.5, 154.5, 88.6, 58.2, 43.8, 38.2, 38.2, 36.0])\\n\\n area = [upper_left, center, upper_center, lower_right]\\n colors = [\\\"#1f77b4\\\", \\\"#ff7f0e\\\", \\\"#2ca02c\\\", \\\"#d62728\\\"]\\n name = [\\\"Upper left area\\\", \\\"Center area\\\", \\\"Up center area\\\", \\\"Lower right area\\\"]\\n x_new = np.linspace(4.22, 270.5, 10000)\\n for i, j, k in zip(area, colors, name):\\n popt, _ = curve_fit(M_xy, TE, i, p0=np.array([200, 300]))\\n M0, T2 = popt[0], popt[1]\\n y_new = M_xy(x_new, M0, T2)\\n plt.scatter(TE, i)\\n plt.plot(x_new, y_new, \\\"--\\\", c=j, label=\\\"Fit: %s\\\" % k + f\\\", $T_2$={T2:.2f}\\\")\\n plt.legend(loc=\\\"best\\\")\\n plt.grid()\\n plt.ylabel(\\\"Mean Signal Intensity\\\")\\n plt.xlabel(\\\"TE [ms]\\\")\\n plt.show()\",\n \"def mplot(m, xlabel='', ylabel='', title='', custom=(7,7)):\\n lag = ps.lag_spatial(m.w, m.z)\\n fit = ps.spreg.OLS(m.z[:, None], lag[:,None])\\n\\n # Customize plot\\n fig = plt.figure(figsize=custom)\\n ax = fig.add_subplot(111)\\n\\n ax.set_xlabel(xlabel)\\n ax.set_ylabel(ylabel)\\n fig.suptitle(title)\\n\\n ax.scatter(m.z, lag, s=60, color='k', alpha=.6)\\n ax.plot(lag, fit.predy, color='r')\\n\\n ax.axvline(0, alpha=0.5)\\n ax.axhline(0, alpha=0.5)\\n\\n return fig\",\n \"def plot_beam_exp_rms(beam_exp_rms, beam_nums, sbid, fig_folder, closepack=False):\\n\\n title = 'Expected RMS for SBID {}'.format(sbid)\\n plot_name = 'Exp_RMS.png'\\n saved_fig = fig_folder+'/'+plot_name\\n\\n params = {'axes.labelsize': 10,\\n 'axes.titlesize': 10,\\n 'font.size':10}\\n\\n mpl.rcParams.update(params)\\n\\n num_interleaves = len(beam_exp_rms) // 36\\n fig = plt.figure(figsize=(18, 12))\\n axes = []\\n if len(beam_exp_rms) > 36:\\n for i in range(1,num_interleaves+1):\\n ax = fig.add_subplot(2,2,i)\\n axes.append(ax)\\n else:\\n ax = fig.add_subplot()\\n axes.append(ax)\\n\\n beam_xpos, beam_ypos = beam_positions(closepack=closepack)\\n vmin = round(np.min(beam_exp_rms), 3)\\n vmax = round(np.minimum(vmin*2,np.max(beam_exp_rms)), 3)\\n norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)\\n\\n for i in range(num_interleaves):\\n print (\\\"Interleave\\\", i)\\n ax = axes[i]\\n for j in range(36):\\n bnum = beam_nums[j]\\n b_idx = i*36+bnum\\n ax.scatter([beam_xpos[j]], [beam_ypos[j]], s=1500, c=[beam_exp_rms[b_idx]], cmap='GnBu', edgecolors='black', vmin=vmin, vmax=vmax)\\n ax.text(beam_xpos[j], beam_ypos[j], bnum)\\n\\n ax.set_xlim(0,0.7)\\n ax.set_ylim(0.1,1.3)\\n ax.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\\n ax.set_title(\\\"Expected RMS for Interleave \\\" + chr(ord('A')+i))\\n\\n cb = plt.colorbar(mpl.cm.ScalarMappable(cmap='GnBu', norm=norm), ax=ax)\\n cb.set_label('mJy / beam')\\n cb.ax.tick_params(labelsize=10)\\n\\n plt.suptitle(title)\\n plt.savefig(saved_fig, bbox_inches='tight')\\n plt.close()\\n print (saved_fig, plot_name)\\n\\n return saved_fig\",\n \"def plot():\\n xvals = np.arange(-50, 250, step=0.1)\\n\\n fig = plt.figure()\\n plt.suptitle(\\\"Gaussian with smooth transition to power law\\\")\\n\\n A0vals = [10, 11]\\n avals = [5*10**-3, 10**-3, 5*10**-4]\\n ttvals = [10., 50., 100.]\\n cvals = [-0.1, -0.9, -5./3., -4.]\\n offset = [-30, 0.0, 30]\\n\\n paramvals = [A0vals, avals, ttvals,cvals, offset]\\n titles, labels = return_parameter_names()\\n\\n nplots = len(paramvals)\\n\\n for i in range(nplots):\\n plt.subplot(nplots, 1, i+1)\\n vals = paramvals[i]\\n for j in range(len(vals)):\\n pset = list(default())\\n pset[i] = vals[j]\\n yvals=[]\\n ypower=[]\\n ypeak=[]\\n for x in xvals:\\n yvals.append(fitfunc(x, pset))\\n ypeak.append(logpeak(x,pset))\\n if x > 0:\\n ypower.append(logpowerlaw(x,pset))\\n label = labels[i] + \\\"=\\\"+str(vals[j])\\n plt.plot(xvals, yvals, label = label)\\n\\n plt.title(titles[i])\\n plt.legend()\\n\\n fig.set_size_inches(15, 30)\\n plt.savefig(\\\"graphs/misc/lightcurve_models.pdf\\\")\\n plt.close()\",\n \"def calc_rmse(pred_target, val, time_slot_length):\\n pred_data = pred_target.data.loc[:, 1] # Need to add the data column in the CSVFileManager itself, rather than\\n # hardcore values\\n pred_length = pred_data.size(0)\\n rmse_list = []\\n deviation_list = []\\n for j in range(0, pred_length-time_slot_length):\\n se = 0\\n start_time_slot = j\\n end_time_slot = start_time_slot + time_slot_length\\n timed_pred_data = pred_data.iloc[start_time_slot:end_time_slot, 1]\\n for i in range(0, time_slot_length):\\n se += math.pow((timed_pred_data[i]-val), 2)\\n rmse = math.sqrt((se/time_slot_length))\\n rmse_list.append(rmse)\\n\\n # Calculate the optimal rmse value, and the deviation of other rmse values from the optimal value\\n min_rmse = min(rmse_list)\\n for j in range(0, pred_length - time_slot_length):\\n deviation_list.append((abs(min_rmse - rmse_list[j])/min_rmse)*100)\\n return deviation_list, rmse_list\",\n \"def energies():\\n # Hardcoded initial values\\n numsteps = 10000\\n time_max = 1\\n # Running the calculation in the solver class using the velocity verlet method\\n # for better accuracy.\\n verlet = solver(input_matrix, 'verlet', time_max, numsteps)\\n output_matrix, KE, PE, AM = verlet.main()\\n # Creating a simple time axis for plotting\\n x = np.linspace(0, 1, numsteps+1)\\n\\n # Plotting kinetic energy over time\\n plt.figure(1, figsize=(10, 10))\\n plt.plot(x, KE)\\n plt.suptitle('Total kinetic energy in the Earth-Sun system.', fontsize=24)\\n plt.xlabel('time [yr]', fontsize=16)\\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\\n plt.legend(['KE'])\\n\\n # Plotting potential energy over time\\n plt.figure(2, figsize=(10, 10))\\n plt.plot(x, PE)\\n plt.suptitle('Total potential energy in the Earth-Sun system.', fontsize=24)\\n plt.xlabel('time [yr]', fontsize=16)\\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\\n plt.legend(['PE'])\\n\\n # Plotting total energy against time\\n plt.figure(3, figsize=(10, 10))\\n plt.plot(x, PE+KE)\\n plt.suptitle('Total energy in the Earth-Sun system.', fontsize=24)\\n plt.xlabel('time [yr]', fontsize=16)\\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\\n plt.legend(['KE+PE'])\\n\\n # Plotting angular momentum against time. print the amplitude to terminal\\n amplitude = max(AM)-min(AM)\\n print('Amplitude of angular momentum during 1 year: %g[AU²/yr²]' %(amplitude))\\n plt.figure(4, figsize=(10, 10))\\n plt.plot(x, AM)\\n plt.suptitle('Total angular momentum in the Earth-Sun system.', fontsize=24)\\n plt.xlabel('time [yr]', fontsize=16)\\n plt.ylabel('energy [AU²/yr²]', fontsize=16)\\n plt.legend(['AM'])\\n\\n # Plotting the kinetic, potential and total energy against time to see\\n # how great the variations are\\n plt.figure(5, figsize=(10, 10))\\n plt.plot(x, PE, x, KE, x, KE+PE)\\n plt.suptitle('Total energy in the Earth-Sun system.', fontsize=24)\\n plt.xlabel('time [yr]', fontsize=16)\\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\\n plt.legend(['PE', 'KE', 'KE+PE'])\\n plt.show()\",\n \"def plot_LvsL(modeldata,line1='CIV1548',line2='CIII1908',plotname='./TESTPLOT.pdf',\\n Zgas=False,logU=False,xid=0.3,nh=100,COratio=0.38,Mcutoff=100,\\n logx=False,logy=False,logp1=False,logp2=False,fixxrange=False,fixyrange=False,\\n showobs=None,noobserr=False,verbose=True):\\n NFalse = 0\\n freeparam = []\\n inforstr = \\\"\\\"\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n legenddic = {}\\n legenddic['Zgas'] = r'Z$_\\\\textrm{gas}$'\\n legenddic['logUs'] = r'log$_\\\\textrm{10}$(U)'\\n legenddic['xid'] = r'$\\\\xi_\\\\textrm{d}$'\\n legenddic['nh'] = r'n$_\\\\textrm{H}$ / [cm$^3$]'\\n legenddic['COCOsol'] = r'C/O / [C/O]$_\\\\textrm{sun}$'\\n legenddic['mup'] = r'M$_\\\\textrm{cut IMF}$ / [M$_\\\\textrm{sun}]$'\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not Zgas:\\n Zgasrange = [0.0,1.0]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' Zgas:vary, '\\n freeparam.append('Zgas')\\n else:\\n Zgasrange = [Zgas-1e-6,Zgas+1e-6]\\n inforstr = inforstr+' '+legenddic['Zgas']+'='+str(Zgas)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not logU:\\n logUrange = [-5.0,0.0]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' logU:vary, '\\n freeparam.append('logUs')\\n else:\\n logUrange = [logU-0.1,logU+0.1]\\n inforstr = inforstr+' '+legenddic['logUs']+'='+str(logU)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not xid:\\n xidrange = [0.0,0.6]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' xid:vary, '\\n freeparam.append('xid')\\n else:\\n xidrange = [xid-0.01,xid+0.01]\\n inforstr = inforstr+' '+legenddic['xid']+'='+str(xid)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not nh:\\n nhrange = [0.0,1.0e6]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' nH:vary, '\\n freeparam.append('nh')\\n else:\\n nhrange = [nh-1.0,nh+1.0]\\n inforstr = inforstr+' '+legenddic['nh']+'='+str(nh)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not COratio:\\n COratiorange = [0.0,2.0]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' C/O:vary, '\\n freeparam.append('COCOsol')\\n else:\\n COratiorange = [COratio-0.001,COratio+0.001]\\n inforstr = inforstr+' '+legenddic['COCOsol']+'='+str(COratio)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not Mcutoff:\\n Mcutoffrange = [0.0,400.0]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' Mcutoff:vary, '\\n freeparam.append('mup')\\n else:\\n Mcutoffrange = [Mcutoff-1.0,Mcutoff+1.0]\\n inforstr = inforstr+' '+legenddic['mup']+'='+str(Mcutoff)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n\\n if NFalse != 2:\\n sys.exit(' Two and only two of the model parameters (Zgas,logU,xid,nh,COratio,Mcutoff) '\\n 'should be set to Flase to define the model grid; however it appears '+str(NFalse)+\\n ' parameters where not set')\\n\\n goodent = np.where( (modeldata['Zgas'] > Zgasrange[0]) & (modeldata['Zgas'] < Zgasrange[1]) &\\n (modeldata['logUs'] > logUrange[0]) & (modeldata['logUs'] < logUrange[1]) &\\n (modeldata['xid'] > xidrange[0]) & (modeldata['xid'] < xidrange[1]) &\\n (modeldata['nh'] > nhrange[0]) & (modeldata['nh'] < nhrange[1]) &\\n (modeldata['COCOsol'] > COratiorange[0]) & (modeldata['COCOsol'] < COratiorange[1]) &\\n (modeldata['mup'] > Mcutoffrange[0]) & (modeldata['mup'] < Mcutoffrange[1]) )\\n\\n Ngoodent = len(goodent[0])\\n\\n if Ngoodent > 1:\\n if verbose: print(' - Getting data for '+str(Ngoodent)+' data points satisfying model selection ')\\n param1 = modeldata[freeparam[0]][goodent]\\n if logp1:\\n param1 = np.log10(param1)\\n\\n param2 = modeldata[freeparam[1]][goodent]\\n if logp2:\\n param2 = np.log10(param2)\\n\\n lum1 = modeldata[line1][goodent]\\n lum2 = modeldata[line2][goodent]\\n else:\\n if verbose: print(' WARNING: Less than 2 model grid points to plot; no output generated')\\n return\\n\\n # - - - - - - - - - - - PLOTTING - - - - - - - - - - -\\n if verbose: print(' - Setting up and generating plot')\\n plotname = plotname\\n fig = plt.figure(figsize=(9, 5))\\n fig.subplots_adjust(wspace=0.1, hspace=0.1,left=0.1, right=0.99, bottom=0.10, top=0.95)\\n Fsize = 10\\n lthick = 1\\n marksize = 3\\n plt.rc('text', usetex=True)\\n plt.rc('font', family='serif',size=Fsize)\\n plt.rc('xtick', labelsize=Fsize)\\n plt.rc('ytick', labelsize=Fsize)\\n plt.clf()\\n plt.ioff()\\n plt.title(inforstr[:-2],fontsize=Fsize)\\n\\n margin = 0.1\\n dx = np.abs(np.max(lum1)-np.min(lum1))\\n dy = np.abs(np.max(lum2)-np.min(lum2))\\n\\n\\n if fixxrange:\\n xrange = fixxrange\\n else:\\n if logx:\\n xrange = [np.min(lum1)-np.min(lum1)/2.,np.max(lum1)+np.max(lum1)/2.]\\n else:\\n xrange = [np.min(lum1)-dx*margin,np.max(lum1)+dx*margin]\\n\\n if fixyrange:\\n yrange = fixyrange\\n else:\\n if logy:\\n yrange = [np.min(lum2)-np.min(lum2)/2.,np.max(lum2)+np.max(lum2)/2.]\\n else:\\n yrange = [np.min(lum2)-dy*margin,np.max(lum2)+dy*margin]\\n\\n # ------------ PARAM1 ------------\\n cmap = plt.cm.get_cmap('winter')\\n cmin = np.min(param1)\\n cmax = np.max(param1)\\n colnorm = matplotlib.colors.Normalize(vmin=cmin,vmax=cmax)\\n cmaparr = np.linspace(cmin, cmax, 30) #cmax-cmin)\\n mm = plt.cm.ScalarMappable(cmap=cmap)\\n mm.set_array(cmaparr)\\n cb1 = plt.colorbar(mm)#shrink=0.25\\n\\n pstr1 = legenddic[freeparam[0]]\\n if logp1:\\n pstr1 = r'log$_\\\\textrm{10}$('+pstr1+')'\\n\\n cb1.set_label(pstr1+' (outer circle) - Fixed: black line')\\n\\n for p1 in np.unique(param1):\\n p1col = cmap(colnorm(p1))\\n p1ent = np.where(param1 == p1)\\n\\n plt.plot(lum1[p1ent],lum2[p1ent],'-',lw=lthick, color='k',zorder=1)\\n\\n plt.errorbar(lum1[p1ent],lum2[p1ent],xerr=None,yerr=None,\\n marker='o',lw=0, markersize=marksize*3,\\n markerfacecolor=p1col,ecolor=p1col,markeredgecolor = 'k',zorder=10)\\n\\n # ------------ PARAM2 ------------\\n cmap = plt.cm.get_cmap('spring')\\n cmin = np.min(param2)\\n cmax = np.max(param2)\\n colnorm = matplotlib.colors.Normalize(vmin=cmin,vmax=cmax)\\n cmaparr = np.linspace(cmin, cmax, 30) #cmax-cmin)\\n mm = plt.cm.ScalarMappable(cmap=cmap)\\n mm.set_array(cmaparr)\\n cb2 = plt.colorbar(mm)#shrink=0.25\\n\\n pstr2 = legenddic[freeparam[1]]\\n if logp2:\\n pstr2 = 'log10('+pstr2+')'\\n\\n cb2.set_label(pstr2+' (inner circle) - Fixed: gray line')\\n\\n for p2 in np.unique(param2):\\n p2col = cmap(colnorm(p2))\\n p2ent = np.where(param2 == p2)\\n\\n plt.plot(lum1[p2ent],lum2[p2ent],'-',lw=lthick, color='gray',zorder=2)\\n\\n plt.errorbar(lum1[p2ent],lum2[p2ent],xerr=None,yerr=None,\\n marker='o',lw=0, markersize=marksize*1.5,\\n markerfacecolor=p2col,ecolor=p2col,markeredgecolor = 'k',zorder=20)\\n\\n if showobs != None:\\n for ii, objid in enumerate(showobs[:,0]):\\n if (showobs[:,7][ii] > xrange[0]) & (showobs[:,7][ii] < xrange[1]) & \\\\\\n (showobs[:,9][ii] > yrange[0]) & (showobs[:,9][ii] < yrange[1]):\\n\\n if noobserr:\\n obsxerr = None\\n obsyerr = None\\n else:\\n obsxerr = showobs[:,8][ii]\\n obsyerr = showobs[:,10][ii]\\n plt.errorbar(showobs[:,7][ii],showobs[:,9][ii],xerr=obsxerr,yerr=obsyerr,\\n marker='*',lw=lthick, markersize=marksize*2,\\n markerfacecolor='k',ecolor='k',markeredgecolor = 'k',zorder=30)\\n\\n plt.xlabel(r'L$_\\\\textrm{'+line1+r'}$ / [3.826$\\\\times$1e33 erg/s]/[Msun/yr]')\\n plt.ylabel(r'L$_\\\\textrm{'+line2+r'}$ / [3.826$\\\\times$1e33 erg/s]/[Msun/yr]')\\n\\n plt.xlim(xrange)\\n plt.ylim(yrange)\\n\\n if logx:\\n plt.xscale('log')\\n if logy:\\n plt.yscale('log')\\n\\n #--------- LEGEND ---------\\n # plt.errorbar(-1,-1,xerr=None,yerr=None,fmt='o',lw=lthick,ecolor='white', markersize=marksize*2,\\n # markerfacecolor='white',markeredgecolor = 'k',label='Ground-based spec')\\n #\\n # leg = plt.legend(fancybox=True, loc='upper center',prop={'size':Fsize},ncol=1,numpoints=1)\\n # #bbox_to_anchor=(1.25, 1.03)) # add the legend\\n # leg.get_frame().set_alpha(0.7)\\n #--------------------------\\n\\n if verbose: print(' Saving plot to'+plotname)\\n plt.savefig(plotname)\\n plt.clf()\\n plt.close('all')\",\n \"def get_stability_plot(self):\\n fig, ax = plt.subplots()\\n first_episode = self.get_convergence_episode()\\n\\n values = self.stats['return_stats']['episode_totals']\\n _, _, (y_lower, _) = self._moving_average(\\n values, window=_ROLLING_WINDOW, p=_CONFIDENCE_LEVEL)\\n episodes = np.arange(len(values))\\n unstable_episodes = np.where(\\n np.logical_and(values < y_lower[-1], episodes > first_episode))[0]\\n\\n ax.plot(episodes, values, color='steelblue', lw=2, alpha=.9,\\n label='Return')\\n for i, episode in enumerate(unstable_episodes):\\n ax.axvline(episode, color='salmon', lw=2,\\n label='Unstable' if i == 0 else None)\\n ax.axvline(first_episode, color='seagreen', lw=2, label='Converged')\\n\\n ax.set_title('Normalized instability = {:.3f}%'.format(\\n self.get_normalized_instability() * 100.))\\n ax.legend()\\n ax.set_ylabel('Return')\\n ax.set_xlabel('Episode')\\n return fig\",\n \"def scree_plot(self, ev):\\n plt.scatter(range(1,len(ev)+1), ev)\\n plt.plot(range(1,len(ev)+1), ev)\\n plt.title(\\\"Scree Plot\\\")\\n plt.xlabel(\\\"Factors\\\")\\n plt.ylabel(\\\"Eigenvalue\\\")\\n plt.grid()\\n plt.show()\",\n \"def evaluate(self, X_test, y_test):\\n \\n y_pred = self.pipeline.predict(X_test)\\n test_rmse = compute_rmse(y_pred, y_test)\\n print(\\\"test rmse:\\\", test_rmse)\\n return test_rmse\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7626725","0.708637","0.6610557","0.6603707","0.65582985","0.654513","0.6439415","0.6360636","0.63175553","0.62971836","0.6282147","0.6249508","0.6227701","0.62119347","0.61805004","0.6114414","0.61127007","0.609514","0.6088742","0.6055546","0.6054864","0.6053795","0.60223866","0.6014243","0.59910214","0.5973026","0.59636325","0.5960617","0.59511155","0.5928602","0.5919186","0.5915699","0.5887823","0.5885012","0.58721304","0.58705586","0.58631593","0.58531797","0.5852266","0.5851342","0.5838689","0.5838689","0.58181316","0.5806501","0.5787207","0.57699883","0.57697684","0.57665783","0.5763783","0.5753784","0.57460684","0.574559","0.5741605","0.5741403","0.5734128","0.5733666","0.5730992","0.5729153","0.57288134","0.5727863","0.57260746","0.57187843","0.570684","0.5705349","0.5704151","0.5698208","0.5696897","0.5695273","0.56940323","0.56938374","0.56926936","0.5681458","0.5680381","0.5669119","0.56643534","0.5650554","0.56503916","0.5647769","0.5637187","0.5614338","0.56130946","0.5609498","0.560775","0.56045616","0.5604077","0.56036365","0.55934817","0.5588931","0.55873543","0.5584528","0.5580307","0.55781204","0.55727834","0.557206","0.556963","0.55690944","0.5568344","0.5568288","0.5568275","0.55658525"],"string":"[\n \"0.7626725\",\n \"0.708637\",\n \"0.6610557\",\n \"0.6603707\",\n \"0.65582985\",\n \"0.654513\",\n \"0.6439415\",\n \"0.6360636\",\n \"0.63175553\",\n \"0.62971836\",\n \"0.6282147\",\n \"0.6249508\",\n \"0.6227701\",\n \"0.62119347\",\n \"0.61805004\",\n \"0.6114414\",\n \"0.61127007\",\n \"0.609514\",\n \"0.6088742\",\n \"0.6055546\",\n \"0.6054864\",\n \"0.6053795\",\n \"0.60223866\",\n \"0.6014243\",\n \"0.59910214\",\n \"0.5973026\",\n \"0.59636325\",\n \"0.5960617\",\n \"0.59511155\",\n \"0.5928602\",\n \"0.5919186\",\n \"0.5915699\",\n \"0.5887823\",\n \"0.5885012\",\n \"0.58721304\",\n \"0.58705586\",\n \"0.58631593\",\n \"0.58531797\",\n \"0.5852266\",\n \"0.5851342\",\n \"0.5838689\",\n \"0.5838689\",\n \"0.58181316\",\n \"0.5806501\",\n \"0.5787207\",\n \"0.57699883\",\n \"0.57697684\",\n \"0.57665783\",\n \"0.5763783\",\n \"0.5753784\",\n \"0.57460684\",\n \"0.574559\",\n \"0.5741605\",\n \"0.5741403\",\n \"0.5734128\",\n \"0.5733666\",\n \"0.5730992\",\n \"0.5729153\",\n \"0.57288134\",\n \"0.5727863\",\n \"0.57260746\",\n \"0.57187843\",\n \"0.570684\",\n \"0.5705349\",\n \"0.5704151\",\n \"0.5698208\",\n \"0.5696897\",\n \"0.5695273\",\n \"0.56940323\",\n \"0.56938374\",\n \"0.56926936\",\n \"0.5681458\",\n \"0.5680381\",\n \"0.5669119\",\n \"0.56643534\",\n \"0.5650554\",\n \"0.56503916\",\n \"0.5647769\",\n \"0.5637187\",\n \"0.5614338\",\n \"0.56130946\",\n \"0.5609498\",\n \"0.560775\",\n \"0.56045616\",\n \"0.5604077\",\n \"0.56036365\",\n \"0.55934817\",\n \"0.5588931\",\n \"0.55873543\",\n \"0.5584528\",\n \"0.5580307\",\n \"0.55781204\",\n \"0.55727834\",\n \"0.557206\",\n \"0.556963\",\n \"0.55690944\",\n \"0.5568344\",\n \"0.5568288\",\n \"0.5568275\",\n \"0.55658525\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6174114"},"document_rank":{"kind":"string","value":"15"}}},{"rowIdx":21289,"cells":{"query":{"kind":"string","value":"Convert scale term to unit label"},"document":{"kind":"string","value":"def get_unit(scale):\n scale2unit = { 1e-9: 'nm',\n 1e-6: u'\\N{MICRO SIGN}m', #or hex id (lookup): u'\\u00B5'\n 1e-3: 'mm',\n 0.01: 'cm',\n 0.1:'dm',\n 1:'m',\n 1000:'km',\n # time\n 8.6400e4:'day',\n 3.1536e7:'yr',\n 3.1536e10:'ka',\n 3.1536e13:'Ma',\n #Pressure\n 1e9: 'GPa',\n 1e6: 'MPa',\n }\n return scale2unit[scale]"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def point_scale_name(self):","def to_axis_units(self, label, vals):\n if label in ['Hmolar', 'Smolar', 'Umolar', 'Dmolar', 'P']:\n return vals / 1000\n elif label in ['T']:\n return vals\n else:\n raise ValueError(label)","def labels_x(x_unit, latex = True, verbose = 0): \n \n if verbose > 1:\n print(\"SpectraTools.Resources.UnitConversion.labels_x()\") \n \n if x_unit in nm_labels:\n return \"Wavelength (nm)\"\n elif x_unit in um_labels:\n if latex:\n return r\"Wavelength ($\\mu$m)\"\n else:\n return \"Wavelength (micron)\"\n elif x_unit in cm_labels:\n if latex:\n return r\"Energy (cm$^{-1}$)\"\n else:\n return \"Energy (cm-1)\"\n elif x_unit in ev_labels:\n return \"Energy (eV)\" \n else:\n return x_unit","def make_label(self, label, units):\n nice_label = self.tex_axis_label(label)\n if not (units == 'dimensionless') and \\\n (units is not None) and (not units == []):\n nice_label += ' (%s)'%self.tex_axis_label(units)\n return nice_label","def get_scale():\r\n\r\n \r\n return 0.5","def test_replace_namespaced_scale_scale(self):\n pass","def scaled_to_name(a):\r\n wt_list = ['Rx','Sc']\r\n return wt_list[a]","def unit(self,unit_str,unit_scale):\n self.units[unit_str] = unit_scale\n return self","def scale_to_factor(scale):\n return (B.pi / 2) / (2 * scale**2)","def GetScale(self):\n ...","def tex_axis_label(self, label, smalllabel=False):\n if isinstance(label, list):\n label = label[0]\n if not isinstance(label, str):\n raise ValueError(\"Label must be a string. Got %s of \"\n \"type %s\"%(label, type(label)))\n label = label.lower()\n pretty_labels = {}\n pretty_labels[\"atm_muon_scale\"] = r\"Muon Background Scale\"\n pretty_labels[\"nue_numu_ratio\"] = r\"$\\nu_e/\\nu_{\\mu}$ Ratio\"\n pretty_labels[\"nu_nc_norm\"] = r\"$\\nu$ NC Scale\"\n pretty_labels[\"nu_nubar_ratio\"] = r\"$\\nu/\\bar{\\nu}$ Ratio\"\n pretty_labels[\"barr_uphor_ratio\"] = r\"Barr Up/Horizontal Ratio\"\n pretty_labels[\"barr_nu_nubar_ratio\"] = r\"Barr $\\nu/\\bar{\\nu}$ Ratio\"\n pretty_labels[\"barr_uphor\"] = r\"Barr Up/Horizontal Ratio\"\n pretty_labels[\"barr_nu_nubar\"] = r\"Barr $\\nu/\\bar{\\nu}$ Ratio\"\n pretty_labels[\"delta_index\"] = r\"Atmospheric Index Change\"\n pretty_labels[\"theta13\"] = r\"$\\theta_{13}$\"\n pretty_labels[\"theta23\"] = r\"$\\theta_{23}$\"\n pretty_labels[\"deltacp\"] = r\"$\\delta_{\\mathrm{CP}}$\"\n pretty_labels[\"gamma\"] = r\"$\\Gamma$\"\n pretty_labels[\"sin2theta23\"] = r\"$\\sin^2\\theta_{23}$\"\n pretty_labels[\"deltam31\"] = r\"$\\Delta m^2_{31}$\"\n pretty_labels[\"deltam32\"] = r\"$\\Delta m^2_{32}$\"\n pretty_labels[\"deltam3l\"] = r\"$\\Delta m^2_{3l}$\"\n pretty_labels[\"aeff_scale\"] = r\"$A_{\\mathrm{eff}}$ Scale\"\n pretty_labels[\"energy_scale\"] = r\"Energy Scale\"\n pretty_labels[\"genie_ma_qe\"] = r\"GENIE $M_{A}^{QE}$\"\n pretty_labels[\"genie_ma_res\"] = r\"GENIE $M_{A}^{Res}$\"\n pretty_labels[\"dom_eff\"] = r\"DOM Efficiency\"\n pretty_labels[\"hole_ice\"] = r\"Hole Ice\"\n pretty_labels[\"hole_ice_fwd\"] = r\"Hole Ice Forward\"\n pretty_labels[\"degree\"] = r\"$^\\circ$\"\n pretty_labels[\"radians\"] = r\"rads\"\n pretty_labels[\"radian\"] = r\"rads\"\n pretty_labels[\"electron_volt ** 2\"] = r\"$\\mathrm{eV}^2$\"\n pretty_labels[\"electron_volt\"] = r\"$\\mathrm{eV}^2$\"\n pretty_labels[\"gigaelectron_volt\"] = r\"$\\mathrm{GeV}$\"\n pretty_labels[\"llh\"] = r\"Likelihood\"\n pretty_labels[\"conv_llh\"] = r\"Convoluted Likelihood\"\n pretty_labels[\"chi2\"] = r\"$\\chi^2$\"\n pretty_labels[\"mod_chi2\"] = r\"Modified $\\chi^2$\"\n pretty_labels[\"delta_llh\"] = r\"$\\Delta$ Likelihood\"\n pretty_labels[\"delta_conv_llh\"] = r\"$\\Delta$ Convoluted Likelihood\"\n pretty_labels[\"delta_chi2\"] = r\"$\\Delta\\chi^2$\"\n pretty_labels[\"delta_mod_chi2\"] = r\"$\\Delta$ $\\chi^2_{\\mathrm{mod}}$\"\n if smalllabel:\n pretty_labels[\"no\"] = r\"NO\"\n pretty_labels[\"io\"] = r\"IO\"\n else:\n pretty_labels[\"no\"] = r\"Normal Ordering\"\n pretty_labels[\"io\"] = r\"Inverted Ordering\"\n pretty_labels[\"nomsw\"] = r\"Normal Ordering, Matter Oscillations\"\n pretty_labels[\"iomsw\"] = r\"Inverted Ordering, Matter Oscillations\"\n pretty_labels[\"novacuum\"] = r\"Normal Ordering, Vacuum Oscillations\"\n pretty_labels[\"iovacuum\"] = r\"Inverted Ordering, Vacuum Oscillations\"\n pretty_labels[\"msw\"] = r\"Matter Oscillations\"\n pretty_labels[\"vacuum\"] = r\"Vacuum Oscillations\"\n pretty_labels[\"no,llr\"] = r\"LLR Method\"\n pretty_labels[\"no,llr,nufitpriors\"] = r\"LLR Method, Nu-Fit Priors\"\n pretty_labels[\"io,llr\"] = r\"llr Method\"\n pretty_labels[\"io,llr,nufitpriors\"] = r\"LLR Method, Nu-Fit Priors\"\n pretty_labels[\"nue\"] = r\"$\\nu_e$\"\n pretty_labels[\"nuebar\"] = r\"$\\bar{\\nu}_e$\"\n pretty_labels[\"numu\"] = r\"$\\nu_{\\mu}$\"\n pretty_labels[\"numubar\"] = r\"$\\bar{\\nu}_{\\mu}$\"\n pretty_labels[\"second\"] = r\"s\"\n pretty_labels[\"seconds\"] = r\"s\"\n pretty_labels[\"atm_delta_index\"] = r\"Atmospheric Index Change\"\n pretty_labels[\"pve\"] = r\"Positive\"\n pretty_labels[\"nve\"] = r\"Negative\"\n pretty_labels[\"fitwrong\"] = r\"Sensitivity Stability\"\n pretty_labels[\"fixwrong\"] = r\"Fitting Relevance\"\n pretty_labels[\"nminusone\"] = r\"Hidden Potential\"\n pretty_labels[\"minimiser_times\"] = r\"Minimiser Time (seconds)\"\n pretty_labels[\"minimiser_iterations\"] = r\"Minimiser Iterations\"\n pretty_labels[\"minimiser_funcevals\"] = r\"Minimiser Function Evaluations\"\n pretty_labels[\"minimiser_status\"] = r\"Minimiser Status\"\n pretty_labels[\"correlation_coefficients\"] = r\"Correlation Coefficients\"\n pretty_labels[\"true no, llr\"] = r\"True Normal Ordering, LLR\"\n pretty_labels[\"true io, llr\"] = r\"True Inverted Ordering, LLR\"\n pretty_labels[\"e_res_scale\"] = r\"Energy Resolution Scale\"\n pretty_labels[\"cz_res_scale\"] = r\"$\\cos\\theta_Z$ Resolution Scale\"\n pretty_labels[\"livetime\"] = r\"Livetime\"\n pretty_labels[\"julian_year\"] = r\"Years\"\n if label not in pretty_labels.keys():\n logging.warning(\"I have no nice label for %s. Returning as is.\"%label)\n return label\n return pretty_labels[label]","def units_to_fits(unit):\n if unit is None:\n unit = Unit('')\n return unit.to_string(\"fits\").upper()","def convert_scaling_to_form_factors(qz, scale):\n apply_absorption_correction(qz, scale)\n apply_Lorentz_correction(qz, scale)\n for i in xrange(len(scale)):\n scale[i] = np.sign(scale[i]) * math.sqrt(abs(scale[i]))","def get_scale_op(self):\n\t\treturn self.variables.get('scale')","def Unit_removeScale(*args):\n return _libsbml.Unit_removeScale(*args)","def _get_scaled_odr_label(odr_fit, order, action_unit, acd_correction, magnitude_exponent=3):\n str_acd_scale = \"$^*$\" if acd_correction != 1 else \"\"\n\n scale = acd_correction * (10 ** -magnitude_exponent) / (UNIT_IN_METERS[action_unit] ** order)\n str_val, str_std = _get_scaled_labels(odr_fit.beta[order], odr_fit.sd_beta[order], scale)\n str_mag = ''\n if magnitude_exponent != 0:\n str_mag = fr'$\\cdot$ 10$^{{{magnitude_exponent}}}$'\n return fr'({str_val} $\\pm$ {str_std}){str_acd_scale} {str_mag} m$^{{-{order}}}$'","def scale(self):","def convertUnits(self, varname, arr):\n if varname == \"SPDQ\" or varname == \"PHQ\":\n return arr*2.5e6/1000.\n return arr","def convert_units(self):\n for prod in (\"ier\", \"ier_inc_rain\"):\n self.data[prod].data[:] /= 1e6","def petab_scale_to_amici_scale(scale_str):\n\n if scale_str == 'lin':\n return amici.ParameterScaling_none\n if scale_str == 'log':\n return amici.ParameterScaling_ln\n if scale_str == 'log10':\n return amici.ParameterScaling_log10\n raise ValueError(\"Invalid pscale \" + scale_str)","def unicode_of_unit(quant):\n return quant.dimensionality.unicode","def removeScale(*args):\n return _libsbml.Unit_removeScale(*args)","def __str__(self) -> str:\n lengthscale = self.covar_module.base_kernel.lengthscale.detach()\n outputscale = self.covar_module.outputscale.detach()\n return \"\\toutputscale: {}\\n \\tlengthscale: {}\".format(outputscale, lengthscale)","def convert(self, value, unit, axis):\n scaled = getattr(value, self.scale)\n if self.format in YMDHMS_FORMATS:\n return scaled.mjd\n elif self.format == \"byear_str\":\n return scaled.byear\n elif self.format == \"jyear_str\":\n return scaled.jyear\n else:\n return getattr(scaled, self.format)","def label(self):\r\n if isinstance(self.Lbeta, str):\r\n result = self.Lbeta\r\n else:\r\n result = 'T%.2d' % int(round(self.Lbeta))\r\n result += 'E%.2d' % int(round(self.E))\r\n result += 'G%.2d' % int(round(self.minTauG))\r\n result += self.insulation\r\n return result","def unit_scale(x, eps=1e-8):\n\tx = x.copy()\n\tx -= x.min()\n\tx *= 1.0 / (x.max() + eps)\n\treturn x","def factor_to_scale(factor):\n return 1 / B.sqrt(4 * factor / B.pi)","def test_read_namespaced_scale_scale(self):\n pass","def numerify_iso_label(lab):\n from sage.databases.cremona import class_to_int\n if 'CM' in lab:\n return -1 - class_to_int(lab[2:])\n else:\n return class_to_int(lab.lower())","def any_scale(scale):\n return scale","def convertToSpectroGram(self):","def getyscale(self, trace: int) -> str: \n if not self.debug:\n # TODO: Verificar\n #self.myFieldFox.write(\"[:SENSe]:AMPLitude:SCALe?\")\n #self.myFieldFox.write(\"SENS:AMPL:SCAL?\")\n self.myFieldFox.write(\"CALC1:FORM?\")\n ret = self.myFieldFox.read()\n if ret == \"MLOG\\n\":\n ret = \"logarithmic\"\n elif ret == \"MLIN\\n\":\n ret = \"linear\"\n else:\n ret = \"\"\n else:\n ret = 'logarithmic'\n return ret","def get_tscale_stringlist(self):\n return text_tscale","def labels_y(y_unit, latex = True, verbose = 0): \n\n if verbose > 1:\n print(\"SpectraTools.Resources.UnitConversion.labels_y()\") \n \n if y_unit in absorption_labels:\n return \"Absorption (OD)\"\n elif y_unit in milli_absorption_labels:\n return \"Absorption (mOD)\" \n elif y_unit in transmission_1_labels:\n return \"Transmission\"\n elif y_unit in transmission_pct_labels:\n if latex:\n return r\"Transmission (\\%)\"\n else:\n return \"Transmission (%)\"\n else:\n return y_unit","def normalize(self, factor):","def scale(self):\n return self.scale_factor / CONSTANTS.AU","def _convert_value(self, value, unit, axis):\n if hasattr(value, 'units'):\n return value.to(unit).magnitude\n else:\n return self._reg.Quantity(value, axis.get_units()).to(unit).magnitude","def getLabel(self, names, values, withRescale = False, pow10first=False, sigma = 0.45):\n #lb_name = (names[-1] == ',') and names[:-1] or names[-1]\n lb = names + \" = \"\n lb += \",\".join([str(i) for i in values])\n if len(values)==2:\n L, k = values\n if len(values)==3:\n L, k, W = values\n\n if withRescale:\n if len(values)==2:\n lb = names + \"=\"\n lb += str(values[0])\n if pow10first:\n lb += r\", $10^{%d}$\" %(int(round(numpy.log10(1.0*k/L))))\n else:\n lb += \", %.3e\" %(1.0*k/L)\n if len(values)==3:\n lb = r\"$k, W_s =$\"\n #lb += str(L)\n if pow10first:\n lb += r\"$10^{%d}$\" %(int(round(numpy.log10(1.0*k/L))))\n else:\n lb += \"%.2e\" %(1.0*k/L)\n lb += \",%.2f\" %(W*(1.0*k/L)**sigma)\n #lb += str(W)\n #lb += \",%.3e\" %((1.0*k/L)**(-sigma)/L)\n #for nm, val in zip(a,b):\n # exec(nm + \"= \" + str(val))\n #if len(values) == 2:\n # lb += str(1.0*k/L)**sigma\n #elif len(values) == 3:\n # lb += str((1.0*k/L)**sigma*W)[0:5]\n return lb","def quote_scaled(term: str):\n if has_scaled(term):\n return (True, quote_poly_term(before_scaled(term)))\n else:\n return (False, quote_poly_term(term))","def test_patch_namespaced_scale_scale(self):\n pass","def temperature_scale(self) -> str:\r\n self._logger.debug(log_message_formatter(\r\n \"get\", f\"{self}\", \"temperature_scale\"))\r\n return self._temperature_scale","def normalize_label(labels):\n max_val = torch.max(labels)\n min_val = torch.min(labels)\n norm_labels = (labels - min_val)/(max_val - min_val)\n return norm_labels","def fix_label(label):\n\n replace_dict = {'_': ' ',\n 'degE': '$^{\\circ}$E',\n 'ms-1': '$m s^{-1}$',\n 'm.s-1': '$m s^{-1}$',\n 'Wm-2': '$W m^{-2}$',\n '1000000 m2.s-1': '$10^6$m$^2$s$^{-1}$'\n } \n\n for value, replacement in list(replace_dict.items()):\n label = label.replace(value, replacement)\n\n return label","def dim_unit_scaling(in_unit, out_unit):\n\n unit_vals = {\n 'nm': 1e-9,\n 'um': 1e-6,\n 'mm': 1e-3,\n 'cm': 1e-2,\n 'm': 1.0,\n 'km': 1e3,\n }\n\n if in_unit not in unit_vals:\n raise ValueError(\n 'Invalid input unit {}. Must be one of {}'.format(\n in_unit, list(unit_vals.keys())\n )\n )\n if out_unit not in unit_vals:\n raise ValueError(\n 'Invalid input unit {}. Must be one of {}'.format(\n in_unit, list(unit_vals.keys())\n )\n )\n\n return unit_vals[in_unit]/unit_vals[out_unit]","def unsetScale(self):\n return _libsbml.Unit_unsetScale(self)","def testStringInput(self):\n nb.rescale_length(\"2.0\")\n self.assertEqual(2.0, nb.rscale)","def normalisesym(self, label):\n return label","def convert_qty (qty,unit,ing) :\n portion_presence = False\n try :\n div = re.search(r\"[^ \\w]\", qty).start()\n portion = float(qty[div-1]) / float(qty[div+1])\n qty_float=portion\n portion_presence = True\n qty = qty[:div-1]\n except :\n try : \n qty_float = float(qty)\n except :\n qty_float = 10\n\n if portion_presence == True :\n if len(qty) > 0 :\n qty_float += float(qty[:div-2])\n \n #use the unit to have in ml\n #qty_float*=conversion_unit[unit]\n \n #convert in grammes with the database of density\n #qty_float*=density[ing]\n \n return qty_float","def scale_ticks_params(tick_scale='linear'):\n if tick_scale == 'linear':\n base = None\n label_scale = 'Linear Scale'\n else:\n if tick_scale == 'log2':\n base = 2\n label_scale = 'Log2 Scale'\n elif tick_scale == 'log10':\n base = 10\n label_scale = 'Log10 Scale'\n else:\n raise ValueError('The specified tick scale is not supported.')\n return base, label_scale","def scale(self):\n return self._scale","def getxscale(self) -> int:\n if not self.debug:\n # TODO: Verificar\n self.myFieldFox.write(\"TRAC:SPEC:AMPL:SCAL?\")\n ret = self.myFieldFox.read()\n else:\n ret = 'LOG'\n return ret","def get_KE(p, scale= 1):\n p = p.flatten()\n return scale * 0.5*np.sum(np.multiply(p, p))","def get_scale_freq():\n return sf / 2 / (num_freq-1)","def scale(self):\n return self.distribution.scale","def latex_of_unit(quant):\n return _latex_from_dimensionality(quant.dimensionality).strip(\"$\")","def convert_scale(g, op, block):\n\n scale = op.attr(\"scale\")\n bias = op.attr(\"bias\")\n bias_after_scale = op.attr(\"bias_after_scale\")\n x = g.get_node(op.input(\"X\")[0])\n if np.isclose(scale, 1.0) and np.isclose(bias, 0.0):\n out = x\n else:\n if np.isclose(bias, 0.0):\n out = x * _expr.const(np.array(scale).astype(\"float32\"))\n elif np.isclose(scale, 1.0):\n out = x + _expr.const(np.array(bias).astype(\"float32\"))\n else:\n if bias_after_scale:\n out = x * _expr.const(np.array(scale).astype(\"float32\")) + _expr.const(\n np.array(bias).astype(\"float32\")\n )\n else:\n out = (x + _expr.const(np.array(bias).astype(\"float32\"))) * _expr.const(\n np.array(scale).astype(\"float32\")\n )\n g.add_node(op.output(\"Out\")[0], out)","def get_scale(units, compartmentId, volume, extracellularVolume):\r\n if compartmentId == 'c':\r\n V = volume\r\n else:\r\n V = extracellularVolume\r\n\r\n if units == 'uM':\r\n return 1. / N_AVOGADRO / V * 1e6\r\n elif units == 'mM':\r\n return 1. / N_AVOGADRO / V * 1e3\r\n elif units == 'molecules':\r\n return 1.\r\n else:\r\n raise Exception('Invalid units \"%s\"' % units)","def unit_converter(val, from_u, to_u):\n\tconverter = {'b':0, 'k':1, 'm':2, 'g':3, 't':4}\n\tif converter[from_u] < converter[to_u]:\n\t\tval = float(val)\n\t\tfor _ in range(converter[to_u] - converter[from_u]):\n\t\t\tval = val/1024\n\telse:\n\t\tfor _ in range(converter[from_u] - converter[to_u]):\n\t\t\tval = val * 1024\n\t\t\t\n\treturn val","def convert(self):\n return _libsbml.SBMLUnitsConverter_convert(self)","def scale(self):\n return self._gev_bijector.scale","def Scale(*args, **kwargs):\n return _gdi_.Font_Scale(*args, **kwargs)","def unit(self) -> str:","def freqscale(self):\n index = self._ordered_input_names.index('freqscale')\n return self._inputs[index]","def norm(self, label):\n label_vec = []\n label_value = self.to_int(label)\n for i in range(10):\n if i == label_value:\n label_vec.append(0.9)\n else:\n label_vec.append(0.1)\n return label_vec","def human_m(v):\n if v < 1e-2:\n return (v*1.0e3, 'mm')\n if v < 1:\n return (v*1.0e2, 'cm')\n if v < 1000:\n return (v, 'm')\n return (v/1.0e3, 'km')","def scale(self, factor):\n for a in self.symbol_attributes:\n a.scale(factor)","def transform(self, X):\r\n X[(X == 'Large') | (X == 'Medium')] = 'Large / Medium'\r\n return X","def transform(self, X):\r\n X[(X == 'Large') | (X == 'Medium')] = 'Large / Medium'\r\n return X","def get_tempscale(self, text=False):\n if text:\n return text_tscale[self.tempscale]\n return self.tempscale","def label (x):\n\n if x == 0:\n return None\n if x == 1:\n return Fraction(0)\n b = bin(x)[2:]\n s = b[1]\n wf = re.compile(r'^.({}+)(.*)$'.format(s))\n w,f = wf.findall(b)[0]\n p = 1 if s == '1' else -1\n n = p * Fraction(len(w),1)\n scale = Fraction(1,1)\n while len(f):\n scale /= 2\n if f[0] == '1':\n n += scale\n else:\n n += -scale\n f = f[1:]\n return n","def convert(self):\n return _libsbml.SBMLInferUnitsConverter_convert(self)","def get_label(urs):\n return assign_term(urs)[1]","def yscale(value):\n impl.yscale(**locals())","def convert_shape_to_units(self, shape):\n unit_factor = [GDS[\"unit\"][0]] * 2\n ll=shape[0].scale(unit_factor)\n ur=shape[1].scale(unit_factor)\n return [ll,ur]","def on_scale_changed(self):\n\n options = self.get_options()\n\n label = \"Result: {0}x{1}\".format(int(options[\"width\"]),\n int(options[\"height\"]))\n\n self.scale_result.setText(label)","def _get_unit_factor(self, unit: str) -> np.ndarray:\n\n unit_factors = {\n 'vx': np.array((1, 1, 1)),\n 'nm': np.array(self.parameters.scale),\n 'um': np.array(self.parameters.scale)/1000\n }\n assert unit in unit_factors.keys(), 'Invalid unit'\n unit_factor = unit_factors[unit]\n\n return unit_factor","def _adjust_scale(self, value):\n if self._min_val <= value <= self._max_val:\n self._scale_var.set(value)\n self.update_label_text()","def get_timescale(self, text=False):\n if text:\n return text_timescale[self.timescale]\n return self.timescale","def label(self, decimals=None, base_label=None, cache=None):\n return super().label(decimals=decimals, base_label=base_label or \"∏_ϕ\", cache=cache)","def enlabel(mi_, ma_):\n\treturn \"Unicode characters from {} to {} codepoints\".format(mi_, ma_)","def uc(p) :\r\n return Components(p, Scale=2)","def scaling(self):\n \n if self.colindex == self.rowsize: # last chart in row\n self.colindex = 0\n self.rowindex += 1 \n xorigin = self.indent + (self.colindex * self.xscale) \n yorigin = self.rowindex * self.yscale\n xscale = self.xscale # to fulfil % formatting below\n yscale = self.yscale \n self.colindex += 1\n\n res = \"origin(%(xorigin)s%%, %(yorigin)s%%), scale(%(xscale)s%%, %(yscale)s%%)\" % locals()\n return res","def native_unit_of_measurement(self) -> str:\n return f\"{CURRENCY_CENT}/{UnitOfVolume.LITERS}\"","def sequence_scale(scale, scale_sequence):\n factor = math.floor(math.log10(scale))\n norm = scale / (10**factor)\n\n for s in scale_sequence:\n if norm <= s:\n return s * 10**factor\n return scale_sequence[0] * 10**(factor + 1)","def unit_of_measurement(self):\n return \"%\"","def test_jy_to_mk_units():\n test_fq = np.array([0.1]) * units.GHz\n jy_to_mk = utils.jy_to_mk(test_fq)\n test_conversion = const.c**2 / (2 * test_fq.to(\"1/s\") ** 2 * const.k_B) * units.sr\n test_conversion = test_conversion.to(\"mK*sr/Jy\")\n assert test_conversion.unit.to_string() == jy_to_mk.unit.to_string()","def scale_value(self):\n return self._scale_value[2]","def add_scale(self, scale=None, label=None, *, loc=\"auto\", color=\"k\", fontsize=\"x-small\"):\n if scale is None:\n scale = 5\n else:\n # convert to display units\n scale = scale * self.factor_for(self.projection[0])\n\n if label is None:\n unit = self.display_unit_for(self.projection[0])\n label = f\"{scale:g} {unit}\"\n\n return super(FloorPlot, self).add_scale(\n self.ax, scale, label=label, loc=loc, color=color, fontsize=fontsize\n )","def scale(self, value):\r\n return (float(value)-float(self.minimum))/float(self.maximum-self.minimum)*2.0 - 1.0","def _to_large_medium(self, value):\r\n if value == 'Medium' or value == 'Large':\r\n return 'Large / Medium'\r\n else:\r\n return value","def _to_large_medium(self, value):\r\n if value == 'Medium' or value == 'Large':\r\n return 'Large / Medium'\r\n else:\r\n return value","def vm(x):\r\n return str(x) + 'mm'","def useUnits():","def to_units(number):\n unit = 0\n while number >= 1024.:\n unit += 1\n number = number / 1024.\n if unit == len(UNITS) - 1:\n break\n if unit:\n return '%.2f%s' % (number, UNITS[unit])\n return '%d' % number","def scale_pos(q_unsc):\n q_sc = (q_unsc - 0.125)/0.125\n return q_sc","def to_base_unit(val: float, unit: str = \"\") -> float:\n unit_scalar = UNITS.get(unit, None)\n if not unit_scalar:\n raise UnknownUnitError(f\"Unit '{unit}' is not supported\")\n\n return val * unit_scalar","def _fix_units(cube, definition):\n\n if cube.var_name != 'pr':\n cube.convert_units(definition.units)","def spice_unit_convert(valuet, restrict=[]):\n # valuet is a tuple of (unit, value), where \"value\" is numeric\n # and \"unit\" is a string. \"restrict\" may be used to require that\n # the value be of a specific class like \"time\" or \"resistance\". \n\n # Recursive handling of '/' and multiplicatioon dot in expressions\n if '/' in valuet[0]:\n parts = valuet[0].split('/', 1)\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\n result /= numeric(spice_unit_convert([parts[1], \"1.0\"], restrict))\n return str(result)\n\n if '\\u22c5' in valuet[0]:\t# multiplication dot\n parts = valuet[0].split('\\u22c5')\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\n result *= numeric(spice_unit_convert([parts[1], \"1.0\"], restrict))\n return str(result)\n\n if '\\u00b2' in valuet[0]:\t# squared\n part = valuet[0].split('\\u00b2')[0]\n result = numeric(spice_unit_unconvert([part, valuet[1]], restrict))\n result *= numeric(spice_unit_unconvert([part, \"1.0\"], restrict))\n return str(result)\n\n if valuet[0] == \"\":\t\t# null case, no units\n return valuet[1]\n\n for unitrec in unittypes:\t# case of no prefix\n if re.match('^' + unitrec + '$', valuet[0]):\n if restrict:\n if unittypes[unitrec] == restrict.lower():\n return valuet[1]\n else:\n return valuet[1]\n\n for prerec in prefixtypes:\n for unitrec in unittypes:\n if re.match('^' + prerec + unitrec + '$', valuet[0]):\n if restrict:\n if unittypes[unitrec] == restrict.lower():\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\n return str(newvalue)\n else:\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\n return str(newvalue)\n\n # Check for \"%\", which can apply to anything.\n if valuet[0][0] == '%':\n newvalue = numeric(valuet[1]) * 0.01\n return str(newvalue)\n \n if restrict:\n raise ValueError('units ' + valuet[0] + ' cannot be parsed as ' + restrict.lower())\n else:\n # raise ValueError('units ' + valuet[0] + ' cannot be parsed')\n # (Assume value is not in SI units and will be passed back as-is)\n return valuet[1]","def default_units(x, axis):\n # In the case where the first matplotlib command is setting limits,\n # x may be a tuple of length two (with the same units).\n if isinstance(x, tuple):\n name = getattr(x[0], \"name\", \"\")\n units = x[0].units\n else:\n name = getattr(x, \"name\", \"\")\n units = x.units\n\n # maintain a mapping between Axis and name since Axis does not point to\n # its underlying data and we want to propagate the name to the axis\n # label in the subsequent call to axisinfo\n unyt_arrayConverter._axisnames[axis] = name if name is not None else \"\"\n return units","def _tidyup_labels(self, labels: Sequence[str]) -> Sequence[str]:\n\n def remove_zeroes(s: str) -> str:\n \"\"\"\n Remove unnecessary zeros for float string s\n \"\"\"\n tup = s.split(\"e\")\n if len(tup) == 2:\n mantissa = tup[0].rstrip(\"0\").rstrip(\".\")\n exponent = int(tup[1])\n if exponent:\n s = \"%se%d\" % (mantissa, exponent)\n else:\n s = mantissa\n return s\n\n def as_exp(s: str) -> str:\n \"\"\"\n Float string s as in exponential format\n \"\"\"\n return s if \"e\" in s else \"{:1.0e}\".format(float(s))\n\n def as_mathtex(s: str) -> str:\n \"\"\"\n Mathtex for maplotlib\n \"\"\"\n if \"e\" not in s:\n assert s == \"1\", f\"Unexpected value {s = }, instead of '1'\"\n return f\"${self.base}^{{0}}$\"\n\n exp = s.split(\"e\")[1]\n return f\"${self.base}^{{{exp}}}$\"\n\n # If any are in exponential format, make all of\n # them expontential\n has_e = [\"e\" in x for x in labels]\n if not all(has_e) and sum(has_e):\n labels = [as_exp(x) for x in labels]\n\n labels = [remove_zeroes(x) for x in labels]\n\n has_e = [\"e\" in x for x in labels]\n if self.mathtex and any(has_e):\n labels = [as_mathtex(x) for x in labels]\n\n return labels"],"string":"[\n \"def point_scale_name(self):\",\n \"def to_axis_units(self, label, vals):\\n if label in ['Hmolar', 'Smolar', 'Umolar', 'Dmolar', 'P']:\\n return vals / 1000\\n elif label in ['T']:\\n return vals\\n else:\\n raise ValueError(label)\",\n \"def labels_x(x_unit, latex = True, verbose = 0): \\n \\n if verbose > 1:\\n print(\\\"SpectraTools.Resources.UnitConversion.labels_x()\\\") \\n \\n if x_unit in nm_labels:\\n return \\\"Wavelength (nm)\\\"\\n elif x_unit in um_labels:\\n if latex:\\n return r\\\"Wavelength ($\\\\mu$m)\\\"\\n else:\\n return \\\"Wavelength (micron)\\\"\\n elif x_unit in cm_labels:\\n if latex:\\n return r\\\"Energy (cm$^{-1}$)\\\"\\n else:\\n return \\\"Energy (cm-1)\\\"\\n elif x_unit in ev_labels:\\n return \\\"Energy (eV)\\\" \\n else:\\n return x_unit\",\n \"def make_label(self, label, units):\\n nice_label = self.tex_axis_label(label)\\n if not (units == 'dimensionless') and \\\\\\n (units is not None) and (not units == []):\\n nice_label += ' (%s)'%self.tex_axis_label(units)\\n return nice_label\",\n \"def get_scale():\\r\\n\\r\\n \\r\\n return 0.5\",\n \"def test_replace_namespaced_scale_scale(self):\\n pass\",\n \"def scaled_to_name(a):\\r\\n wt_list = ['Rx','Sc']\\r\\n return wt_list[a]\",\n \"def unit(self,unit_str,unit_scale):\\n self.units[unit_str] = unit_scale\\n return self\",\n \"def scale_to_factor(scale):\\n return (B.pi / 2) / (2 * scale**2)\",\n \"def GetScale(self):\\n ...\",\n \"def tex_axis_label(self, label, smalllabel=False):\\n if isinstance(label, list):\\n label = label[0]\\n if not isinstance(label, str):\\n raise ValueError(\\\"Label must be a string. Got %s of \\\"\\n \\\"type %s\\\"%(label, type(label)))\\n label = label.lower()\\n pretty_labels = {}\\n pretty_labels[\\\"atm_muon_scale\\\"] = r\\\"Muon Background Scale\\\"\\n pretty_labels[\\\"nue_numu_ratio\\\"] = r\\\"$\\\\nu_e/\\\\nu_{\\\\mu}$ Ratio\\\"\\n pretty_labels[\\\"nu_nc_norm\\\"] = r\\\"$\\\\nu$ NC Scale\\\"\\n pretty_labels[\\\"nu_nubar_ratio\\\"] = r\\\"$\\\\nu/\\\\bar{\\\\nu}$ Ratio\\\"\\n pretty_labels[\\\"barr_uphor_ratio\\\"] = r\\\"Barr Up/Horizontal Ratio\\\"\\n pretty_labels[\\\"barr_nu_nubar_ratio\\\"] = r\\\"Barr $\\\\nu/\\\\bar{\\\\nu}$ Ratio\\\"\\n pretty_labels[\\\"barr_uphor\\\"] = r\\\"Barr Up/Horizontal Ratio\\\"\\n pretty_labels[\\\"barr_nu_nubar\\\"] = r\\\"Barr $\\\\nu/\\\\bar{\\\\nu}$ Ratio\\\"\\n pretty_labels[\\\"delta_index\\\"] = r\\\"Atmospheric Index Change\\\"\\n pretty_labels[\\\"theta13\\\"] = r\\\"$\\\\theta_{13}$\\\"\\n pretty_labels[\\\"theta23\\\"] = r\\\"$\\\\theta_{23}$\\\"\\n pretty_labels[\\\"deltacp\\\"] = r\\\"$\\\\delta_{\\\\mathrm{CP}}$\\\"\\n pretty_labels[\\\"gamma\\\"] = r\\\"$\\\\Gamma$\\\"\\n pretty_labels[\\\"sin2theta23\\\"] = r\\\"$\\\\sin^2\\\\theta_{23}$\\\"\\n pretty_labels[\\\"deltam31\\\"] = r\\\"$\\\\Delta m^2_{31}$\\\"\\n pretty_labels[\\\"deltam32\\\"] = r\\\"$\\\\Delta m^2_{32}$\\\"\\n pretty_labels[\\\"deltam3l\\\"] = r\\\"$\\\\Delta m^2_{3l}$\\\"\\n pretty_labels[\\\"aeff_scale\\\"] = r\\\"$A_{\\\\mathrm{eff}}$ Scale\\\"\\n pretty_labels[\\\"energy_scale\\\"] = r\\\"Energy Scale\\\"\\n pretty_labels[\\\"genie_ma_qe\\\"] = r\\\"GENIE $M_{A}^{QE}$\\\"\\n pretty_labels[\\\"genie_ma_res\\\"] = r\\\"GENIE $M_{A}^{Res}$\\\"\\n pretty_labels[\\\"dom_eff\\\"] = r\\\"DOM Efficiency\\\"\\n pretty_labels[\\\"hole_ice\\\"] = r\\\"Hole Ice\\\"\\n pretty_labels[\\\"hole_ice_fwd\\\"] = r\\\"Hole Ice Forward\\\"\\n pretty_labels[\\\"degree\\\"] = r\\\"$^\\\\circ$\\\"\\n pretty_labels[\\\"radians\\\"] = r\\\"rads\\\"\\n pretty_labels[\\\"radian\\\"] = r\\\"rads\\\"\\n pretty_labels[\\\"electron_volt ** 2\\\"] = r\\\"$\\\\mathrm{eV}^2$\\\"\\n pretty_labels[\\\"electron_volt\\\"] = r\\\"$\\\\mathrm{eV}^2$\\\"\\n pretty_labels[\\\"gigaelectron_volt\\\"] = r\\\"$\\\\mathrm{GeV}$\\\"\\n pretty_labels[\\\"llh\\\"] = r\\\"Likelihood\\\"\\n pretty_labels[\\\"conv_llh\\\"] = r\\\"Convoluted Likelihood\\\"\\n pretty_labels[\\\"chi2\\\"] = r\\\"$\\\\chi^2$\\\"\\n pretty_labels[\\\"mod_chi2\\\"] = r\\\"Modified $\\\\chi^2$\\\"\\n pretty_labels[\\\"delta_llh\\\"] = r\\\"$\\\\Delta$ Likelihood\\\"\\n pretty_labels[\\\"delta_conv_llh\\\"] = r\\\"$\\\\Delta$ Convoluted Likelihood\\\"\\n pretty_labels[\\\"delta_chi2\\\"] = r\\\"$\\\\Delta\\\\chi^2$\\\"\\n pretty_labels[\\\"delta_mod_chi2\\\"] = r\\\"$\\\\Delta$ $\\\\chi^2_{\\\\mathrm{mod}}$\\\"\\n if smalllabel:\\n pretty_labels[\\\"no\\\"] = r\\\"NO\\\"\\n pretty_labels[\\\"io\\\"] = r\\\"IO\\\"\\n else:\\n pretty_labels[\\\"no\\\"] = r\\\"Normal Ordering\\\"\\n pretty_labels[\\\"io\\\"] = r\\\"Inverted Ordering\\\"\\n pretty_labels[\\\"nomsw\\\"] = r\\\"Normal Ordering, Matter Oscillations\\\"\\n pretty_labels[\\\"iomsw\\\"] = r\\\"Inverted Ordering, Matter Oscillations\\\"\\n pretty_labels[\\\"novacuum\\\"] = r\\\"Normal Ordering, Vacuum Oscillations\\\"\\n pretty_labels[\\\"iovacuum\\\"] = r\\\"Inverted Ordering, Vacuum Oscillations\\\"\\n pretty_labels[\\\"msw\\\"] = r\\\"Matter Oscillations\\\"\\n pretty_labels[\\\"vacuum\\\"] = r\\\"Vacuum Oscillations\\\"\\n pretty_labels[\\\"no,llr\\\"] = r\\\"LLR Method\\\"\\n pretty_labels[\\\"no,llr,nufitpriors\\\"] = r\\\"LLR Method, Nu-Fit Priors\\\"\\n pretty_labels[\\\"io,llr\\\"] = r\\\"llr Method\\\"\\n pretty_labels[\\\"io,llr,nufitpriors\\\"] = r\\\"LLR Method, Nu-Fit Priors\\\"\\n pretty_labels[\\\"nue\\\"] = r\\\"$\\\\nu_e$\\\"\\n pretty_labels[\\\"nuebar\\\"] = r\\\"$\\\\bar{\\\\nu}_e$\\\"\\n pretty_labels[\\\"numu\\\"] = r\\\"$\\\\nu_{\\\\mu}$\\\"\\n pretty_labels[\\\"numubar\\\"] = r\\\"$\\\\bar{\\\\nu}_{\\\\mu}$\\\"\\n pretty_labels[\\\"second\\\"] = r\\\"s\\\"\\n pretty_labels[\\\"seconds\\\"] = r\\\"s\\\"\\n pretty_labels[\\\"atm_delta_index\\\"] = r\\\"Atmospheric Index Change\\\"\\n pretty_labels[\\\"pve\\\"] = r\\\"Positive\\\"\\n pretty_labels[\\\"nve\\\"] = r\\\"Negative\\\"\\n pretty_labels[\\\"fitwrong\\\"] = r\\\"Sensitivity Stability\\\"\\n pretty_labels[\\\"fixwrong\\\"] = r\\\"Fitting Relevance\\\"\\n pretty_labels[\\\"nminusone\\\"] = r\\\"Hidden Potential\\\"\\n pretty_labels[\\\"minimiser_times\\\"] = r\\\"Minimiser Time (seconds)\\\"\\n pretty_labels[\\\"minimiser_iterations\\\"] = r\\\"Minimiser Iterations\\\"\\n pretty_labels[\\\"minimiser_funcevals\\\"] = r\\\"Minimiser Function Evaluations\\\"\\n pretty_labels[\\\"minimiser_status\\\"] = r\\\"Minimiser Status\\\"\\n pretty_labels[\\\"correlation_coefficients\\\"] = r\\\"Correlation Coefficients\\\"\\n pretty_labels[\\\"true no, llr\\\"] = r\\\"True Normal Ordering, LLR\\\"\\n pretty_labels[\\\"true io, llr\\\"] = r\\\"True Inverted Ordering, LLR\\\"\\n pretty_labels[\\\"e_res_scale\\\"] = r\\\"Energy Resolution Scale\\\"\\n pretty_labels[\\\"cz_res_scale\\\"] = r\\\"$\\\\cos\\\\theta_Z$ Resolution Scale\\\"\\n pretty_labels[\\\"livetime\\\"] = r\\\"Livetime\\\"\\n pretty_labels[\\\"julian_year\\\"] = r\\\"Years\\\"\\n if label not in pretty_labels.keys():\\n logging.warning(\\\"I have no nice label for %s. Returning as is.\\\"%label)\\n return label\\n return pretty_labels[label]\",\n \"def units_to_fits(unit):\\n if unit is None:\\n unit = Unit('')\\n return unit.to_string(\\\"fits\\\").upper()\",\n \"def convert_scaling_to_form_factors(qz, scale):\\n apply_absorption_correction(qz, scale)\\n apply_Lorentz_correction(qz, scale)\\n for i in xrange(len(scale)):\\n scale[i] = np.sign(scale[i]) * math.sqrt(abs(scale[i]))\",\n \"def get_scale_op(self):\\n\\t\\treturn self.variables.get('scale')\",\n \"def Unit_removeScale(*args):\\n return _libsbml.Unit_removeScale(*args)\",\n \"def _get_scaled_odr_label(odr_fit, order, action_unit, acd_correction, magnitude_exponent=3):\\n str_acd_scale = \\\"$^*$\\\" if acd_correction != 1 else \\\"\\\"\\n\\n scale = acd_correction * (10 ** -magnitude_exponent) / (UNIT_IN_METERS[action_unit] ** order)\\n str_val, str_std = _get_scaled_labels(odr_fit.beta[order], odr_fit.sd_beta[order], scale)\\n str_mag = ''\\n if magnitude_exponent != 0:\\n str_mag = fr'$\\\\cdot$ 10$^{{{magnitude_exponent}}}$'\\n return fr'({str_val} $\\\\pm$ {str_std}){str_acd_scale} {str_mag} m$^{{-{order}}}$'\",\n \"def scale(self):\",\n \"def convertUnits(self, varname, arr):\\n if varname == \\\"SPDQ\\\" or varname == \\\"PHQ\\\":\\n return arr*2.5e6/1000.\\n return arr\",\n \"def convert_units(self):\\n for prod in (\\\"ier\\\", \\\"ier_inc_rain\\\"):\\n self.data[prod].data[:] /= 1e6\",\n \"def petab_scale_to_amici_scale(scale_str):\\n\\n if scale_str == 'lin':\\n return amici.ParameterScaling_none\\n if scale_str == 'log':\\n return amici.ParameterScaling_ln\\n if scale_str == 'log10':\\n return amici.ParameterScaling_log10\\n raise ValueError(\\\"Invalid pscale \\\" + scale_str)\",\n \"def unicode_of_unit(quant):\\n return quant.dimensionality.unicode\",\n \"def removeScale(*args):\\n return _libsbml.Unit_removeScale(*args)\",\n \"def __str__(self) -> str:\\n lengthscale = self.covar_module.base_kernel.lengthscale.detach()\\n outputscale = self.covar_module.outputscale.detach()\\n return \\\"\\\\toutputscale: {}\\\\n \\\\tlengthscale: {}\\\".format(outputscale, lengthscale)\",\n \"def convert(self, value, unit, axis):\\n scaled = getattr(value, self.scale)\\n if self.format in YMDHMS_FORMATS:\\n return scaled.mjd\\n elif self.format == \\\"byear_str\\\":\\n return scaled.byear\\n elif self.format == \\\"jyear_str\\\":\\n return scaled.jyear\\n else:\\n return getattr(scaled, self.format)\",\n \"def label(self):\\r\\n if isinstance(self.Lbeta, str):\\r\\n result = self.Lbeta\\r\\n else:\\r\\n result = 'T%.2d' % int(round(self.Lbeta))\\r\\n result += 'E%.2d' % int(round(self.E))\\r\\n result += 'G%.2d' % int(round(self.minTauG))\\r\\n result += self.insulation\\r\\n return result\",\n \"def unit_scale(x, eps=1e-8):\\n\\tx = x.copy()\\n\\tx -= x.min()\\n\\tx *= 1.0 / (x.max() + eps)\\n\\treturn x\",\n \"def factor_to_scale(factor):\\n return 1 / B.sqrt(4 * factor / B.pi)\",\n \"def test_read_namespaced_scale_scale(self):\\n pass\",\n \"def numerify_iso_label(lab):\\n from sage.databases.cremona import class_to_int\\n if 'CM' in lab:\\n return -1 - class_to_int(lab[2:])\\n else:\\n return class_to_int(lab.lower())\",\n \"def any_scale(scale):\\n return scale\",\n \"def convertToSpectroGram(self):\",\n \"def getyscale(self, trace: int) -> str: \\n if not self.debug:\\n # TODO: Verificar\\n #self.myFieldFox.write(\\\"[:SENSe]:AMPLitude:SCALe?\\\")\\n #self.myFieldFox.write(\\\"SENS:AMPL:SCAL?\\\")\\n self.myFieldFox.write(\\\"CALC1:FORM?\\\")\\n ret = self.myFieldFox.read()\\n if ret == \\\"MLOG\\\\n\\\":\\n ret = \\\"logarithmic\\\"\\n elif ret == \\\"MLIN\\\\n\\\":\\n ret = \\\"linear\\\"\\n else:\\n ret = \\\"\\\"\\n else:\\n ret = 'logarithmic'\\n return ret\",\n \"def get_tscale_stringlist(self):\\n return text_tscale\",\n \"def labels_y(y_unit, latex = True, verbose = 0): \\n\\n if verbose > 1:\\n print(\\\"SpectraTools.Resources.UnitConversion.labels_y()\\\") \\n \\n if y_unit in absorption_labels:\\n return \\\"Absorption (OD)\\\"\\n elif y_unit in milli_absorption_labels:\\n return \\\"Absorption (mOD)\\\" \\n elif y_unit in transmission_1_labels:\\n return \\\"Transmission\\\"\\n elif y_unit in transmission_pct_labels:\\n if latex:\\n return r\\\"Transmission (\\\\%)\\\"\\n else:\\n return \\\"Transmission (%)\\\"\\n else:\\n return y_unit\",\n \"def normalize(self, factor):\",\n \"def scale(self):\\n return self.scale_factor / CONSTANTS.AU\",\n \"def _convert_value(self, value, unit, axis):\\n if hasattr(value, 'units'):\\n return value.to(unit).magnitude\\n else:\\n return self._reg.Quantity(value, axis.get_units()).to(unit).magnitude\",\n \"def getLabel(self, names, values, withRescale = False, pow10first=False, sigma = 0.45):\\n #lb_name = (names[-1] == ',') and names[:-1] or names[-1]\\n lb = names + \\\" = \\\"\\n lb += \\\",\\\".join([str(i) for i in values])\\n if len(values)==2:\\n L, k = values\\n if len(values)==3:\\n L, k, W = values\\n\\n if withRescale:\\n if len(values)==2:\\n lb = names + \\\"=\\\"\\n lb += str(values[0])\\n if pow10first:\\n lb += r\\\", $10^{%d}$\\\" %(int(round(numpy.log10(1.0*k/L))))\\n else:\\n lb += \\\", %.3e\\\" %(1.0*k/L)\\n if len(values)==3:\\n lb = r\\\"$k, W_s =$\\\"\\n #lb += str(L)\\n if pow10first:\\n lb += r\\\"$10^{%d}$\\\" %(int(round(numpy.log10(1.0*k/L))))\\n else:\\n lb += \\\"%.2e\\\" %(1.0*k/L)\\n lb += \\\",%.2f\\\" %(W*(1.0*k/L)**sigma)\\n #lb += str(W)\\n #lb += \\\",%.3e\\\" %((1.0*k/L)**(-sigma)/L)\\n #for nm, val in zip(a,b):\\n # exec(nm + \\\"= \\\" + str(val))\\n #if len(values) == 2:\\n # lb += str(1.0*k/L)**sigma\\n #elif len(values) == 3:\\n # lb += str((1.0*k/L)**sigma*W)[0:5]\\n return lb\",\n \"def quote_scaled(term: str):\\n if has_scaled(term):\\n return (True, quote_poly_term(before_scaled(term)))\\n else:\\n return (False, quote_poly_term(term))\",\n \"def test_patch_namespaced_scale_scale(self):\\n pass\",\n \"def temperature_scale(self) -> str:\\r\\n self._logger.debug(log_message_formatter(\\r\\n \\\"get\\\", f\\\"{self}\\\", \\\"temperature_scale\\\"))\\r\\n return self._temperature_scale\",\n \"def normalize_label(labels):\\n max_val = torch.max(labels)\\n min_val = torch.min(labels)\\n norm_labels = (labels - min_val)/(max_val - min_val)\\n return norm_labels\",\n \"def fix_label(label):\\n\\n replace_dict = {'_': ' ',\\n 'degE': '$^{\\\\circ}$E',\\n 'ms-1': '$m s^{-1}$',\\n 'm.s-1': '$m s^{-1}$',\\n 'Wm-2': '$W m^{-2}$',\\n '1000000 m2.s-1': '$10^6$m$^2$s$^{-1}$'\\n } \\n\\n for value, replacement in list(replace_dict.items()):\\n label = label.replace(value, replacement)\\n\\n return label\",\n \"def dim_unit_scaling(in_unit, out_unit):\\n\\n unit_vals = {\\n 'nm': 1e-9,\\n 'um': 1e-6,\\n 'mm': 1e-3,\\n 'cm': 1e-2,\\n 'm': 1.0,\\n 'km': 1e3,\\n }\\n\\n if in_unit not in unit_vals:\\n raise ValueError(\\n 'Invalid input unit {}. Must be one of {}'.format(\\n in_unit, list(unit_vals.keys())\\n )\\n )\\n if out_unit not in unit_vals:\\n raise ValueError(\\n 'Invalid input unit {}. Must be one of {}'.format(\\n in_unit, list(unit_vals.keys())\\n )\\n )\\n\\n return unit_vals[in_unit]/unit_vals[out_unit]\",\n \"def unsetScale(self):\\n return _libsbml.Unit_unsetScale(self)\",\n \"def testStringInput(self):\\n nb.rescale_length(\\\"2.0\\\")\\n self.assertEqual(2.0, nb.rscale)\",\n \"def normalisesym(self, label):\\n return label\",\n \"def convert_qty (qty,unit,ing) :\\n portion_presence = False\\n try :\\n div = re.search(r\\\"[^ \\\\w]\\\", qty).start()\\n portion = float(qty[div-1]) / float(qty[div+1])\\n qty_float=portion\\n portion_presence = True\\n qty = qty[:div-1]\\n except :\\n try : \\n qty_float = float(qty)\\n except :\\n qty_float = 10\\n\\n if portion_presence == True :\\n if len(qty) > 0 :\\n qty_float += float(qty[:div-2])\\n \\n #use the unit to have in ml\\n #qty_float*=conversion_unit[unit]\\n \\n #convert in grammes with the database of density\\n #qty_float*=density[ing]\\n \\n return qty_float\",\n \"def scale_ticks_params(tick_scale='linear'):\\n if tick_scale == 'linear':\\n base = None\\n label_scale = 'Linear Scale'\\n else:\\n if tick_scale == 'log2':\\n base = 2\\n label_scale = 'Log2 Scale'\\n elif tick_scale == 'log10':\\n base = 10\\n label_scale = 'Log10 Scale'\\n else:\\n raise ValueError('The specified tick scale is not supported.')\\n return base, label_scale\",\n \"def scale(self):\\n return self._scale\",\n \"def getxscale(self) -> int:\\n if not self.debug:\\n # TODO: Verificar\\n self.myFieldFox.write(\\\"TRAC:SPEC:AMPL:SCAL?\\\")\\n ret = self.myFieldFox.read()\\n else:\\n ret = 'LOG'\\n return ret\",\n \"def get_KE(p, scale= 1):\\n p = p.flatten()\\n return scale * 0.5*np.sum(np.multiply(p, p))\",\n \"def get_scale_freq():\\n return sf / 2 / (num_freq-1)\",\n \"def scale(self):\\n return self.distribution.scale\",\n \"def latex_of_unit(quant):\\n return _latex_from_dimensionality(quant.dimensionality).strip(\\\"$\\\")\",\n \"def convert_scale(g, op, block):\\n\\n scale = op.attr(\\\"scale\\\")\\n bias = op.attr(\\\"bias\\\")\\n bias_after_scale = op.attr(\\\"bias_after_scale\\\")\\n x = g.get_node(op.input(\\\"X\\\")[0])\\n if np.isclose(scale, 1.0) and np.isclose(bias, 0.0):\\n out = x\\n else:\\n if np.isclose(bias, 0.0):\\n out = x * _expr.const(np.array(scale).astype(\\\"float32\\\"))\\n elif np.isclose(scale, 1.0):\\n out = x + _expr.const(np.array(bias).astype(\\\"float32\\\"))\\n else:\\n if bias_after_scale:\\n out = x * _expr.const(np.array(scale).astype(\\\"float32\\\")) + _expr.const(\\n np.array(bias).astype(\\\"float32\\\")\\n )\\n else:\\n out = (x + _expr.const(np.array(bias).astype(\\\"float32\\\"))) * _expr.const(\\n np.array(scale).astype(\\\"float32\\\")\\n )\\n g.add_node(op.output(\\\"Out\\\")[0], out)\",\n \"def get_scale(units, compartmentId, volume, extracellularVolume):\\r\\n if compartmentId == 'c':\\r\\n V = volume\\r\\n else:\\r\\n V = extracellularVolume\\r\\n\\r\\n if units == 'uM':\\r\\n return 1. / N_AVOGADRO / V * 1e6\\r\\n elif units == 'mM':\\r\\n return 1. / N_AVOGADRO / V * 1e3\\r\\n elif units == 'molecules':\\r\\n return 1.\\r\\n else:\\r\\n raise Exception('Invalid units \\\"%s\\\"' % units)\",\n \"def unit_converter(val, from_u, to_u):\\n\\tconverter = {'b':0, 'k':1, 'm':2, 'g':3, 't':4}\\n\\tif converter[from_u] < converter[to_u]:\\n\\t\\tval = float(val)\\n\\t\\tfor _ in range(converter[to_u] - converter[from_u]):\\n\\t\\t\\tval = val/1024\\n\\telse:\\n\\t\\tfor _ in range(converter[from_u] - converter[to_u]):\\n\\t\\t\\tval = val * 1024\\n\\t\\t\\t\\n\\treturn val\",\n \"def convert(self):\\n return _libsbml.SBMLUnitsConverter_convert(self)\",\n \"def scale(self):\\n return self._gev_bijector.scale\",\n \"def Scale(*args, **kwargs):\\n return _gdi_.Font_Scale(*args, **kwargs)\",\n \"def unit(self) -> str:\",\n \"def freqscale(self):\\n index = self._ordered_input_names.index('freqscale')\\n return self._inputs[index]\",\n \"def norm(self, label):\\n label_vec = []\\n label_value = self.to_int(label)\\n for i in range(10):\\n if i == label_value:\\n label_vec.append(0.9)\\n else:\\n label_vec.append(0.1)\\n return label_vec\",\n \"def human_m(v):\\n if v < 1e-2:\\n return (v*1.0e3, 'mm')\\n if v < 1:\\n return (v*1.0e2, 'cm')\\n if v < 1000:\\n return (v, 'm')\\n return (v/1.0e3, 'km')\",\n \"def scale(self, factor):\\n for a in self.symbol_attributes:\\n a.scale(factor)\",\n \"def transform(self, X):\\r\\n X[(X == 'Large') | (X == 'Medium')] = 'Large / Medium'\\r\\n return X\",\n \"def transform(self, X):\\r\\n X[(X == 'Large') | (X == 'Medium')] = 'Large / Medium'\\r\\n return X\",\n \"def get_tempscale(self, text=False):\\n if text:\\n return text_tscale[self.tempscale]\\n return self.tempscale\",\n \"def label (x):\\n\\n if x == 0:\\n return None\\n if x == 1:\\n return Fraction(0)\\n b = bin(x)[2:]\\n s = b[1]\\n wf = re.compile(r'^.({}+)(.*)$'.format(s))\\n w,f = wf.findall(b)[0]\\n p = 1 if s == '1' else -1\\n n = p * Fraction(len(w),1)\\n scale = Fraction(1,1)\\n while len(f):\\n scale /= 2\\n if f[0] == '1':\\n n += scale\\n else:\\n n += -scale\\n f = f[1:]\\n return n\",\n \"def convert(self):\\n return _libsbml.SBMLInferUnitsConverter_convert(self)\",\n \"def get_label(urs):\\n return assign_term(urs)[1]\",\n \"def yscale(value):\\n impl.yscale(**locals())\",\n \"def convert_shape_to_units(self, shape):\\n unit_factor = [GDS[\\\"unit\\\"][0]] * 2\\n ll=shape[0].scale(unit_factor)\\n ur=shape[1].scale(unit_factor)\\n return [ll,ur]\",\n \"def on_scale_changed(self):\\n\\n options = self.get_options()\\n\\n label = \\\"Result: {0}x{1}\\\".format(int(options[\\\"width\\\"]),\\n int(options[\\\"height\\\"]))\\n\\n self.scale_result.setText(label)\",\n \"def _get_unit_factor(self, unit: str) -> np.ndarray:\\n\\n unit_factors = {\\n 'vx': np.array((1, 1, 1)),\\n 'nm': np.array(self.parameters.scale),\\n 'um': np.array(self.parameters.scale)/1000\\n }\\n assert unit in unit_factors.keys(), 'Invalid unit'\\n unit_factor = unit_factors[unit]\\n\\n return unit_factor\",\n \"def _adjust_scale(self, value):\\n if self._min_val <= value <= self._max_val:\\n self._scale_var.set(value)\\n self.update_label_text()\",\n \"def get_timescale(self, text=False):\\n if text:\\n return text_timescale[self.timescale]\\n return self.timescale\",\n \"def label(self, decimals=None, base_label=None, cache=None):\\n return super().label(decimals=decimals, base_label=base_label or \\\"∏_ϕ\\\", cache=cache)\",\n \"def enlabel(mi_, ma_):\\n\\treturn \\\"Unicode characters from {} to {} codepoints\\\".format(mi_, ma_)\",\n \"def uc(p) :\\r\\n return Components(p, Scale=2)\",\n \"def scaling(self):\\n \\n if self.colindex == self.rowsize: # last chart in row\\n self.colindex = 0\\n self.rowindex += 1 \\n xorigin = self.indent + (self.colindex * self.xscale) \\n yorigin = self.rowindex * self.yscale\\n xscale = self.xscale # to fulfil % formatting below\\n yscale = self.yscale \\n self.colindex += 1\\n\\n res = \\\"origin(%(xorigin)s%%, %(yorigin)s%%), scale(%(xscale)s%%, %(yscale)s%%)\\\" % locals()\\n return res\",\n \"def native_unit_of_measurement(self) -> str:\\n return f\\\"{CURRENCY_CENT}/{UnitOfVolume.LITERS}\\\"\",\n \"def sequence_scale(scale, scale_sequence):\\n factor = math.floor(math.log10(scale))\\n norm = scale / (10**factor)\\n\\n for s in scale_sequence:\\n if norm <= s:\\n return s * 10**factor\\n return scale_sequence[0] * 10**(factor + 1)\",\n \"def unit_of_measurement(self):\\n return \\\"%\\\"\",\n \"def test_jy_to_mk_units():\\n test_fq = np.array([0.1]) * units.GHz\\n jy_to_mk = utils.jy_to_mk(test_fq)\\n test_conversion = const.c**2 / (2 * test_fq.to(\\\"1/s\\\") ** 2 * const.k_B) * units.sr\\n test_conversion = test_conversion.to(\\\"mK*sr/Jy\\\")\\n assert test_conversion.unit.to_string() == jy_to_mk.unit.to_string()\",\n \"def scale_value(self):\\n return self._scale_value[2]\",\n \"def add_scale(self, scale=None, label=None, *, loc=\\\"auto\\\", color=\\\"k\\\", fontsize=\\\"x-small\\\"):\\n if scale is None:\\n scale = 5\\n else:\\n # convert to display units\\n scale = scale * self.factor_for(self.projection[0])\\n\\n if label is None:\\n unit = self.display_unit_for(self.projection[0])\\n label = f\\\"{scale:g} {unit}\\\"\\n\\n return super(FloorPlot, self).add_scale(\\n self.ax, scale, label=label, loc=loc, color=color, fontsize=fontsize\\n )\",\n \"def scale(self, value):\\r\\n return (float(value)-float(self.minimum))/float(self.maximum-self.minimum)*2.0 - 1.0\",\n \"def _to_large_medium(self, value):\\r\\n if value == 'Medium' or value == 'Large':\\r\\n return 'Large / Medium'\\r\\n else:\\r\\n return value\",\n \"def _to_large_medium(self, value):\\r\\n if value == 'Medium' or value == 'Large':\\r\\n return 'Large / Medium'\\r\\n else:\\r\\n return value\",\n \"def vm(x):\\r\\n return str(x) + 'mm'\",\n \"def useUnits():\",\n \"def to_units(number):\\n unit = 0\\n while number >= 1024.:\\n unit += 1\\n number = number / 1024.\\n if unit == len(UNITS) - 1:\\n break\\n if unit:\\n return '%.2f%s' % (number, UNITS[unit])\\n return '%d' % number\",\n \"def scale_pos(q_unsc):\\n q_sc = (q_unsc - 0.125)/0.125\\n return q_sc\",\n \"def to_base_unit(val: float, unit: str = \\\"\\\") -> float:\\n unit_scalar = UNITS.get(unit, None)\\n if not unit_scalar:\\n raise UnknownUnitError(f\\\"Unit '{unit}' is not supported\\\")\\n\\n return val * unit_scalar\",\n \"def _fix_units(cube, definition):\\n\\n if cube.var_name != 'pr':\\n cube.convert_units(definition.units)\",\n \"def spice_unit_convert(valuet, restrict=[]):\\n # valuet is a tuple of (unit, value), where \\\"value\\\" is numeric\\n # and \\\"unit\\\" is a string. \\\"restrict\\\" may be used to require that\\n # the value be of a specific class like \\\"time\\\" or \\\"resistance\\\". \\n\\n # Recursive handling of '/' and multiplicatioon dot in expressions\\n if '/' in valuet[0]:\\n parts = valuet[0].split('/', 1)\\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\\n result /= numeric(spice_unit_convert([parts[1], \\\"1.0\\\"], restrict))\\n return str(result)\\n\\n if '\\\\u22c5' in valuet[0]:\\t# multiplication dot\\n parts = valuet[0].split('\\\\u22c5')\\n result = numeric(spice_unit_convert([parts[0], valuet[1]], restrict))\\n result *= numeric(spice_unit_convert([parts[1], \\\"1.0\\\"], restrict))\\n return str(result)\\n\\n if '\\\\u00b2' in valuet[0]:\\t# squared\\n part = valuet[0].split('\\\\u00b2')[0]\\n result = numeric(spice_unit_unconvert([part, valuet[1]], restrict))\\n result *= numeric(spice_unit_unconvert([part, \\\"1.0\\\"], restrict))\\n return str(result)\\n\\n if valuet[0] == \\\"\\\":\\t\\t# null case, no units\\n return valuet[1]\\n\\n for unitrec in unittypes:\\t# case of no prefix\\n if re.match('^' + unitrec + '$', valuet[0]):\\n if restrict:\\n if unittypes[unitrec] == restrict.lower():\\n return valuet[1]\\n else:\\n return valuet[1]\\n\\n for prerec in prefixtypes:\\n for unitrec in unittypes:\\n if re.match('^' + prerec + unitrec + '$', valuet[0]):\\n if restrict:\\n if unittypes[unitrec] == restrict.lower():\\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\\n return str(newvalue)\\n else:\\n newvalue = numeric(valuet[1]) * prefixtypes[prerec]\\n return str(newvalue)\\n\\n # Check for \\\"%\\\", which can apply to anything.\\n if valuet[0][0] == '%':\\n newvalue = numeric(valuet[1]) * 0.01\\n return str(newvalue)\\n \\n if restrict:\\n raise ValueError('units ' + valuet[0] + ' cannot be parsed as ' + restrict.lower())\\n else:\\n # raise ValueError('units ' + valuet[0] + ' cannot be parsed')\\n # (Assume value is not in SI units and will be passed back as-is)\\n return valuet[1]\",\n \"def default_units(x, axis):\\n # In the case where the first matplotlib command is setting limits,\\n # x may be a tuple of length two (with the same units).\\n if isinstance(x, tuple):\\n name = getattr(x[0], \\\"name\\\", \\\"\\\")\\n units = x[0].units\\n else:\\n name = getattr(x, \\\"name\\\", \\\"\\\")\\n units = x.units\\n\\n # maintain a mapping between Axis and name since Axis does not point to\\n # its underlying data and we want to propagate the name to the axis\\n # label in the subsequent call to axisinfo\\n unyt_arrayConverter._axisnames[axis] = name if name is not None else \\\"\\\"\\n return units\",\n \"def _tidyup_labels(self, labels: Sequence[str]) -> Sequence[str]:\\n\\n def remove_zeroes(s: str) -> str:\\n \\\"\\\"\\\"\\n Remove unnecessary zeros for float string s\\n \\\"\\\"\\\"\\n tup = s.split(\\\"e\\\")\\n if len(tup) == 2:\\n mantissa = tup[0].rstrip(\\\"0\\\").rstrip(\\\".\\\")\\n exponent = int(tup[1])\\n if exponent:\\n s = \\\"%se%d\\\" % (mantissa, exponent)\\n else:\\n s = mantissa\\n return s\\n\\n def as_exp(s: str) -> str:\\n \\\"\\\"\\\"\\n Float string s as in exponential format\\n \\\"\\\"\\\"\\n return s if \\\"e\\\" in s else \\\"{:1.0e}\\\".format(float(s))\\n\\n def as_mathtex(s: str) -> str:\\n \\\"\\\"\\\"\\n Mathtex for maplotlib\\n \\\"\\\"\\\"\\n if \\\"e\\\" not in s:\\n assert s == \\\"1\\\", f\\\"Unexpected value {s = }, instead of '1'\\\"\\n return f\\\"${self.base}^{{0}}$\\\"\\n\\n exp = s.split(\\\"e\\\")[1]\\n return f\\\"${self.base}^{{{exp}}}$\\\"\\n\\n # If any are in exponential format, make all of\\n # them expontential\\n has_e = [\\\"e\\\" in x for x in labels]\\n if not all(has_e) and sum(has_e):\\n labels = [as_exp(x) for x in labels]\\n\\n labels = [remove_zeroes(x) for x in labels]\\n\\n has_e = [\\\"e\\\" in x for x in labels]\\n if self.mathtex and any(has_e):\\n labels = [as_mathtex(x) for x in labels]\\n\\n return labels\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66115385","0.64944685","0.6276687","0.62619853","0.6258747","0.6168202","0.6106348","0.6104452","0.6032182","0.59474814","0.59472513","0.593621","0.5931593","0.591483","0.59085834","0.5896219","0.58899754","0.588468","0.58570886","0.5837348","0.5832844","0.58197284","0.58173925","0.57987094","0.5795785","0.5791935","0.57719576","0.5750965","0.5746385","0.5744292","0.5731548","0.57280165","0.5723024","0.5719639","0.5712984","0.5707073","0.5691654","0.56883717","0.5643382","0.56318533","0.5631286","0.56233203","0.56210583","0.5616291","0.5608231","0.5580789","0.55750066","0.55714655","0.5564321","0.55611527","0.5542536","0.5527664","0.5522432","0.5519277","0.5514172","0.5498539","0.54979795","0.54843456","0.5476058","0.5475074","0.5464759","0.54630286","0.54588366","0.54467714","0.5438548","0.5430175","0.5422709","0.5422709","0.54165477","0.5407259","0.5403315","0.53868634","0.53821313","0.53781956","0.5373035","0.5371227","0.53689885","0.53664184","0.5357477","0.53552645","0.5351983","0.5350985","0.534735","0.5344987","0.5339413","0.5336808","0.5323985","0.5322103","0.53218704","0.53171474","0.53171474","0.53158116","0.5311065","0.5308291","0.5302521","0.52982163","0.52860487","0.5281576","0.52768826","0.526764"],"string":"[\n \"0.66115385\",\n \"0.64944685\",\n \"0.6276687\",\n \"0.62619853\",\n \"0.6258747\",\n \"0.6168202\",\n \"0.6106348\",\n \"0.6104452\",\n \"0.6032182\",\n \"0.59474814\",\n \"0.59472513\",\n \"0.593621\",\n \"0.5931593\",\n \"0.591483\",\n \"0.59085834\",\n \"0.5896219\",\n \"0.58899754\",\n \"0.588468\",\n \"0.58570886\",\n \"0.5837348\",\n \"0.5832844\",\n \"0.58197284\",\n \"0.58173925\",\n \"0.57987094\",\n \"0.5795785\",\n \"0.5791935\",\n \"0.57719576\",\n \"0.5750965\",\n \"0.5746385\",\n \"0.5744292\",\n \"0.5731548\",\n \"0.57280165\",\n \"0.5723024\",\n \"0.5719639\",\n \"0.5712984\",\n \"0.5707073\",\n \"0.5691654\",\n \"0.56883717\",\n \"0.5643382\",\n \"0.56318533\",\n \"0.5631286\",\n \"0.56233203\",\n \"0.56210583\",\n \"0.5616291\",\n \"0.5608231\",\n \"0.5580789\",\n \"0.55750066\",\n \"0.55714655\",\n \"0.5564321\",\n \"0.55611527\",\n \"0.5542536\",\n \"0.5527664\",\n \"0.5522432\",\n \"0.5519277\",\n \"0.5514172\",\n \"0.5498539\",\n \"0.54979795\",\n \"0.54843456\",\n \"0.5476058\",\n \"0.5475074\",\n \"0.5464759\",\n \"0.54630286\",\n \"0.54588366\",\n \"0.54467714\",\n \"0.5438548\",\n \"0.5430175\",\n \"0.5422709\",\n \"0.5422709\",\n \"0.54165477\",\n \"0.5407259\",\n \"0.5403315\",\n \"0.53868634\",\n \"0.53821313\",\n \"0.53781956\",\n \"0.5373035\",\n \"0.5371227\",\n \"0.53689885\",\n \"0.53664184\",\n \"0.5357477\",\n \"0.53552645\",\n \"0.5351983\",\n \"0.5350985\",\n \"0.534735\",\n \"0.5344987\",\n \"0.5339413\",\n \"0.5336808\",\n \"0.5323985\",\n \"0.5322103\",\n \"0.53218704\",\n \"0.53171474\",\n \"0.53171474\",\n \"0.53158116\",\n \"0.5311065\",\n \"0.5308291\",\n \"0.5302521\",\n \"0.52982163\",\n \"0.52860487\",\n \"0.5281576\",\n \"0.52768826\",\n \"0.526764\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7126686"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21290,"cells":{"query":{"kind":"string","value":"Plot vertical and radial profiles for specified output directories."},"document":{"kind":"string","value":"def compare_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2013/output',\n\t\t\t\tsteps=['step01','step02'],\n\t\t\t\t#labels='',\n\t\t\t\tshow=True,\n\t\t\t\txscale=1e3,\n\t\t\t\tyscale=1e-2):\n\tplt.figure()\n\t#path = '/Users/scott/Desktop/elastic'\n\n\t# Deep source\n\tlabels = ['no APMB', 'APMB']\n\tdeep = {}\n\tuzmax = 0.824873455364\n\t# NOT sure why hardcoded...\n\tuzmax = 1\n\tfor i,outdir in enumerate(steps):\n\t\tpointsFile = os.path.join(path, outdir, 'points.h5')\n\n\t\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n\n\t\tX = x / xscale\n\t\tY1 = ux / yscale\n\n\t\tx_fem = X #/ xscale #double scaling!\n\t\tur_fem = Y1 #/ yscale\n\t\tuz_fem = uz / yscale\n\n\t\t#print(pointsFile)\n\t\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\n\n\t\t#normalize\n\t\tuz_fem = uz_fem / uzmax\n\t\tur_fem = ur_fem / uzmax\n\t\tx_fem = x_fem / 30.0\n\n\t\tl, = plt.plot(x_fem,uz_fem,'o-',ms=4,lw=4,label=labels[i])\n\t\tplt.plot(x_fem,ur_fem,'o--',ms=4,lw=4,color=l.get_color()) #mfc='none' transparent\n\t\tdeep[outdir] = uz_fem/uz_fem\n\n\n\t# Shallow Source\n\tshallow = {}\n\tuzmax = 0.949652827795 # Why?\n\tfor i,outdir in enumerate(['step11','step12']):\n\t\tpointsFile = os.path.join(path, outdir, 'points.h5')\n\n\t\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n\n\t\tX = x / xscale\n\t\tY1 = ux / yscale\n\n\t\tx_fem = X #/ xscale #double scaling!\n\t\tur_fem = Y1 #/ yscale\n\t\tuz_fem = uz / yscale\n\n\t\t#print(pointsFile)\n\t\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\n\n\t\t#normalize\n\t\tuz_fem = uz_fem / uzmax\n\t\tur_fem = ur_fem / uzmax\n\t\tx_fem = x_fem / 20.0\n\n\t\tl, = plt.plot(x_fem,uz_fem,'.-', mfc='w', lw=4,label=labels[i])\n\t\tplt.plot(x_fem,ur_fem,'.--',lw=4, mfc='w',color=l.get_color()) #mfc='none' transparent\n\n\t\tshallow[outdir] = uz_fem/ur_fem\n\n\t# Annotate\n\tplt.axhline(color='k',lw=0.5)\n\t#plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n\t#plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n\tplt.legend()\n\tplt.grid()\n\t#plt.ylim(-0.5, 3.5)\n\t#plt.savefig('deep.png',bbox_inches='tight')\n\t#plt.savefig('shallow.png',bbox_inches='tight')\n\n\t# normalized\n\tplt.ylim(-0.5, 4)\n\tplt.xlim(0,10)\n\tplt.xlabel('Normalized Radial Distance [R / D]')\n\tplt.ylabel('Normalized Displacement [U / Uz_max]')\n\t#plt.savefig('normalized_deep.png',bbox_inches='tight')\n\tplt.savefig('normalized_shallow.png',bbox_inches='tight')\n\n\n\t# Plot ratios of uz versus NOTE: this plot is confusing,,, just keep ratio of uz_max to ur_max\n\t'''\n\tplt.figure()\n\tplt.plot(x_fem, deep['step01'], label='Deep no APMB')\n\tplt.plot(x_fem, deep['step02'], label='Deep w/ APMB')\n\tplt.plot(x_fem, shallow['step11'], label='Shallow no APMB')\n\tplt.plot(x_fem, shallow['step12'], label='Shallow w/ APMB')\n\tplt.xlabel('Distance [km]') #NOTE: maybe plot normailzed X-axis (R-d)\n\t#plt.xlabel('Normalized Distance [R/d]')\n\tplt.ylabel('Ratio [Uz/Ur]')\n\tplt.title('Ratio of vertical to radial displacement')\n\tplt.legend()\n\tplt.show()\n\t'''"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def plot_directory_profiles(path, outname=None, show=True, xscale=1, yscale=1,\n xval='x', adjustRadial=True):\n outdirs = np.sort(os.listdir(path))\n plt.figure()\n\n #labels=['homogeneous','1D layering', '3D tomography'] #xscale=1e-3, yscale=1e2\n for i,outdir in enumerate(outdirs):\n pointsFile = os.path.join(path, outdir, 'points.h5')\n #print(pointsFile)\n #x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile, output='cyl',adjustRadial=adjustRadial)\n #x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile)\n #Load data\n\n x,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n #Y = uz / yscale\n if xval == 'x':\n X = x / xscale\n Y1 = ux / yscale\n elif xval == 'r':\n X = np.hypot(x,y) / xscale\n ur_fem = np.hypot(ux,uy)\n Y1 = ur_fem / yscale\n if adjustRadial: #fix sign from hypot square root\n ur_fem = pu.radial2negative(Y1)\n\n x_fem = X #/ xscale #double scaling!\n ur_fem = Y1 #/ yscale\n uz_fem = uz / yscale\n\n #print(pointsFile)\n print(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max())\n\n l, = plt.plot(x_fem,uz_fem,'.-',lw=3,label=outdir)\n #l, = plt.plot(x_fem,uz_fem,'.-',lw=2,label=labels[i]) #for 3d heterogeneity example\n plt.plot(x_fem,ur_fem,'.--',lw=3, mfc='w',color=l.get_color()) #mfc='none' transparent\n\n # Annotate\n plt.axhline(color='k',lw=0.5)\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n plt.legend()\n\n #NOTE: custom annotations for 3d heterogeneity\n #plt.title('Elastic Heterogeneity Effects')\n #plt.legend([l1,l2,l3],['homogeneous','1D layering', '3D tomography'])\n\n if outname: plt.savefig(outname)\n if show: plt.show()","def plot(profiler, outdir):\n # go through the outputs of all morphisms\n for cur_name, cur_output in profiler.profile.items():\n cur_outdir = os.path.join(outdir, cur_name)\n if not os.path.exists(cur_outdir):\n os.makedirs(cur_outdir)\n\n ProfilePlotter.plot_morphism_output(cur_output, cur_outdir)","def plot_morphism_output(data, outdir):\n\n # show the distributions for each variable separately\n for col in data.columns:\n ProfilePlotter._plot_1d(data[col], outfile = os.path.join(outdir, col + \".pdf\"))\n\n # later, maybe also show 2d plots etc.","def plot_directory_numex(path, vals, param='density', outname=None, show=True,\n xscale=1e-3,yscale=1e2):\n #vals = arange(2300.0, 2800.0, 50.0)\n outdirs = np.sort(os.listdir(path))\n plt.figure()\n\n # Plot surface profiles for each parameter\n for val,outdir in zip(vals,outdirs):\n pointsFile = os.path.join(path, outdir, 'points.h5')\n print(pointsFile)\n x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile, output=True, adjustRadial=True)\n x_fem = x_fem / xscale\n ur_fem = ur_fem / yscale\n uz_fem = uz_fem / yscale\n l, = plt.plot(x_fem,uz_fem,'.-',label=str(val))\n plt.plot(x_fem,ur_fem,'.-',color=l.get_color())\n\n # Annotate\n plt.axhline(color='k') #zero displacement line\n plt.title(param)\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n plt.legend()\n\n if outname: plt.savefig(outname)\n if show: plt.show()","def plot_profile(outdir, xval='x', xscale=1, yscale=1, comp2los=False, adjustRadial=False,\n fig=True):\n #Load data\n path = os.path.join(outdir,'points.h5')\n x,y,z,ux,uy,uz = pu.extract_points(path)\n\n Y = uz / yscale\n if xval == 'x':\n X = x / xscale\n Y1 = ux / yscale\n elif xval == 'r':\n X = np.hypot(x,y) / xscale\n ur = np.hypot(ux,uy)\n Y1 = ur / yscale\n if adjustRadial: #fix sign from hypot square root\n ur = pu.radial2negative(Y1)\n\n if fig:\n plt.figure()\n # otherwise profile added to active plot\n\n #plt.plot(X,uy/yscale,'r.-',label='Uy') #should be zero along EW axis\n de = 90e3 / xscale #eastern data extent\n if comp2los != False:\n data_extents = (X<=de)\n if comp2los == 'west': #switch sign of radial profile\n #ux = -ux #move to comp2los function\n X = -X\n Y1 = -Y1\n de = -de\n data_extents = (X>=de)\n\n los = pu.comp2los(x,ux,uy,uz,track=comp2los)\n plt.plot(X, los/yscale, 'k-', lw=2, label='Ulos_' + comp2los)\n plt.fill_between(X,los/yscale, where=data_extents, color='gray',alpha=0.5)\n\n plt.plot(X, Y, 'b-', lw=2, label='Uz')\n plt.plot(X, Y1, 'b--',lw=2, mfc='None',label='U{0}'.format(xval))\n\n # Annotate\n plt.title(outdir)\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n plt.ylabel('Uz [{}]'.format(get_unit(yscale)))\n plt.axhline(color='k')\n plt.axvline(de,color='k', linestyle='dashed', label='EW data extent') #EW extent of InSAR coverage\n plt.legend(loc='best')\n plt.grid(True)\n plt.show()","def plot_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2014/output',\n\t\t\t\tsteps=['step01','step02'],\n\t\t\t\t#labels='',\n\t\t\t\tshow=True,\n\t\t\t\txscale=1e3,\n\t\t\t\tyscale=1e-2):\n\tplt.figure()\n\t#path = '/Users/scott/Desktop/elastic'\n\n\t# Deep source\n\t#labels = ['no APMB', 'APMB']\n\t#if labels == '':\n\tlabels = steps\n\tdeep = {}\n\t#uzmax = 0.824873455364\n\t# NOT sure why hardcoded...\n\tuzmax = 1\n\tfor i,outdir in enumerate(steps):\n\t\tpointsFile = os.path.join(path, outdir, 'points.h5')\n\t\tprint(pointsFile)\n\t\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n\n\t\tX = x / xscale\n\t\tY1 = ux / yscale\n\n\t\tx_fem = X #/ xscale #double scaling!\n\t\tur_fem = Y1 #/ yscale\n\t\tuz_fem = uz / yscale\n\n\t\t#print(pointsFile)\n\t\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\n\n\t\t#normalize\n\t\tuz_fem = uz_fem / uzmax\n\t\tur_fem = ur_fem / uzmax\n\t\tx_fem = x_fem / 30.0\n\n\t\tl, = plt.plot(x_fem,uz_fem,'o-',ms=4,lw=4,label=labels[i])\n\t\tplt.plot(x_fem,ur_fem,'o--',ms=4,lw=4,color=l.get_color()) #mfc='none' transparent\n\t\tdeep[outdir] = uz_fem/uz_fem\n\n\t'''\n\t# Shallow Source\n\tshallow = {}\n\tuzmax = 0.949652827795\n\tfor i,outdir in enumerate(['step11','step12']):\n\t\tpointsFile = os.path.join(path, outdir, 'points.h5')\n\n\t\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n\n\t\tX = x / xscale\n\t\tY1 = ux / yscale\n\n\t\tx_fem = X #/ xscale #double scaling!\n\t\tur_fem = Y1 #/ yscale\n\t\tuz_fem = uz / yscale\n\n\t\t#print(pointsFile)\n\t\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\n\n\t#normalize\n\tuz_fem = uz_fem / uzmax\n\tur_fem = ur_fem / uzmax\n\tx_fem = x_fem / 20.0\n\n\t\tl, = plt.plot(x_fem,uz_fem,'.-', mfc='w', lw=4,label=labels[i])\n\t\tplt.plot(x_fem,ur_fem,'.--',lw=4, mfc='w',color=l.get_color()) #mfc='none' transparent\n\n\t\tshallow[outdir] = uz_fem/ur_fem\n\t'''\n\n\t# Annotate\n\tplt.axhline(color='k',lw=0.5)\n\t#plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n\t#plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n\tplt.legend()\n\tplt.grid()\n\t#plt.ylim(-0.5, 3.5)\n\t#plt.savefig('deep.png',bbox_inches='tight')\n\t#plt.savefig('shallow.png',bbox_inches='tight')\n\n\t# normalized\n\tplt.ylim(-0.5, 4)\n\tplt.xlim(0,10)\n\tplt.xlabel('Normalized Radial Distance [R / D]')\n\tplt.ylabel('Normalized Displacement [U / Uz_max]')\n\t#plt.savefig('normalized_deep.png',bbox_inches='tight')\n\tplt.savefig('normalized_shallow.png',bbox_inches='tight')\n\n\n\t# Plot ratios of uz versus NOTE: this plot is confusing,,, just keep ratio of uz_max to ur_max\n\t'''\n\tplt.figure()\n\tplt.plot(x_fem, deep['step01'], label='Deep no APMB')\n\tplt.plot(x_fem, deep['step02'], label='Deep w/ APMB')\n\tplt.plot(x_fem, shallow['step11'], label='Shallow no APMB')\n\tplt.plot(x_fem, shallow['step12'], label='Shallow w/ APMB')\n\tplt.xlabel('Distance [km]') #NOTE: maybe plot normailzed X-axis (R-d)\n\t#plt.xlabel('Normalized Distance [R/d]')\n\tplt.ylabel('Ratio [Uz/Ur]')\n\tplt.title('Ratio of vertical to radial displacement')\n\tplt.legend()\n\tplt.show()\n\t'''","def plot_one_directory(args, dirnames, figname):\n logdir = args.logdir\n num = len(ATTRIBUTES)\n fig, axes = subplots(num, figsize=(13,4*num))\n\n for (dd, cc) in zip(dirnames, COLORS):\n A = np.genfromtxt(join(logdir, dd, 'log.txt'), \n delimiter='\\t', \n dtype=None, \n names=True)\n x = A['Iterations']\n\n for (i,attr) in enumerate(ATTRIBUTES):\n axes[i].plot(x, A[attr], '-', lw=lw, color=cc, label=dd)\n axes[i].set_ylabel(attr, fontsize=ysize)\n axes[i].tick_params(axis='x', labelsize=tick_size)\n axes[i].tick_params(axis='y', labelsize=tick_size)\n axes[i].legend(loc='best', ncol=2, prop={'size':legend_size})\n\n axes[0].set_ylim([-10,10])\n axes[1].set_ylim([-10,10])\n axes[2].set_ylim([0,10])\n axes[3].set_ylim([0,10])\n\n plt.tight_layout()\n plt.savefig(figname)","def create_plots(self):\n if not os.path.exists(self.output_folder):\n os.makedirs(self.output_folder)\n self.sse_plot()\n self.avg_sse_plot()","def Plot(self):\n\n ### Create the path names ###\n folder_string = self.params.folder+\"/plots/\"\n u_string = self.params.folder+\"/plots/u.pdf\"\n p_string = self.params.folder+\"/plots/p.pdf\"\n\n ### Check if folder exists ###\n if not os.path.exists(folder_string): os.makedirs(folder_string)\n\n ### Plot the x component of velocity ###\n plot(self.u_next[0],title=\"Velocity in the x Direction\")\n plt.savefig(u_string)\n plt.figure()\n\n ### Plot the pressure ###\n plot(self.p_next,title=\"Pressure\")\n plt.savefig(p_string)\n plt.show()","def run_plots(self):\n # load the files\n self.pre_dark_file = os.path.join(self.input_dir, 'step_lastframe.fits')\n self.post_dark_file = os.path.join(self.input_dir, 'step_dark_current.fits')\n self.jump_file = os.path.join(self.input_dir, 'step_jump.fits')\n self.rate_file = os.path.join(self.input_dir, 'step_rate.fits')\n self.ramp_file = glob.glob(os.path.join(self.input_dir, '*.fits'))[0]\n\n # plots\n self.plot_jump_flags_image()\n self.plot_groupdq_flags(pixel=[884, 550])\n self.plot_ramps_pre_post_correction(pixel=[884, 550])","def plot_it(self, ui=None, res_dir=None):\r\n print_it(\"plotting results\")\r\n plt_profile(self.sun, PltOpts.DD.value, res_dir, SubDir.profiles.value)\r\n plt_profile(self.sun, PltOpts.DDD.value, res_dir, SubDir.profiles.value)\r\n plt_profile(self.planet, PltOpts.DD.value, res_dir,\r\n SubDir.profiles.value)\r\n plt_profile(self.planet, PltOpts.DDD.value, res_dir,\r\n SubDir.profiles.value)\r\n plt_profile_approx(res_dir, SubDir.profiles.value)\r\n plt_contact(self.sun, self.planet, PltOpts.DD.value, res_dir,\r\n SubDir.contacts.value)\r\n plt_contact(self.sun, self.planet, PltOpts.DDD.value, res_dir,\r\n SubDir.contacts.value)\r\n\r\n plt_3d(self.sun.x_axis, self.sun.y_axis, self.sun.press,\r\n self.sun.x_label, self.sun.y_label, 'pressure in MPa',\r\n 'contact_pressure_sun', res_dir, SubDir.pressures.value,\r\n 'contact_pressure_sun')\r\n plt_2d_scatt_line(self.sun.x_axis, self.pv, self.sun.x_axis, self.pv,\r\n self.sun.x_label,\r\n 'pv_rel in {}'.format(Unit.pvrel.value), 'pv_rel',\r\n res_dir, SubDir.energy.value, 'pv_rel')\r\n plt_2d_scatt_line(self.sun.x_axis, self.sun.e_akin, self.sun.x_axis,\r\n self.sun.e_akin, self.sun.x_label,\r\n 'e_akin in {}'.format(Unit.eakin.value), 'e_akin',\r\n res_dir, SubDir.energy.value, 'sun.e_akin')\r\n plt_2d_scatt_line(self.planet.x_axis, self.planet.e_akin,\r\n self.planet.x_axis, self.planet.e_akin,\r\n self.planet.x_label,\r\n 'e_akin in {}'.format(Unit.eakin.value), 'e_akin',\r\n res_dir,\r\n SubDir.energy.value, 'planet.e_akin')\r\n plt_energy_ring_on_ring(self, res_dir, SubDir.energy.value,\r\n 'e-akin-vs-pv-rel')","def main():\n\n\timport numpy as np\n\timport matplotlib as mpl\n\n\t# Parse arguments\n\targs = cli.parse_args()\n\n\t# Check all files exist\n\tfor filepath in args.files:\n\t\tif not os.path.isfile(filepath):\n\t\t\t_exit('file {} does not exist'.format(filepath))\n\n\t# Use TK interactive backend as it should work on all installations\n\tmpl.use('tkagg')\n\n\t# Turn on interactive plotting (pyplot import must come after call to use())\n\timport matplotlib.pyplot as plt\n\tplt.ion()\n\n\t# Get torsion angle arrays for all input files\n\tarrays = []\n\tfor filepath in args.files:\n\t\twith open(filepath) as fobj:\n\t\t\tchain = list(parse_pdb_chain(fobj))\n\t\t\tarrays.append(torsion_array(chain))\n\n\tangles = np.concatenate(arrays, axis=0)\n\n\t# Make the plot\n\tif args.plottype == 'hexbin':\n\t\thb = ramachandran_hexbin(angles, log=args.log, degrees=not args.radians)\n\t\tif args.cbar:\n\t\t\tplt.colorbar(hb)\n\n\telif args.plottype == 'scatter':\n\t\tramachandran_scatter(angles, degrees=not args.radians)\n\n\telif args.plottype == 'kde':\n\t\t_assert_seaborn_available('kde')\n\t\tramachandran_kdeplot(angles, shade=True, degrees=not args.radians)\n\n\telif args.plottype == 'joint':\n\t\t_assert_seaborn_available('joint')\n\t\tramachandran_jointplot(angles, kind='kde', degrees=not args.radians)\n\n\telse:\n\t\traise ValueError(args.plottype)\n\n\t# Plot title\n\tif len(args.files) == 1:\n\t\tfilename = os.path.basename(args.files[0])\n\telse:\n\t\tfilename = '{} files'.format(len(args.files))\n\n\tplt.gcf().suptitle('{} ({} residues)'.format(filename, angles.shape[0]))\n\n\t# Show the plot, blocking until closed\n\tplt.show(block=True)","def plot_potential_profile(rims_object):\r\n if not os.path.exists(rims_object.path_for_output):\r\n os.makedirs(rims_object.path_for_output)\r\n number_of_profiles = rims_object.potential_profile_mat.shape[0]\r\n x = [dx * pow(10, 4) for dx in rims_object.x_space_vec]\r\n fig, axs = plt.subplots(number_of_profiles)\r\n plt.suptitle('RIMS: Ratchet potential profiles', fontsize=14, fontweight='bold')\r\n\r\n for i_profile in range(number_of_profiles):\r\n y = [dy for dy in rims_object.potential_profile_mat[i_profile]]\r\n axs[i_profile].plot(x, y, color=YELLOW, label=\"V(x) potential profile\")\r\n axs[i_profile].tick_params(axis='y', labelcolor=YELLOW)\r\n ax2 = axs[i_profile].twinx()\r\n y = [dy * pow(10, -4) for dy in rims_object.electric_field_mat[i_profile]]\r\n ax2.plot(x, y, color=PURPLE, label=r\"E(x) electric field = -$\\nabla $V\")\r\n ax2.tick_params(axis='y', labelcolor=PURPLE)\r\n text_kwargs = dict(fontsize=10, color=YELLOW, fontweight='bold')\r\n fig.text(0.1, 0.91, 'V(x) potential profile [v]', text_kwargs)\r\n text_kwargs = dict(fontsize=10, color=PURPLE, fontweight='bold')\r\n fig.text(0.5, 0.91, r\"E(x) electric field = -$\\nabla $V [v/$\\mu $m]\", text_kwargs)\r\n axs[number_of_profiles-1].set_xlabel(r\"X [$\\mu $m]\")\r\n\r\n if number_of_profiles < 4:\r\n fig.tight_layout()\r\n plt.savefig(rims_object.path_for_output + 'Ratchet potential profiles.jpeg')\r\n plt.close()\r\n write_to_log(rims_object, \"potential profile plot saved\")\r\n return","def generate_plots(path):\n videos = glob(path + '/*.mkv')\n print(path, len(videos), videos)\n\n if len(videos) == 0:\n return\n else:\n videos = videos[0]\n\n metadata_list = glob(path + '/metadata.txt')\n #print(path, len(metadata_list), metadata_list)\n\n if len(metadata_list) == 0:\n return \n\n P = Preprocessor()\n P.import_video(str(videos))\n P.read_metadata(path)\n P.preprocess()\n Im = P.frames_processed\n if len(Im) == 0:\n print(len(Im))\n return\n\n z_start = P.z_start\n z_end = P.z_end\n\n mean, cov = analyze_image(Im)\n\n window_size = 10\n mean_smoothed = smoothing.mean_moving_average(mean, window_size)\n cov_smoothed = smoothing.cov_moving_average(cov, window_size)\n\n c = CubicFitRotated()\n c.fit(mean=mean_smoothed, cov=cov_smoothed, z_start=z_start, z_end=z_end)\n\n try:\n os.mkdir(path + '/analysis')\n path += '/analysis'\n except OSError:\n pass\n\n\n plots.plot_mean(mean, z_start, z_end).savefig(path + '/beam_center.png')\n plots.plot_beta(cov, z_start, z_end).savefig(path + '/sigma_squared.png')\n\n export.export_mean(mean = mean, filename = path + '/center.csv', z_start = z_start, z_end = z_end)\n export.export_cov(cov = cov, filename = path + '/cov.csv', z_start = z_start, z_end = z_end)\n\n plt.close('all')","def plot(self):\n\t\tplot_chain(self.database_path, self.temp_folder)\n\t\tplot_density(self.database_path, self.temp_folder, self.cal_params)","def plot_visualization(path_results, x_data, y_data, variant_mode, nb_classes, signal_test, args):\n\n\t#path_tsne = path_results + \"/Visualization/train/\" + str(args.step) + \"_2d.csv\"\n\t#data_frame = pd.read_csv(path_tsne)\n\t\n\tpath_maping = path_results + \"/Maping/\" + str(args.subject).split(\".txt\")[0] + \"/\"\n\tfilename = path_maping + \"maping_\" + str(args.step) + \"_\" + str(args.subject).split(\".txt\")[0] + \"_stick\" + str(args.stick) + \".png\"\n\n\tprint(\"path_save maping\", path_maping)\n\n\tif not os.path.exists(path_maping):\n\t\tos.makedirs(path_maping)\n\n\t#print(\"path_tsne\", path_tsne)\n\n\tlabel_maping = np.array([10])\n\n\tx_data = np.concatenate((x_data,signal_test),axis=0)\n\ty_data = np.concatenate((y_data,label_maping),axis=0)\n\n\tprint(\"x_data concatenate\",x_data.shape)\n\tprint(\"y_data concatenate\",y_data.shape)\n\n\tdata_frame = tsne_2d(x_data, y_data)\n\n\t\n\t\n\tgroups = data_frame.groupby('label')\n\n\tcluster_names, cluster_colors = get_target_names_dr(nb_classes, args.mode, args, variant_mode)\n\n\tfig = plt.figure(figsize=(20, 10))\n\tax = fig.add_subplot(111)\n\tax.margins(0.05) # Optional, just adds 5% padding to the autoscaling\n\tfor name, group in groups:\n\t\t\n\t\tif cluster_names[name] == str(args.subject):\n\t\t\tax.scatter(group.x, group.y, marker='D', s=150, edgecolors = 'face',label=cluster_names[name], color=cluster_colors[name])\n\t\telse:\n\t\t\tax.scatter(group.x, group.y, marker='o', label=cluster_names[name], color=cluster_colors[name])\n\n\tax.legend(numpoints=1) #show legend with only 1 point\n\tplt.savefig(filename) #save the plot","def plot_dat_file(dat_paths: [str]):\n import pandas as pd\n import matplotlib.pyplot as plt\n\n fig, ax = plt.subplots(1, 3, sharey=\"all\", sharex=\"col\", figsize=(8, 6))\n for i, dat_path in enumerate(dat_paths):\n if i == i:\n skipfoot = 11 + 9\n else:\n skipfoot = 11\n dat_file = pd.read_csv(\n dat_path,\n skiprows=3,\n skipfooter=skipfoot,\n header=None,\n delim_whitespace=True,\n engine=\"python\",\n )\n depth = dat_file.values[:, 0]\n vp = dat_file.values[:, 1]\n vs = dat_file.values[:, 3]\n dens = dat_file.values[:, 5]\n\n ax[0].plot(vp, depth, label=f\"nr {i}\")\n\n ax[1].plot(vs, depth)\n ax[2].plot(dens, depth)\n ax[0].set_ylim(ax[0].get_ylim()[::-1])\n ax[0].legend()\n plt.show()","def plot_directory_surface_rmse(path, vals, param='Vp'):\n\n unw = '/home/scott/data/insar/cvz/t2282/geo/geo_stack282_8rlks.unw'\n incidence = '/home/scott/data/insar/cvz/t2282/aux_files/geo_incidence_8rlks.unw'\n dem = '/home/scott/data/dems/cgiar/uturuncu_1000_1000.tif'\n #surface = '/home/scott/research/models/pylith/3d/uturuncu_layered/output/step01/surface.h5'\n #geosurface = '/home/scott/research/models/pylith/scripts/geo_fem_Uz.tif'\n\n plt.figure()\n outdirs = np.sort(os.listdir(path))\n\n # Calculate rmse\n rmse = np.zeros_like(vals)\n for i,outdir in enumerate(outdirs):\n surface = os.path.join(path,outdir,'surface.h5')\n los,fem_los,residual = pu.los2pylith(surface, dem, unw, incidence)\n rmse[i] = rms_flat(residual[np.isfinite(residual)])\n\n plt.plot(vals,rmse,'b.-')\n\n # Annotate\n #plt.title(param)\n plt.xlabel('{} [km]'.format(param))\n plt.ylabel('RMSE [cm]')\n plt.legend()\n plt.show()","def plot_results(dir_path):\n results, labels, dx = get_results_labels(dir_path)\n\n colors = plt.cm.get_cmap('tab10', len(labels)+1)\n fig = plt.figure(figsize=(16, 9))\n for i, (label, result) in enumerate(zip(labels, results)):\n plt.plot(np.arange(result.shape[1]) * dx, np.mean(result, 0),\n color=colors(i), linewidth=2, label=label)\n plt.fill_between(np.arange(len(result[0])) * dx,\n np.mean(result, 0) - np.std(result, 0),\n np.mean(result, 0) + np.std(result, 0),\n alpha=0.25, color=colors(i))\n plt.title('Training Performance of Different Algorithms', fontsize=25)\n plt.ylabel('Cumulative return', fontsize=20)\n plt.xlabel('Steps', fontsize=20)\n plt.xlim([0, results[0].shape[1] * dx])\n plt.tick_params(labelsize=15)\n plt.ticklabel_format(axis='both', style='sci', scilimits=(-2, 2))\n plt.legend(fontsize=20)\n plt.grid(linestyle=':')\n plt.show()\n\n return fig","def plot(cp_profile, *args, destination=\"browser\",\n show_profiles=True, show_observations=True, show_residuals=False, show_rugs=False,\n aggregate_profiles=None, selected_variables=None,\n color=None, size=2, alpha=0.4,\n color_pdps=None, size_pdps=None, alpha_pdps=None,\n color_points=None, size_points=None, alpha_points=None,\n color_residuals=None, size_residuals=None, alpha_residuals=None,\n height=500, width=600,\n plot_title='', yaxis_title='y',\n print_observations=True,\n **kwargs):\n\n params = dict()\n params.update(kwargs)\n params[\"variables\"] = _calculate_plot_variables(cp_profile, selected_variables)\n params['color'] = \"_label_\" if args else color\n params['show_profiles'] = show_profiles\n params['show_observations'] = show_observations\n params['show_rugs'] = show_rugs\n params['show_residuals'] = show_residuals and (cp_profile.new_observation_true is not None)\n params['add_table'] = print_observations\n params['height'] = height\n params['width'] = width\n params['plot_title'] = plot_title\n params['size_ices'] = size\n params['alpha_ices'] = alpha\n params = _params_update(params,\n color_pdps=color_pdps, size_pdps=size_pdps, alpha_pdps=alpha_pdps,\n size_points=size_points, alpha_points=alpha_points, color_points=color_points,\n size_residuals=size_residuals, alpha_residuals=alpha_residuals,\n color_residuals=color_residuals,\n yaxis_title=yaxis_title)\n\n if aggregate_profiles in {'mean', 'median', None}:\n params['aggregate_profiles'] = aggregate_profiles\n else:\n logging.warning(\"Incorrect function for profile aggregation: {}. Parameter ignored.\"\n \"Available values are: 'mean' and 'median'\".format(aggregate_profiles))\n params['aggregate_profiles'] = None\n\n all_profiles = [cp_profile] + list(args)\n\n plot_id = str(next(_PLOT_NUMBER))\n plot_path, params_path, obs_path, profile_path = _get_data_paths(plot_id)\n\n with open(params_path, 'w') as f:\n f.write(\"params = \" + json.dumps(params, indent=2) + \";\")\n\n save_observations(all_profiles, obs_path)\n save_profiles(all_profiles, profile_path)\n\n with app.app_context():\n data = render_template(\"plot_template.html\", i=plot_id, params=params)\n\n with open(plot_path, 'w') as f:\n f.write(data)\n\n destination = _detect_plot_destination(destination)\n if destination == \"notebook\":\n from IPython.display import IFrame, display\n display(IFrame(plot_path, width=int(width * 1.1), height=int(height * 1.1)))\n else:\n # open plot in a browser\n if sys.platform == \"darwin\": # check if on OSX\n plot_path = \"file://\" + os.path.abspath(plot_path)\n webbrowser.open(plot_path)","def combine_plot(qa_out_path,brain_path):\n \n #Get the scan volume of the brain.\n brain_ref = nib.load(brain_path)\n brain_ref_shape = brain_ref.shape[0:3]\n \n plots_list = ['Rotate_Z_axis_000000.png','Rotate_Z_axis_000001.png','Rotate_Z_axis_000002.png',\n 'Rotate_Y_axis_000000.png','Rotate_Y_axis_000001.png','Rotate_Y_axis_000002.png',\n 'Rotate_X_axis_000000.png','Rotate_X_axis_000001.png','Rotate_X_axis_000002.png']\n y_labels = [\"Rotate with Z axis\",\"Rotate with Y axis\",\"Rotate with X axis\"]\n x_labels = [\"angle=0\",\"angle=120\",\"angle=240\"]\n \n #Temporary list to store the image nparray:\n im_arr=[] \n \n fig= plt.figure()\n plt.title(f'QA_tractography. Scan volume = {brain_ref_shape} \\n\\n', fontsize=60,fontweight='bold')\n plt.xticks([])\n plt.yticks([])\n plt.axis(\"off\")\n\n j = 0\n for i in range(9):\n #Load in the nine images into a nparray one by one.\n im_arr = np.array(Image.open(qa_out_path + \"/\" + plots_list[i]))\n #Change the background of the image into black:\n im_arr = np.where(im_arr<=0.01, 255, im_arr) \n ax = fig.add_subplot(3,3,i+1)\n ax.imshow(im_arr,interpolation=\"none\",alpha=0.9)\n \n #Set the X labels and Y labels\n if i<3:\n ax.set_title(x_labels[i],fontsize=60,fontweight='bold')\n if i % 3 == 0:\n ax.set_ylabel(y_labels[j],fontsize=60,fontweight='bold')\n j = j + 1\n plt.xticks([])\n plt.yticks([])\n \n fig.set_size_inches(40, 40, forward = True)\n fig.savefig(qa_out_path + \"/\" + 'qa_tractography.png', format='png')\n\n #Delete the Nine images which used to generate the qa_tractography.png \n for plot in plots_list:\n if os.path.exists(qa_out_path + \"/\" + plot):\n os.remove(qa_out_path + \"/\" + plot)\n else:\n print('No such file generated from streamlines window. Please check if the streamline.trk files is generated from the pipeline correctly or not')","def matplotlib_plot(self, output_dir: Union[str, Path]):\n keys2 = set.union(*[set(self.get_keys2(k)) for k in self.get_keys()])\n for key2 in keys2:\n keys = [k for k in self.get_keys() if key2 in self.get_keys2(k)]\n plt = self._plot_stats(keys, key2)\n p = Path(output_dir) / f\"{key2}.png\"\n p.parent.mkdir(parents=True, exist_ok=True)\n plt.savefig(p)","def plot_parcles_run(k, v):\n\n L.info(f'Received Input: {v}')\n\n L.info(f\"Plotting results from: {v['filepath']}\")\n\n plotpath = Path(__file__).parent.parent / 'plots'\n filename = v['id'] + '.png'\n plotfile = str(plotpath / filename) \n\n plotTrajectoriesFile(v['filepath'], mode='2d', show_plt=False)\n f = plt.gcf()\n f.savefig(plotfile)\n\n L.info(f'Saved plot to: {plotfile}')","def plot_all_LLRs(self, outdir):\n\t\t#Iterate over all parameter groups\n\t\tfor group in self.group_names:\n\t\t\tself.plot_group_LLR(groupname=group, outdir=outdir)","def plot_track_rigidbody(params, datadir, pp=4, zoom=None):\n h = params['h']\n\n # get dirs\n xypath = sorted(glob.glob(datadir + 'xyv/'))[0]\n # list files\n xyfiles = sorted(glob.glob(xypath + '*.txt'))\n\n plt.clf()\n ax1 = plt.subplot(5, 1, 1)\n ax2 = plt.subplot(5, 1, 2)\n ax3 = plt.subplot(5, 1, 3)\n ax4 = plt.subplot(5, 1, 4)\n ax5 = plt.subplot(5, 1, 5)\n doall = range(0, len(xyfiles))\n for i in doall:\n iterind = (xyfiles[i].split('_')[-1]).split('.')[0]\n t = float(iterind) * h\n\n x, y, theta, phi, psi = np.loadtxt(xyfiles[i], delimiter=',', usecols=(0, 1, 2, 3, 4), unpack=True)\n # vX,vY,vtheta,vphi,vpsi = np.loadtxt(xyfiles[i],delimiter=',', usecols=(5,6,7,8,9), unpack=True)\n\n ax1.plot(t, x[pp], 'k.')\n ax2.plot(t, y[pp], 'r.')\n ax3.plot(t, theta[pp], 'r.')\n ax4.plot(t, phi[pp], 'r.')\n ax5.plot(t, psi[pp], 'g.')\n\n title = 'Tracking Single Gyro'\n ax1.set_title(title)\n ax5.set_xlabel('time')\n ax1.set_ylabel('X')\n ax2.set_ylabel('Y')\n ax3.set_ylabel(r'$\\theta$')\n ax4.set_ylabel(r'$\\phi$')\n ax5.set_ylabel(r'$\\psi$')\n\n ax1.set_xlim([-h, t])\n ax2.set_xlim([-h, t])\n ax3.set_xlim([-h, t])\n ax4.set_xlim([-h, t])\n ax5.set_xlim([-h, t])\n\n ax1.set_xticks([])\n ax2.set_xticks([])\n ax3.set_xticks([])\n ax4.set_xticks([])\n\n outname = datadir + 'Track.png'\n plt.savefig(outname)\n\n if zoom != None:\n ax1.set_xlim([-h, zoom])\n ax2.set_xlim([-h, zoom])\n ax3.set_xlim([-h, zoom])\n ax4.set_xlim([-h, zoom])\n ax5.set_xlim([-h, zoom])\n\n outname = datadir + 'Track_zoom.png'\n plt.savefig(outname)","def plot_pdf(pop_name, pop_val, pop_file, full_pop_file, outdir='.'):\n try:\n plt.style.use(\n \"https://gist.githubusercontent.com/avivajpeyi/4d9839b1ceb7d3651cbb469bc6b0d69b/raw/4ee4a870126653d542572372ff3eee4e89abcab0/publication.mplstyle\")\n except Exception:\n pass\n\n plt.close('all')\n all = pd.read_csv(full_pop_file, sep=\" \")\n all['cos_theta_1'] = all['cos_tilt_1']\n all = process_samples(all)\n sub = pd.read_csv(pop_file, sep=\" \")\n sub = process_samples(sub)\n sub['cos_theta_1'] = sub['cos_tilt_1']\n\n fig, axes = plt.subplots(1, 2, figsize=(10, 5))\n for ax, l in zip(axes, [\"cos_theta_1\", \"cos_theta_12\"]):\n ax.hist(all[l], density=True, histtype='step', color=\"tab:blue\", label=\"ALL\", lw=2, alpha=0.8)\n ax.scatter(all[l], [0 for _ in all[l]], color=\"tab:blue\",marker=\"+\")\n ax.hist(sub[l], density=True, histtype='step', color=\"tab:purple\", label=\"HIGH SNR\", lw=2, alpha=0.6)\n ax.scatter(sub[l], [0 for _ in sub[l]], color=\"tab:purple\", marker=\"+\")\n\n x = np.linspace(-1, 1, 100)\n y1 = TruncatedNormal(mu=1, sigma=pop_val[0], minimum=-1, maximum=1).prob(x)\n y2 = TruncatedNormal(mu=1, sigma=pop_val[1], minimum=-1, maximum=1).prob(x)\n axes[1].plot(x, y2, color='tab:gray', zorder=-10, lw=3, label=\"TRUE\")\n axes[0].plot(x, y1, color='tab:gray', zorder=-10, lw=3)\n\n for i in range(len(axes)):\n if (i == 0):\n axes[i].set_xlabel(r\"$\\cos\\ \\theta_1$\")\n axes[i].set_ylabel(\"PDF\")\n else:\n axes[i].set_xlabel(r\"$\\cos\\ \\theta_{12}$\")\n axes[i].set_yticklabels([])\n axes[i].legend()\n axes[i].grid(False)\n axes[i].set_xlim(-1, 1)\n\n plt.suptitle(f\"POP {pop_name}\")\n plt.tight_layout()\n plt.savefig(f\"{outdir}/pop_trues_{pop_name}.png\")","def plot_dir(main):\n try:\n wd = str(main.lineEdit_8.text())\n if wd == '':\n main.msg(\"Error \"+errorPath+\"plot_dir: Must choose directory first\")\n return\n for fi in os.listdir(wd):\n dataPath = os.path.join(wd, fi)\n main.msg(\"Plotting \"+str(fi))\n img = mpimg.imread(str(dataPath))\n imgObj = Img.Img(img, title=str(fi), filePath=str(dataPath))\n main.imgObjList.append(imgObj)\n func.update(main)\n slider.slider_update(main)\n except:\n main.msg(\"Error \"+errorPath+\"plot_dir: Make sure all files are images (tiff, jpeg, etc.)\")","def plot(path, subjects):\n transformToXYZmm = np.array([[-3.125, 0, 0, 81.250], [0, 3.125, 0, -115.625], [0, 0, 6, -54.000], [0, 0, 0, 1.000]])\n data = data_load.load_data(path, subjects)\n dimx = int(data[0][\"meta\"][\"dimx\"][0])\n dimy = int(data[0][\"meta\"][\"dimy\"][0])\n dimz = int(data[0][\"meta\"][\"dimz\"][0])\n coordToCol = data[0][\"meta\"][\"coordToCol\"][0][0]\n images = {}\n max_val = 0\n voxels = np.load(\"data/general_selected_500_1.npy\")\n directory = os.listdir(\"data/input/\")\n bar = pyprind.ProgBar(len(directory), title='Info extraction and Image Building')\n bar2 = pyprind.ProgBar(len(images.keys()), title='Saving Pictures')\n for file in directory:\n file_name = \"data/input/{}\".format(file)\n fh = open(file_name)\n activation_values = np.asarray(list(map(lambda x: float(x), filter(lambda x: x != '', fh.read().split(\",\")))))\n fh.close()\n plot_matrix = np.zeros((dimx, dimy, dimz))\n for x in range(dimx):\n for y in range(dimy):\n for z in range(dimz):\n indice = coordToCol[x][y][z]\n if indice != 0:\n if indice in list(voxels):\n voxel_indice = list(voxels).index(indice)\n value = activation_values[voxel_indice]\n if abs(value) > max_val:\n max_val = abs(value)\n plot_matrix[x][y][z] = value\n image = nib.Nifti1Image(plot_matrix, transformToXYZmm)\n images[file_name] = image\n bar.update(force_flush=True)\n print(bar)\n for image in images:\n plotting.plot_glass_brain(images[image], display_mode='ortho', vmax=max_val, plot_abs=False, threshold=None, colorbar=True, output_file=\"{}-wom1.png\".format(image))\n bar2.update(force_flush=True)\n print(bar2)","def plot_folder(folder, title, stochastic=True):\n results = open_folder(folder, stochastic=stochastic)\n assert len(results) > 0, 'Cannot find any results'\n ce_values = np.concatenate(\n [np.expand_dims(r.item()['train_xent'][:-1], 1) for r in results],\n axis=1)\n steps = np.concatenate(\n [np.expand_dims(r.item()['step'][:-1], 1) for r in results], axis=1)\n alpha_eff_values = np.concatenate(\n [\n np.expand_dims(r.item()['lr'] / (1.0 - r.item()['momentum']), 1)\n for r in results\n ],\n axis=1)\n condition = ['Manual', 'SMD']\n plot_report_figure_combined(\n steps,\n ce_values,\n alpha_eff_values,\n condition,\n title,\n 'Loss',\n 'Eff. Learning Rate',\n os.path.join(\n folder, 'combined_{}.pdf'.format('stoc' if stochastic else 'det')),\n include_legend=True)","def plot_PDs(output_path,M_max,max_dim,normalized=False,output_name=None):\n plots_folder = os.path.join(output_path,'plots')\n if output_name is None: \n aux = ['PDs']\n input_file = os.path.join(output_path,'outputs_PDS.csv')\n else:\n aux = [output_name,'PDs']\n input_file = os.path.join(output_path,'%s_PDS.csv' % output_name)\n if normalized is True:\n aux.append('normalized')\n plot_file_name = '-'.join(aux)+'.png'\n plot_file_name = os.path.join(plots_folder,plot_file_name)\n\n \n data = pd.read_csv(input_file,index_col = 0)\n \n\n fig_size_aux = 15/(3-max_dim)\n plt.figure(figsize=(fig_size_aux,5))\n if(normalized):\n for i in range(1,max_dim+2):\n plt.subplot(1,max_dim+1,i, aspect='equal')\n plt.plot(data[data.dimH==i-1].birth.values/np.float(M_max),data[data.dimH==i-1].death.values/np.float(M_max),'bo',alpha=.3,label='dim %i'%(i-1))\n plt.xlim((0,1)); plt.ylim((0,1))\n frame = plt.legend(loc=4,frameon=True,title='normalized')\n frame = frame.get_frame()\n frame.set_edgecolor('black')\n plt.xlabel('birth'); plt.ylabel('death')\n plt.plot([0, 1], [0, 1], ls=\"--\", c=\".3\")\n plt.suptitle('Persistence Diagrams')\n plt.savefig(plot_file_name)\n print 'Saved PDs plots in %s'%plot_file_name\n else:\n for i in range(1,max_dim+2):\n plt.subplot(1,max_dim+1,i, aspect='equal')\n plt.plot(data[data.dimH==i-1].birth.values,data[data.dimH==i-1].death.values,'bo',alpha=.3,label='dim %i'%(i-1))\n plt.xlim((0,M_max)); plt.ylim((0,M_max))\n frame = plt.legend(loc=4,frameon=True)\n frame = frame.get_frame()\n frame.set_edgecolor('black')\n plt.xlabel('birth'); plt.ylabel('death')\n plt.plot([0, M_max], [0, M_max], ls=\"--\", c=\".3\")\n plt.suptitle('Persistence Diagrams')\n plt.savefig(plot_file_name)\n print 'Saved PDs plots in %s'%plot_file_name\n return()","def plot_results(param_names, param_options, results, params):\n\n\t# circuit/run_num where run_num is one before the existing one\n\tdirectory = params.circuit\n\tif not os.path.isdir(directory):\n\t\tos.mkdir(directory)\n\truns = immediate_subdir(directory)\n\tlatest_run = 0\n\tif runs:\n\t\tnatural_sort(runs)\n\t\tlatest_run = get_trailing_num(runs[-1])\n\tdirectory = os.path.join(directory, \"run\" + str(latest_run+1))\n\n\tprint(directory)\n\tif not os.path.isdir(directory):\n\t\tos.mkdir(directory)\n\n\twith Chdir(directory):\n\n\t\texport_results_to_csv(param_names, results, params)\n\n\t\tx = results.keys()\n\t\ty = []\n\t\tnext_figure = True\n\n\t\tp = 0\n\t\tplt.figure()\n\t\twhile p < len(param_names):\n\t\t\tprint(param_names[p])\n\n\t\t\tif param_options[p]:\n\t\t\t\tnf = True\n\t\t\t\tfor option in param_options[p].split():\n\t\t\t\t\t# stopping has veto power (must all be True to pass)\n\t\t\t\t\tnf = nf and plot_options(option)\n\t\t\t\tnext_figure = nf\n\n\t\t\tif not next_figure:\n\t\t\t\t# y becomes list of lists (for use with stackable plots)\n\t\t\t\ty.append([result[p] for result in results.values()])\n\t\t\t\tp += 1\n\t\t\t\tcontinue\n\t\t\telif not y:\n\t\t\t\ty = [result[p] for result in results.values()]\n\n\t\t\tlx = x[-1]\n\t\t\tly = y[-1]\n\t\t\tplot_method(x,y)\n\t\t\tplt.xlabel('iteration')\n\t\t\tplt.xlim(xmin=0)\n\t\t\t\n\t\t\tplt.ylabel(param_names[p])\n\n\t\t\t# annotate the last value\n\t\t\tannotate_last(lx,ly)\n\n\t\t\tif next_figure:\n\t\t\t\tplt.savefig(param_names[p])\n\t\t\t\tplt.figure()\n\n\t\t\tp += 1\n\t\t# in case the last figure hasn't been shuffled onto file yet\n\t\tif not next_figure:\n\t\t\tplot_method(x,y)\n\t\t\tplt.savefig(param_names[-1])","def generateTrajectoryPlots(dir_path, traj_list, plot_name='scecliptic', plot_vg=True, plot_sol=True, \\\n plot_density=True, plot_showers=False):\n\n\n\n ### Plot Sun-centered geocentric ecliptic plots ###\n\n lambda_list = []\n beta_list = []\n vg_list = []\n sol_list = []\n\n shower_no_list = []\n shower_obj_dict = {}\n\n hypo_count = 0\n jd_min = np.inf\n jd_max = 0\n for traj in traj_list:\n\n # Reject all hyperbolic orbits\n if traj.orbit.e > 1:\n hypo_count += 1\n continue\n\n # Compute Sun-centered longitude\n lambda_list.append(traj.orbit.L_g - traj.orbit.la_sun)\n\n beta_list.append(traj.orbit.B_g)\n vg_list.append(traj.orbit.v_g/1000)\n sol_list.append(np.degrees(traj.orbit.la_sun))\n\n # Track first and last observation\n jd_min = min(jd_min, traj.jdt_ref)\n jd_max = max(jd_max, traj.jdt_ref)\n\n\n\n if plot_showers:\n\n # Perform shower association and track the list of all showers\n shower_obj = associateShowerTraj(traj)\n\n # If the trajectory was associated, sort it to the appropriate shower\n if shower_obj is not None:\n if shower_obj.IAU_no not in shower_no_list:\n shower_no_list.append(shower_obj.IAU_no)\n shower_obj_dict[shower_obj.IAU_no] = [shower_obj]\n else:\n shower_obj_dict[shower_obj.IAU_no].append(shower_obj)\n\n\n\n # Compute mean shower radiant for all associated showers\n shower_obj_list = []\n if plot_showers and shower_obj_dict:\n for shower_no in shower_obj_dict:\n\n # Check if there are enough shower members for plotting\n if len(shower_obj_dict[shower_no]) < MIN_SHOWER_MEMBERS:\n continue\n\n la_sun_mean = meanAngle([sh.la_sun for sh in shower_obj_dict[shower_no]])\n L_g_mean = meanAngle([sh.L_g for sh in shower_obj_dict[shower_no]])\n B_g_mean = np.mean([sh.B_g for sh in shower_obj_dict[shower_no]])\n v_g_mean = np.mean([sh.v_g for sh in shower_obj_dict[shower_no]])\n\n # Init a new shower object\n shower_obj_mean = MeteorShower(la_sun_mean, L_g_mean, B_g_mean, v_g_mean, shower_no)\n\n shower_obj_list.append(shower_obj_mean)\n\n\n\n print(\"Hyperbolic percentage: {:.2f}%\".format(100*hypo_count/len(traj_list)))\n\n # Compute the range of solar longitudes\n sol_min = np.degrees(jd2SolLonSteyaert(jd_min))\n sol_max = np.degrees(jd2SolLonSteyaert(jd_max))\n\n\n\n # Plot SCE vs Vg\n if plot_vg:\n plotSCE(lambda_list, beta_list, vg_list, (sol_min, sol_max), \n \"Sun-centered geocentric ecliptic coordinates\", \"$V_g$ (km/s)\", dir_path, plot_name + \"_vg.png\", \\\n shower_obj_list=shower_obj_list, plot_showers=plot_showers)\n\n\n # Plot SCE vs Sol\n if plot_sol:\n plotSCE(lambda_list, beta_list, sol_list, (sol_min, sol_max), \\\n \"Sun-centered geocentric ecliptic coordinates\", \"Solar longitude (deg)\", dir_path, \\\n plot_name + \"_sol.png\", shower_obj_list=shower_obj_list, plot_showers=plot_showers)\n \n\n \n # Plot SCE orbit density\n if plot_density:\n plotSCE(lambda_list, beta_list, None, (sol_min, sol_max), \n \"Sun-centered geocentric ecliptic coordinates\", \"Count\", dir_path, plot_name + \"_density.png\", \\\n density_plot=True, shower_obj_list=shower_obj_list, plot_showers=plot_showers)","def plot_directory_surface(path,figsize=(17,11), comp=2, nrow=1, norm=None,\n cbar='each', cloc='top', outname=None, labels='1', show=True):\n outdirs = np.sort(os.listdir(path))\n nplots = len(outdirs)\n ncol = np.ceil(nplots/nrow).astype(np.int)\n fig = plt.figure(figsize=figsize)\n\n grid = ImageGrid(fig, 111, # similar to subplot(111)\n nrows_ncols = (nrow, ncol),\n direction=\"row\",\n axes_pad = 0.25,\n add_all=True,\n label_mode = labels, #'all', 'L', '1'\n share_all = True,\n cbar_location=cloc, #top,right\n cbar_mode=cbar, #each,single,None\n cbar_size=0.1,#\"7%\",\n cbar_pad=0.0#,\"1%\",\n )\n\n #NOTE: if cbar='single',cloc='right', a way to automatically normalize by grid[0]\n #if normalize:\n # verts,data,tris = load_h5(os.path.join(path,'step01/surface.h5'))\n # if comp==3: #radial displacements\n # z = np.hypot(data[:,:,0], data[:,:,1]).flatten()\n # else:\n # z = data[:,:,comp].flatten()\n # norm = Normalize(vmin=np.nanmin(z), vmax=np.nanmax(z))\n #else:\n # norm=None\n\n for i,outdir in enumerate(outdirs):\n ax = grid[i]\n print(outdir)\n im = plotSurface(os.path.join(path,outdir,'surface.h5'), comp=comp, ax=ax,\n points=False, tris=False, profile=False, annotate=False, norm=norm,\n xscale=1e-3, yscale=1e-3)\n\n # colorbar settings, not sure what's up with set_xticks...\n ax.cax.colorbar(im)\n #cmin = np.nanmin(data)\n #cmax = np.nanmax(data)\n #ax.cax.set_xticks([cmin,0,cmax])\n\n # label upper left\n ax.text(0.05,0.95,outdir,\n weight='bold',\n ha='left',\n va='top',\n bbox=dict(facecolor='white'),\n transform=ax.transAxes)\n #ax.set_ylabel(outdir)\n #ax.tick_params(labelbottom=0,labeltop=0,labelleft=0,labelright=0,\n # bottom=0,top=0,left=0,right=0)\n\n #if cbar=='single':\n # grid[0].cax.colorbar(im)\n\n # Annotate Plot\n # don't show grid frames without data...\n Nextra = grid.ngrids - nplots\n if Nextra > 0:\n for ax in grid[-Nextra:]:\n #print(ax)\n ax.set_visible(False)\n ax.cax.set_visible(False)\n fig.suptitle(path, fontsize=14, fontweight='bold')\n if outname: plt.savefig(outname)\n if show: plt.show()","def plot_pipeline(differences_dir, plots_dir_intonation, num_quantiles = 31):\n perf_list = ['54363310_1939750539', '540791114_1793842568']\n difference_path_list = [os.path.join(differences_dir, perf_list[i] + \".npy\") for i in range(len(perf_list))]\n comparisons_list = [np.load(path) for _, path in enumerate(difference_path_list)]\n num_samples = 10000\n # quantile indices\n q_indices = (np.linspace(0, 1, num_quantiles)*(num_samples-1)).astype(np.int32)\n plt.style.use('ggplot')\n labels = ['perf. A', 'perf. B']\n colors = ['blue', 'red']\n linestyles = ['dotted', 'dashed']\n grid = plt.GridSpec(2, 2)\n ax1 = plt.subplot(grid[1, 0])\n ax2 = plt.subplot(grid[1, 1])\n ax4 = plt.subplot(grid[0, :])\n ax4.plot(comparisons_list[0], color=colors[0], label=labels[0], linestyle=linestyles[0])\n ax4.plot(comparisons_list[1], color=colors[1], label=labels[1], linestyle=linestyles[1])\n ax4.set_title(\"Difference between MIDI and pYIN, two performances\")\n ax4.set_ylabel(\"Cents\")\n ax4.set_xlabel(\"Frames\")\n ax4.axhline(y=200, linestyle=\"solid\", linewidth=0.7, c=\"black\", zorder=2, label=\"thresh.\")\n ax4.axhline(y=-200, linestyle=\"solid\", linewidth=0.7, c=\"black\", zorder=2)\n ax4.legend(loc=\"upper right\")\n ax1.set_title(\"10k random sample of distances\")\n ax1.set_ylabel(r\"$|$Cents$|$\")\n ax1.set_xlabel(\"Frames sorted by distance\")\n ax2.set_title(\"Sample quantiles\")\n ax2.set_xlabel(\"Quantile indices\")\n # run analysis song by song\n for i, arr in enumerate(comparisons_list):\n # random sample so all arrays have the same size\n samples = np.random.choice(arr, num_samples, replace=True)\n # sort\n samples = np.sort(np.abs(samples))\n # discard the high values (might be due to misalignment, etc...)\n samples = samples[samples <= 200]\n samples = np.random.choice(samples, num_samples, replace=True)\n samples = np.sort(np.abs(samples))\n ax1.plot(samples, color=colors[i], linestyle=linestyles[i], label=labels[i])\n # get the quantiles\n samples = samples[q_indices]\n ax2.plot(samples, color=colors[i], linestyle=linestyles[i], label=labels[i])\n ax1.legend()\n ax2.legend()\n plt.tight_layout()\n plt.savefig(os.path.join(plots_dir_intonation, \"data processing pipeline.eps\"), format=\"eps\")\n plt.show()","def plot(model, results, filename):\n\n # c = model.compartments.get_one(id='c')\n #\n # rna_1 = model.species_types.get_one(id='rna_1').species.get_one(compartment=c)\n # rna_2 = model.species_types.get_one(id='rna_2').species.get_one(compartment=c)\n # rna_3 = model.species_types.get_one(id='rna_3').species.get_one(compartment=c)\n #\n pops = results.get('populations')\n time = pops.index\n pop_rna_1 = pops['rna_1[c]']\n pop_rna_2 = pops['rna_2[c]']\n pop_rna_3 = pops['rna_3[c]']\n\n pop_atp = pops['atp[c]']\n pop_gtp = pops['gtp[c]']\n pop_utp = pops['ctp[c]']\n pop_ctp = pops['utp[c]']\n\n pop_amp = pops['amp[c]']\n pop_gmp = pops['gmp[c]']\n pop_ump = pops['cmp[c]']\n pop_cmp = pops['ump[c]']\n\n print(pop_rna_1, pop_atp, pop_gtp, pop_utp, pop_ctp)\n\n fig1, axes1 = pyplot.subplots(nrows=3, ncols=1)\n\n axes1[0].plot(time / 3600, pop_rna_1)\n axes1[0].plot(time / 3600, pop_rna_2)\n axes1[0].plot(time / 3600, pop_rna_3)\n axes1[0].set_xlim((time[0] / 3600, time[-1] / 3600))\n axes1[0].set_ylim((0., 10.0))\n axes1[0].legend(loc='upper right')\n\n axes1[1].plot(time / 3600, pop_atp)\n axes1[1].plot(time / 3600, pop_gtp)\n axes1[1].plot(time / 3600, pop_utp)\n axes1[1].plot(time / 3600, pop_ctp)\n axes1[1].set_xlim((time[0] / 3600, time[-1] / 3600))\n # axes1[1].set_ylim((0., 10.0))\n axes1[1].legend(loc='upper right')\n\n axes1[2].plot(time / 3600, pop_amp)\n axes1[2].plot(time / 3600, pop_gmp)\n axes1[2].plot(time / 3600, pop_ump)\n axes1[2].plot(time / 3600, pop_cmp)\n axes1[2].set_xlim((time[0] / 3600, time[-1] / 3600))\n # axes1[2].set_ylim((0., 10.0))\n axes1[2].legend(loc='upper right')\n\n fig1.savefig(filename.format('species'))\n pyplot.close(fig1)","def app_SN_combined_moisture_series(self, dfs, phase_dirs, sizer_val, styler_val):\n\n print('Currently plotting plot_SN_combined_moisture_series')\n\n for df, direc in zip(dfs, phase_dirs):\n # this iterates one or multiple times\n self.plotter.plot_SN_combined_moisture_series(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['01_combined_plots'],\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\n styler=self.formatter.styler[styler_val]\n )\n self.plotter.plot_SN_combined_moisture_series(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['01_combined_plots'],\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\n styler=self.formatter.styler[styler_val],\n xaxis_type='datetime'\n )\n\n print('Done\\n')","def plot_visco_profiles(pointsh5, skip=slice(None,None,1), xscale=1e3, yscale=1e-2, tscale=3.1536e7, adjustRadial=False, benchmark=[], title=None):\n\tplt.figure()\n\n\tcoords,data,number,times = pu.load_h5_visco(pointsh5)\n\n\t#x = 1e3*np.loadtxt(points,usecols=[0]) # output_points2.txt\n\t#y = np.zeros_like(x)\n\tx = coords[:,0]\n\ty = np.zeros_like(x)\n\n\t# NOTE: plot elastic solution by passing dictionary as showelastic\n\t# Plot analytic elastic solution (t=0)\n\t#print(benchmark)\n\tif len(benchmark)>=1:\n\t\tur = zeros_like(x)\n\t\tuz = np.zeros_like(x)\n\t\tfor b in benchmark:\n\t\t\turi,uzi = m.calc_mogi_dp(x,y,**params)\n\t\t\tur += uri\n\t\t\tuz += uzi\n\t\tplt.plot(x*xscale,uz*yscale,'ko',label='benchmark')\n\n\t# Convert units\n\t#ur = np.hypot(data[:,:,0], data[:,:,1]) #assume progiles are along EW profile\n\tur = data[:,:,0]\n\tuz = data[:,:,2]\n\tx = x / xscale\n\tur = ur / yscale #cm\n\tuz = uz / yscale #cm\n\ttimes = times / tscale\n\t#times = times / 8.64e4 #days\n\t#times = times / 31536000 #years\n\n\t#plots = np.arange(0,times.size,skip)\n\t#print(plots.size)\n\t#way to cycle through markers if plotting many lines\n\t#marker = itertools.cycle(['o','^','s','D']) #plot(marker=marker.next() iterates list)\n\t#way to use gradually changing colors from a colormap\n\t#color = plt.cm.jet(1.0*i/plots.size)\n\tindplots = np.arange(times.size-1)\n\tprint(indplots)\n\tindplots = indplots[skip]\n\tprint(indplots)\n\tfor i in indplots:\n\t\tline, = plt.plot(x, uz[i], color=plt.cm.jet(1.0*i/indplots[-1]), label='{:.1f}'.format(times[i]))\n\t\tplt.plot(x, ur[i], ls='dashed', color=line.get_color())\n\t#print uz[i]\n\t#print uz[i-1]\n\n\tif title:\n\t\tplt.title(title)\n\telse:\n\t\tplt.title(pointsh5)\n\n\tplt.axhline(color='k',linestyle='dashed')\n\tplt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n\tplt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n\tplt.show()\n\tplt.legend(title='{}'.format(get_unit(tscale)))\n\tplt.grid()","def multi_plot(self, plottitle, gof_fileroot, indir, outdir,\n legends, num_stations):\n # Pick components and labels\n xtick_loc = XTICK_LOC_0_01\n xtick_label = XTICK_LABEL_0_01\n\n # Initialize data arrays\n periods = [[] for _ in range(len(gof_fileroot))]\n bias = [[] for _ in range(len(gof_fileroot))]\n m90 = [[] for _ in range(len(gof_fileroot))]\n p90 = [[] for _ in range(len(gof_fileroot))]\n sigma = [[] for _ in range(len(gof_fileroot))]\n sigma0 = [[] for _ in range(len(gof_fileroot))]\n\n bias_l = [[] for _ in range(len(gof_fileroot))]\n bias_h = [[] for _ in range(len(gof_fileroot))]\n conf_l = [[] for _ in range(len(gof_fileroot))]\n conf_h = [[] for _ in range(len(gof_fileroot))]\n\n # Read data from all input files\n for compnum in xrange(0, len(gof_fileroot)):\n filenamebase = os.path.join(indir, gof_fileroot[compnum])\n #print(\"Reading component files %s.*\" % (filenamebase))\n periods[compnum], bias[compnum] = self.read_data(\"%s.bias\" %\n (filenamebase),\n 0.01)\n periods[compnum], m90[compnum] = self.read_data(\"%s.m90\" %\n (filenamebase),\n 0.01)\n periods[compnum], p90[compnum] = self.read_data(\"%s.p90\" %\n (filenamebase),\n 0.01)\n periods[compnum], sigma[compnum] = self.read_data(\"%s.sigma\" %\n (filenamebase),\n 0.01)\n periods[compnum], sigma0[compnum] = self.read_data(\"%s.sigma0\" %\n (filenamebase),\n 0.01)\n\n # Compute bias and conf interval lower/upper bounds\n for i in xrange(0, len(bias[compnum])):\n bias_l[compnum].append(bias[compnum][i] - sigma0[compnum][i])\n bias_h[compnum].append(bias[compnum][i] + sigma0[compnum][i])\n conf_l[compnum].append(m90[compnum][i])\n conf_h[compnum].append(p90[compnum][i])\n\n num_periods = len(periods[0])\n for comp in periods:\n if len(comp) != num_periods:\n print(\"Number of data points unequal across components\")\n return\n\n # Construct baseline\n baseline = [0.0 for _ in periods[0]]\n\n # Find max, min values\n min_x = min([min(comp) for comp in periods])\n max_x = max([max(comp) for comp in periods])\n min_y = MIN_Y_AXIS\n max_y = MAX_Y_AXIS\n\n # Start plots\n num_plots = len(gof_fileroot)\n # Make 1 column of \"num_plots\" rows\n fig, axs = pylab.plt.subplots(num_plots, 1)\n # Set plot dims\n fig.set_size_inches(6, 10)\n\n #subplots_adjust(left=0.125)\n #subplots_adjust(right=0.9)\n #subplots_adjust(top=0.85)\n fig.subplots_adjust(hspace=0.4)\n fig.subplots_adjust(wspace=0.5)\n\n # Add subplots in a list\n subfigs = []\n for idx in range(0, num_plots):\n subfigs.append(axs[idx])\n\n # Now walk through each subfig\n for (subfig, subplot_title, cur_period,\n cur_bias, cur_bias_h, cur_bias_l,\n cur_conf_h, cur_conf_l) in zip(subfigs,\n legends,\n periods,\n bias,\n bias_h,\n bias_l,\n conf_h,\n conf_l):\n subfig.set_xlim(min_x, max_x)\n subfig.set_ylim(min_y, max_y)\n subfig.set_title(\"%s\" % subplot_title, size=10)\n subfig.plot(cur_period, cur_bias, color='red', label='_nolegend_')\n subfig.fill_between(cur_period, cur_bias_h,\n cur_bias_l, color='cyan',\n label='_nolegend_')\n subfig.fill_between(cur_period, cur_conf_h,\n cur_conf_l, color='yellow',\n label='_nolegend_')\n subfig.plot(cur_period, baseline, color='grey',\n label='_nolegend_')\n # Only put xlabel on bottom plot\n if legends.index(subplot_title) == len(gof_fileroot) - 1:\n subfig.set_xlabel(\"Period (sec)\", size=8)\n subfig.set_ylabel(\"ln (data/model)\", size=8)\n subfig.set_xscale('log')\n # Old way to do it\n # subfig.set_xticks(xtick_loc, xtick_label)\n subfig.set_xticks(xtick_loc)\n subfig.set_xticklabels(xtick_label)\n subfig.tick_params(labelsize=8)\n subfig.minorticks_on()\n\n fig.suptitle('%s\\nNumber of stations: %d' % (plottitle, num_stations),\n size=12)\n # Figure out output filename\n outfile = gof_fileroot[0]\n outfile = outfile[:outfile.rfind(\"-\")]\n outfile = os.path.join(outdir, \"gof-%s.png\" % (outfile))\n print(\"==> Created GoF plot: %s\" % (outfile))\n fig.savefig(outfile, format=\"png\",\n transparent=False, dpi=plot_config.dpi)\n pylab.close()","def plot_profiles(snap, profs, dust_species_to_plot, debug=False):\n print('Plotting profiles...')\n\n units = {\n 'position': 'au',\n 'gas_velocity_radial_analytical': 'dimensionless',\n 'dust_velocity_radial_analytical': 'dimensionless',\n 'velocity_radial_numerical': 'dimensionless',\n }\n p = profs['gas'][0]\n\n if debug:\n num_dust = snap.num_dust_species\n ax = p.plot(x='radius', y=['velocity_pressure', 'velocity_visc'], units=units)\n y = ['gas_velocity_radial']\n y += [f'dust_velocity_radial_{idx+1:03}' for idx in range(num_dust)]\n ax = p.plot(x='radius', y=y, units=units)\n ax.legend().remove()\n\n fig, ax = plt.subplots()\n\n # Plot \"analytical\" radial drift velocity / velocity pressure component\n p.plot(\n x='radius',\n y='gas_velocity_radial_analytical',\n units=units,\n color='black',\n label='',\n ax=ax,\n )\n y = [f'dust_velocity_radial_analytical_{idx+1:03}' for idx in dust_species_to_plot]\n p.plot(x='radius', y=y, units=units, label='', ax=ax)\n colors = [line.get_color() for line in ax.lines[1:]]\n\n # Plot \"numerical\" radial drift velocity / velocity pressure component\n p.plot(\n x='radius',\n y='velocity_radial_numerical',\n units=units,\n color='black',\n linestyle='',\n marker='o',\n markersize=4,\n fillstyle='none',\n label='gas',\n std='shading',\n ax=ax,\n )\n profs_to_plot = [\n prof for idx, prof in enumerate(profs['dust']) if idx in dust_species_to_plot\n ]\n for species, prof, color in zip(dust_species_to_plot, profs_to_plot, colors):\n label = f'{snap.properties[\"grain_size\"][species].to(\"cm\"):.1f~P}'\n prof.plot(\n x='radius',\n y='velocity_radial_numerical',\n units=units,\n color=color,\n linestyle='',\n marker='o',\n markersize=4,\n fillstyle='none',\n label=label,\n std='shading',\n ax=ax,\n )\n\n ax.set_ylabel(r'$v_R / |v_P|$')\n ax.grid()\n\n textstr = f't = {snap.properties[\"time\"].to(\"years\").m:.0f} years'\n bbox = dict(boxstyle='round', facecolor='white', edgecolor='grey', alpha=0.8)\n ax.text(\n 0.97,\n 0.97,\n textstr,\n transform=ax.transAxes,\n horizontalalignment='right',\n verticalalignment='top',\n bbox=bbox,\n )\n ax.legend(framealpha=0.8, edgecolor='grey')\n\n return ax","def main():\n parser = argparse.ArgumentParser(description=\n ('Plot and save data from DS9 projections. If only labels are '\n 'given, it will just plot existing dat files.'\n 'Other regions/objects in file are ignored.'))\n\n parser.add_argument('infile', help='Input DS9 region file (fk5 coords)')\n parser.add_argument('datroot', help='Stem for output profile data')\n\n parser.add_argument('-p', '--pltroot', help='Stem for output plots')\n parser.add_argument('-f', '--files', help=('Files (.fits) to be processed,'\n ' one for each energy band'),\n nargs='*')\n\n parser.add_argument('-l', '--labels', help='Band labels for plots/files',\n nargs='+')\n parser.add_argument('-v', '--verbose', action='store_true',\n help='verbose mode')\n parser.add_argument('-s', '--subplot', action='store_true',\n help='Generate subplot plots')\n\n # Parse arguments\n args = parser.parse_args()\n regions_file = args.infile\n pltroot, datroot = args.pltroot, args.datroot\n bands, labels = args.files, args.labels # NOTE bands = args.files...\n verbose, subplot = args.verbose, args.subplot\n\n # Check arguments for sanity\n # If -p is supplied, output plots\n # If -b is supplied, output data\n if bands is None:\n if not pltroot:\n parser.error('Nothing to be done! Need bands or pltroot.')\n else:\n print 'No bands supplied, generating plots only'\n else:\n if len(bands) != len(labels):\n raise ValueError(('Non-zero number of bands '\n 'does not match number of labels!'))\n elif not pltroot:\n print 'No pltroot supplied, generating data only'\n\n # Parse projections\n rspecs = get_projection_params(regions_file)\n if verbose:\n print 'Projections parsed from region file'\n\n # Generate data files, if desired\n if bands is not None:\n regparse.check_dir(datroot, verbose) # only create if saving data\n generate_dat_files(rspecs, datroot, bands, labels)\n\n # Generate plots, if desired\n if pltroot:\n regparse.check_dir(pltroot, verbose)\n generate_plots(rspecs, datroot, pltroot, labels, verbose, subplot)\n\n if verbose:\n print 'Done!'","def plot_physical_profiles(self, fig=2):\n # Select the physical parameters\n phys_parms = ['temperature', 'salinity', 'theta', 'N']\n \n # Plot these parameters\n self.plot_profiles(phys_parms, fig)","def compare_hist_2(results_dir_root):\n plot_style = [\n {'color': 'k', 'marker': 'none', 'lw': 1.5},\n {'color': 'r', 'marker': 'none', 'lw': 1.5}\n ]\n unwrap_levels = ['r08']\n\n fig, axes = plt.subplots(figsize=(8, 10), nrows=5, ncols=2, sharex=True,\n sharey=False)\n fig.subplots_adjust(left=0.1, bottom=0.08, right=0.98, top=0.98,\n hspace=0.05, wspace=0.15)\n\n print(axes.shape)\n\n results_dirs = [results_dir_root + '_0h', results_dir_root + '_4h']\n\n fig.text(0.5, 0.02, r'Baseline length (m)', ha='center')\n fig.text(0.01, 0.5, r'Baseline count per bin', va='center',\n rotation='vertical')\n\n # Loop over models\n for i in range(7, 8):\n models = ['ska1_v5', 'model%02i' % (i + 1)]\n # Loop over 0h or 4h\n for j in range(1):\n idx = 0\n ax = axes[i, j]\n for model in models:\n # Load saved psf results.\n filename = join(results_dirs[j], '%s_uv_hist.p' % model)\n print('-- Loading: %s' % filename)\n hist = pickle.load(open(filename, 'rb'))\n # Plot comparison of PSF profiles.\n for tel in hist:\n if tel == 'ska1_v5' or any(s in tel for s in unwrap_levels):\n style = plot_style[idx % len(plot_style)]\n x = hist[tel]['log']['hist_x']\n y = hist[tel]['log']['hist_n']\n cut_idx = np.argmax(x > 5e3)\n x = x[:cut_idx]\n y = y[:cut_idx]\n ax.plot(x, y, color=style['color'],\n linestyle='-',\n label=tel + ' max')\n idx += 1\n length_str = 'snapshot' if j == 0 else '4 hours'\n ax.text(0.02, 0.95, ('SKA1 v5 vs. Model %i\\n' % (i + 1)) + length_str,\n weight='bold',\n ha='left', va='top', transform=ax.transAxes,\n fontsize='small')\n # ax.legend(loc='best', fontsize='small', ncol=1)\n # ax.set_xlabel('Baseline length (m)')\n # ax.set_ylabel('Number of baselines per bin')\n ax.set_xlim(10, 1e4)\n if j == 1:\n ax.set_ylim(1.5e3)\n if j == 0:\n ax.set_ylim(5)\n ax.set_yscale('log')\n ax.set_xscale('log')\n # if i == 4:\n # ax.set_xlabel('Baseline length (m)')\n # ax.set_ylabel('Baseline count per bin')\n ax.grid()\n plt.show(True)\n fig.savefig(join('compare_hist_%s.png' %\n ('_'.join(unwrap_levels))))\n plt.close(fig)","def plot_folder(path):\r\n plt.figure(figsize=(20, 10))\r\n for filename in glob.glob(path + '/*.pspec'):\r\n x, y= np.loadtxt(fname=filename, delimiter='\\t',dtype=int, usecols = (1,2),\r\n skiprows=100, unpack = True)\r\n plt.plot(x, y)\r\n return plt.show()","def make_plots(self):\n n_rounds = self.run.n_rounds\n\n log.info('Making %d frames', n_rounds)\n args = [self._get_for_parallel(i) for i in range(n_rounds)]\n self.lbv.map(_plot_helper, args)","def plot_skyplot(\n self,\n figure_name: str=\"plot_skyplot_{system}.{FIGURE_FORMAT}\",\n ) -> List[pathlib.PosixPath]:\n figure_paths = list()\n \n # Convert azimuth to range 0-360 degree\n azimuth = self.dset.site_pos.azimuth\n idx = azimuth < 0\n azimuth[idx] = 2 * np.pi + azimuth[idx]\n \n # Convert zenith distance from radian to degree\n zenith_distance = np.rad2deg(self.dset.site_pos.zenith_distance)\n \n # Generate x- and y-axis data per system\n for sys in sorted(self.dset.unique(\"system\")):\n x_arrays = []\n y_arrays = []\n labels = []\n \n figure_path = self.figure_dir / figure_name.replace(\"{system}\", sys).replace(\"{FIGURE_FORMAT}\", FIGURE_FORMAT)\n figure_paths.append(figure_path)\n \n for sat in sorted(self.dset.unique(\"satellite\")):\n if not sat.startswith(sys):\n continue\n idx = self.dset.filter(satellite= sat)\n x_arrays.append(azimuth[idx])\n y_arrays.append(zenith_distance[idx])\n labels.append(sat)\n \n # Plot with polar projection\n # TODO: y-axis labels are overwritten after second array plot. Why? What to do?\n plot(\n x_arrays=x_arrays,\n y_arrays=y_arrays,\n xlabel=\"\",\n ylabel=\"\",\n y_unit=\"\",\n labels=labels,\n figure_path=figure_path,\n opt_args={\n \"colormap\": \"hsv\",\n \"figsize\": (7, 7.5),\n \"legend\": True,\n \"legend_ncol\": 6,\n \"legend_location\": \"bottom\",\n \"plot_to\": \"file\",\n \"plot_type\": \"scatter\",\n \"projection\": \"polar\",\n \"title\": f\"Skyplot for {enums.gnss_id_to_name[sys]}\\n Azimuth [deg] / Elevation[deg]\",\n \"xlim\": [0, 2 * np.pi],\n \"ylim\": [0, 90],\n \"yticks\": (range(0, 90, 30)), # sets 3 concentric circles\n \"yticklabels\": (map(str, range(90, 0, -30))), # reverse labels from zenith distance to elevation\n },\n )\n \n return figure_paths","def main(self, args):\n for plot in args.plots:\n if plot == 'no_plot':\n break\n print \"plotting\", plot\n\n fig = self.plot_figure(plot)\n\n fformat = '{plot}_{index}.{ext}'\n fname = fformat.format(plot=plot, index=self.index, ext='png')\n fpath = os.path.join(plot_dir, fname)\n fig.savefig(fpath)\n\n if args.distributions == 'all':\n distributions = ['Uf', 'Wf', 'uf_abs',\n 'vorticity', 'vertical_shear']\n else:\n distributions = args.distributions\n for dist in distributions:\n range = self.properties[dist]['range']\n name = self.properties[dist]['name']\n print \"plotting distribution\", dist, name\n fig = self.plot_distribution(getattr(self, dist), range, name)\n\n fformat = 'distribution_{q}_{index}.{ext}'\n fname = fformat.format(q=dist, index=self.index, ext='png')\n fpath = os.path.join(plot_dir, fname)\n fig.savefig(fpath)\n\n if args.funcs:\n for func in args.funcs:\n print \"multiprocessing\", func\n f = getattr(self, 'plot_' + func)\n f()","def plotSpectrums2D(path_fsrcnn, path_liif, path_msrn, path_esrgan, path_bicubic, out_path):\n radial_FSRCNN = []\n radial_LIIF = []\n radial_MSRN = []\n radial_ESRGAN = []\n radial_BICUBIC = []\n\n for FSRCNN_path, LIIF_path, MSRN_path, ESRGAN_path, bicubic_path in zip(sorted(glob.glob(path_fsrcnn)), sorted(glob.glob(path_liif)), sorted(glob.glob(path_msrn)), sorted(glob.glob(path_esrgan)), sorted(glob.glob(path_bicubic))):\n print(FSRCNN_path)\n radialProfile_FSRCNN = spectrum2D(FSRCNN_path)\n print(len(radialProfile_FSRCNN))\n radial_FSRCNN.append(radialProfile_FSRCNN)\n print(LIIF_path)\n radialProfile_LIIF = spectrum2D(LIIF_path)\n radial_LIIF.append(radialProfile_LIIF)\n print(MSRN_path)\n radialProfile_msrn = spectrum2D(MSRN_path)\n radial_MSRN.append(radialProfile_msrn)\n print(ESRGAN_path)\n radialProfile_esrgan = spectrum2D(ESRGAN_path)\n radial_ESRGAN.append(radialProfile_esrgan)\n print(bicubic_path)\n radialProfile_bicubic = spectrum2D(bicubic_path)\n radial_BICUBIC.append(radialProfile_bicubic)\n\n image_name = FSRCNN_path.split('/')[-1]\n if not os.path.exists(out_path):\n os.makedirs(out_path)\n\n plt.figure()\n plt.plot(radialProfile_FSRCNN, label='FSRCNN')\n plt.plot(radialProfile_LIIF, label='LIIF')\n plt.plot(radialProfile_msrn, label='MSRN')\n plt.plot(radialProfile_esrgan, label='ESRGAN')\n plt.plot(radialProfile_bicubic, label='BICUBIC')\n plt.legend()\n plt.title(image_name)\n plt.yscale('log')\n plt.savefig(out_path + image_name)\n\n mean_FSRCNN = tolerant_mean(radial_FSRCNN)\n mean_LIIF = tolerant_mean(radial_LIIF)\n mean_MSRN = tolerant_mean(radial_MSRN)\n mean_ESRGAN = tolerant_mean(radial_ESRGAN)\n mean_BICUBIC = tolerant_mean(radial_BICUBIC)\n plt.figure()\n plt.plot(mean_FSRCNN, label='FSRCNN')\n plt.plot(mean_LIIF, label='LIIF')\n plt.plot(mean_MSRN, label='MSRN')\n plt.plot(mean_ESRGAN, label='ESRGAN')\n plt.plot(mean_BICUBIC, label='BICUBIC')\n plt.legend()\n plt.title('MEAN')\n plt.yscale('log')\n plt.savefig(out_path + 'mean')\n #return radialProfile_FSRCNN.shape, radialProfile_LIIF.shape, radialProfile_msrn.shape","def plot_profiles(self, parameters, fig=1):\n # Make sure the parameters are a list\n if isinstance(parameters, str) or isinstance(parameters, unicode):\n parameters = [parameters]\n \n # Decide how many subplots to create\n nrows = int(len(parameters) / 3)\n if len(parameters) % 3 > 0:\n nrows += 1\n \n # Initialize a figure for plotting\n width = 8\n height = 4 * nrows\n plt.figure(fig, figsize=(width, height))\n plt.clf()\n \n # Plot each parameter\n for parm in parameters:\n ax = plt.subplot(nrows, 3, parameters.index(parm)+1)\n self.plot_parameter(parm)\n \n plt.tight_layout()\n \n plt.show()","def PlotProfile():\n (metadata, data) = Parse('/tmp/sdcard-scalability.txt')\n gp = Gnuplot.Gnuplot(persist=1)\n gp('set data style impulses')\n gp('set xtics 1')\n gp('set pointsize 2')\n gp.clear()\n gp.xlabel('writer process')\n gp.ylabel('duration in second')\n gp.title(metadata.AsTitle())\n\n dataset = data[0]\n x = numpy.array(dataset.time, dtype='int_')\n d = Gnuplot.Data(x, dataset.data,\n title=dataset.name,\n with_='linespoints')\n gp.replot(d)\n gp.hardcopy('/tmp/%s-%s-%f.png' %\n (metadata.name, metadata.kernel, metadata.duration),\n terminal='png')","def stm_profile_plot(flat_file, points, scan_dir=0, cmap=None, vmin=None, vmax=None, xy_ticks=4, z_ticks=4):\n nm = 10 ** -9 # Define the nanometer to meter conversion.\n\n fig, ax = plt.subplots() # Create an instance of a pyplot figure and axis.\n\n # Set the minimum of the scan data to zero.\n figure_data = (flat_file[scan_dir].data - np.amin(flat_file[scan_dir].data)) / nm\n\n if cmap is None: # If no color scheme is given use hot as default.\n cmap = 'hot'\n\n if vmin is None: # If no z-axis minimum is given use minimum of the image data.\n vmin = np.amin(figure_data)\n if vmax is None: # If no z-axis maxmimum is given use 125% of the maximum in the image data.\n vmax = 1.25 * np.amax(figure_data)\n\n # Add image plot to the axis and define it so that the color map can be generated.\n cax = ax.imshow(figure_data, origin='lower', cmap=cmap, vmin=vmin, vmax=vmax)\n\n # Convert nanometer values into pixel numbers.\n for point in range(len(points)):\n points[point][0] = nm2pnt(points[point][0], flat_file, axis='x')\n points[point][1] = nm2pnt(points[point][1], flat_file, axis='y')\n\n # Plot the line profile points on the axis.\n ax.plot(points[:, 0], points[:, 1], 'bo-')\n\n xy_units = flat_file[scan_dir].info['unitxy'] # Get xy units.\n\n x_res = flat_file[scan_dir].info['xres'] # Get number of x-axis pixels.\n y_res = flat_file[scan_dir].info['yres'] # Get number of y-axis pixels.\n\n x_max = flat_file[scan_dir].info['xreal'] # Get x-axis image size.\n y_max = flat_file[scan_dir].info['yreal'] # get y-axis image size.\n\n # Set the x-axis ticks from number given.\n ax.set_xticks([x for x in np.arange(0, x_res + 1, x_res / xy_ticks)])\n # Set the x-axis tick labels from image size.\n ax.set_xticklabels([str(np.round(x, 1)) for x in np.arange(0, x_max + 1, x_max / xy_ticks)])\n\n # Set the y-axis ticks from number given\n ax.set_yticks([y for y in np.arange(0, y_res + 1, y_res / xy_ticks)])\n # Set the y-axis tick labels from image size.\n ax.set_yticklabels([str(np.round(y, 1)) for y in np.arange(0, y_max + 1, y_max / xy_ticks)])\n\n # Set the x- and y-axis labels.\n ax.set_xlabel(xy_units, size=16, weight='bold')\n ax.set_ylabel(xy_units, size=16, weight='bold')\n\n # Define the limits of the plot.\n ax.set_xlim([0, x_res])\n ax.set_ylim([0, y_res])\n\n # St the plot title with the image setpoint parameters.\n ax.set_title('Set-Points: {voltage} V, {current} pA'.format(voltage=flat_file[scan_dir].info['vgap'],\n current=np.round(\n flat_file[scan_dir].info['current']*10**12)))\n\n # Define list containing the z-axis ticks from number given.\n cbar_ticks = [z for z in np.arange(vmin, vmax * 1.01, vmax / z_ticks)]\n # Define the z-axis tick labels.\n cbar_ticklabels = [str(np.round(z, 1)) for z in np.arange(vmin, vmax + 1, vmax / z_ticks)]\n # Create color bar.\n cbar = fig.colorbar(cax, ticks=cbar_ticks)\n # Set the color bar tick labels.\n cbar.ax.set_yticklabels(cbar_ticklabels, size=16)\n # Set color bar label.\n cbar.set_label('Height [' + xy_units + ']', size=18, weight='bold')\n\n plt.show()","def generate_plots(self, env):\n print(' Generating diagnostic plots for : {0}'.format(self.__class__.__name__))\n\n # chdir into the working directory\n os.chdir(env['WORKDIR'])\n\n for nclPlotFile in self._ncl:\n # copy the NCL command to the workdir\n shutil.copy2('{0}/{1}'.format(env['NCLPATH'],nclPlotFile), '{0}/{1}'.format(env['WORKDIR'], nclPlotFile))\n\n nclFile = '{0}/{1}'.format(env['WORKDIR'],nclPlotFile)\n rc, err_msg = cesmEnvLib.checkFile(nclFile, 'read')\n if rc:\n try:\n print(' calling NCL plot routine {0}'.format(nclPlotFile))\n subprocess.check_call(['ncl', '{0}'.format(nclFile)], env=env)\n except subprocess.CalledProcessError as e:\n print('WARNING: {0} call to {1} failed with error:'.format(self.name(), nclFile))\n print(' {0}'.format(e.cmd))\n print(' rc = {0}'.format(e.returncode))\n else:\n print('{0}... continuing with additional plots.'.format(err_msg))","def app_SN_combined_temperature_series(self, dfs, phase_dirs, sizer_val, styler_val): # need to implement other options\n\n print('Currently plotting plot_SN_combined_temperature_series')\n\n for df, direc in zip(dfs, phase_dirs):\n # this iterates one or multiple times\n self.plotter.plot_SN_combined_temperature_series(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['01_combined_plots'],\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\n styler=self.formatter.styler[styler_val]\n )\n self.plotter.plot_SN_combined_temperature_series(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['01_combined_plots'],\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\n styler=self.formatter.styler[styler_val],\n xaxis_type='datetime'\n )\n\n print('Done\\n')","def make_plots(srcdir, outdir, include_subdir=False, level=3):\n srcfiles = get_ordered_srcfiles(srcdir, include_subdir)\n nodelist = get_f_nodelist(srcfiles)\n for n in nodelist:\n print(os.path.basename(n.name))\n for m in n.dependencies:\n print(' ' + os.path.basename(m.name))\n print('')\n\n if not os.path.isdir(outdir):\n raise Exception('output directory does not exist')\n\n for n in nodelist:\n filename = os.path.join(outdir, os.path.basename(n.name) + '.png')\n print('Creating ' + filename)\n graph = pydot.Dot(graph_type='digraph')\n node_dict = {}\n ilev = 0\n add_pydot_nodes(graph, node_dict, n, ilev, level)\n edge_set = set()\n ilev = 1\n add_pydot_edges(graph, node_dict, edge_set, n, ilev, level)\n graph.write_png(filename)\n\n return","def plots():\n out = interactive_output(generate_plots, {'gsize':gridSlider, 'ra':RABox, 'ra':RASlider, 'dec':DECBox, 'dec':DECSlider, 'ang':radBox, 'ang':radSlider, 'style':hexDrop})\n return display(widgrid, out)","def plotPaperFigures(folder='results/'):\n #model Example\n _AiryDisc(amplitude=1e6, center_x=10.0, center_y=10.0, radius=0.5, focus=0.4, size=21)\n _CCDkernel(CCDx=10, CCDy=10, width_x=0.35, width_y=0.4, size=21)\n plotModelExample()\n\n #simulation figures\n theta1 = (2.e5, 9.9, 10.03, 0.41, 0.51, 10., 10., 0.291, 0.335)\n try:\n _plotDifferenceIndividualVsJoined(individuals='simulatedResults/RunI*.pkl',\n joined='results/simulated800nmJoint.pkl',\n title='Simulated Data: CCD PSF Recovery', truthx=theta1[7], truthy=theta1[8],\n requirementE=None, requirementFWHM=None, requirementR2=None)\n _plotModelResiduals(id='RunI1', folder='simulatedResults/', out='Residual1.pdf', individual=True)\n except:\n print 'No simulated data to plot...'\n\n #real data\n _plotDifferenceIndividualVsJoined(individuals=folder+'I800nm?.pkl', joined=folder+'J800nm.pkl', title='800nm',\n FWHMlims=(7.3, 11.8))\n\n _plotModelResiduals(id='I800nm2', folder=folder, out='ResidualData.pdf', individual=True)\n _plotModelResiduals(id='RunI2', folder='simulatedResults/', out='Residual2.pdf', individual=True)\n\n #_plotModelResiduals(id='G600nm0', folder=folder, out='ResidualG600.pdf', individual=True)\n #_plotModelResiduals(id='G700nm0', folder=folder, out='ResidualG700.pdf', individual=True)\n _plotModelResiduals(id='G800nm0', folder=folder, out='ResidualG800.pdf', individual=True)\n #_plotModelResiduals(id='G890nm0', folder=folder, out='ResidualG890.pdf', individual=True)\n\n #wavelength dependency\n plotLambdaDependency()\n\n #brighter fatter\n plotBrighterFatter()","def generate_plots(rspecs, datroot, pltroot, labels,\n verbose=False, subplot=False):\n\n if subplot:\n n = len(labels)\n plt.figure(figsize=(4*n,4))\n else:\n plt.figure(figsize=(6,4))\n\n if verbose:\n print 'Generating {} plots...'.format(len(rspecs))\n print 'First plot will hang a little longer'\n\n # Make a plot for each region\n for i in xrange(len(rspecs)):\n # Plot line/points for each label\n for flab, j in zip(labels, xrange(n)):\n dat_fname = '{0}_{1:02d}_band_{2}.dat'.format(datroot, i+1, flab)\n a = np.loadtxt(dat_fname)\n if subplot:\n plt.subplot(1, n, j+1) # j indexes labels\n plt.plot(a[:,0], a[:,1], '-o') # Use default color cycle\n plt.title('Region {:g}, band {}'.format(i+1, flab))\n fplot('Radial dist. (?)', 'Intensity? (?)')\n else:\n plt.plot(a[:,0], a[:,1], '-o') # Use default color cycle\n # Format overall plot\n if not subplot:\n fplot('Radial dist. (?)', 'Intensity? (?)')\n plt.title('Region %g' % (i+1))\n plt.legend(labels, loc='best')\n plt.tight_layout()\n plt.savefig('{0}_{1:02d}.png'.format(pltroot, i+1), dpi=150)\n plt.clf()\n if verbose:\n print 'Saved: {0}_{1:02d}.png'.format(pltroot, i+1)","def plot_results(path: Path, output_dir: Path, skip: int = 100) -> Path:\n with xr.open_dataset(path) as ds:\n lons = ds.lon.values\n lats = ds.lat.values\n status = ds.status.values\n stranded_flag = get_stranded_flag_from_status(ds)\n\n _ = plt.figure(figsize=(10, 10))\n ax = plt.axes(projection=ccrs.PlateCarree(central_longitude=180))\n ax.set_extent(\n [-210, -140, 45, 75],\n crs=ccrs.PlateCarree()\n )\n nparticles = len(lons)\n if nparticles > skip:\n iter_particles = np.arange(0, nparticles, skip)\n else:\n iter_particles = np.arange(0, nparticles)\n\n for particle in iter_particles:\n # Create mask for stranded or not moving particles\n mask = np.logical_and(\n status[particle, :] <= 1,\n status[particle, :] >= 0\n )\n # Cannot save figure if you plot something that is completely masked\n # Cartopy will raise an error on save\n if not np.any(mask):\n continue\n ax.plot(\n lons[particle, mask],\n lats[particle, mask],\n color='g',\n transform=ccrs.PlateCarree()\n )\n\n # Starting position\n ax.scatter(\n ds.lon[particle, 0],\n ds.lat[particle, 0],\n c='b',\n transform=ccrs.PlateCarree()\n )\n stranded_ix = ds.status[particle, :] == stranded_flag\n\n # Stranded particles\n if np.any(stranded_ix):\n ax.scatter(\n ds.lon[particle, stranded_ix],\n ds.lat[particle, stranded_ix],\n c='r',\n transform=ccrs.PlateCarree()\n )\n\n ax.coastlines()\n ax.add_feature(cartopy.feature.LAND.with_scale('110m'))\n ax.gridlines(draw_labels=True)\n\n fname = path.name.replace('.nc', '.png')\n outpath = output_dir / fname\n\n plt.tight_layout()\n plt.savefig(outpath)\n plt.close()\n\n return outpath","def plot_path_statistics( self, path_file=\"tse_ensemble.json\" ):\n from matplotlib import pyplot as plt\n with open(path_file,'r') as infile:\n data = json.load(infile)\n try:\n paths = data[\"transition_paths\"]\n except KeyError:\n paths = [data]\n total_product_indicator = np.zeros(len(paths[0][\"symbols\"]))\n total_reactant_indicator = np.zeros(len(paths[0][\"symbols\"]))\n self.nuc_mc.min_size_product = paths[0][\"min_size_product\"]\n self.nuc_mc.max_size_reactant = paths[0][\"max_size_reactant\"]\n for path in paths:\n product_indicator = []\n reactant_indicator = []\n reactant_indicator, product_indicator = self.get_basin_indicators(path)\n\n total_product_indicator += np.cumsum(product_indicator)/float( len(product_indicator) )\n total_reactant_indicator += np.cumsum(reactant_indicator)/float( len(reactant_indicator) )\n\n total_reactant_indicator /= float( len(paths) )\n total_product_indicator /= float( len(paths) )\n\n fig = plt.figure()\n ax = fig.add_subplot(1,1,1)\n ax.plot( total_product_indicator, label=\"Product\" )\n ax.plot( total_reactant_indicator, label=\"Reactant\" )\n ax.set_xlabel( \"MC sweeps\" )\n ax.set_ylabel( \"Indicator\" )\n ax.spines[\"right\"].set_visible(False)\n ax.spines[\"top\"].set_visible(False)\n ax.legend( frameon=False, loc=\"best\" )\n return fig","def main():\n import argparse\n import os\n parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n parser.add_argument('--dirs', help='List of log directories', nargs='*', default=['./log'])\n parser.add_argument('--num_timesteps', type=int, default=int(10e6))\n parser.add_argument('--xaxis', help='Varible on X-axis', default=X_TIMESTEPS)\n parser.add_argument('--task_name', help='Title of plot', default='Breakout')\n args = parser.parse_args()\n args.dirs = [os.path.abspath(folder) for folder in args.dirs]\n plot_results(args.dirs, args.num_timesteps, args.xaxis, args.task_name)\n plt.show()","def save_plots(self):\n pdir = os.path.splitext(self.filename)[0] + '_plots'\n if not os.path.exists(pdir):\n os.mkdir(pdir)\n\n for ii in range(self.uv.n_ant):\n fig, ax = self.plot_single_baseline_dual_pol(ii+1, ii+1)\n print \"Saving ant %i\"%ii\n plt.savefig(os.path.join(pdir, 'ant-%i.png'%ii))\n plt.clf()","def app_SN_combined_temperature_gradient(self, dfs, phase_dirs, sizer_val, styler_val): # need to implement other options\n\n print('Currently plotting plot_SN_combined_temperature_gradient')\n\n for df, direc in zip(dfs, phase_dirs):\n # this iterates one or multiple times\n self.plotter.plot_SN_combined_temperature_gradient(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['01_combined_plots'],\n sizer=self.formatter.sizer[sizer_val]['3x1_partial_width'],\n styler=self.formatter.styler[styler_val],\n xscale=self.xscale_var.get()\n )\n\n print('Done\\n')","def Diagnostic_plot3(self):\n\n floc = glob.glob('/home/mxs191/Desktop/MathewSchofield/TRG/DetTest/DetTest1_results/Info2Save/*.csv')\n fig = plt.figure()\n plt.rc('font', size=18)\n #fig, ax = generalPlot(xaxis=r'$\\nu / \\mu$Hz', yaxis=r'$P_{\\rm det}$')\n gs = gridspec.GridSpec(1, 2, width_ratios=(4,1))\n ax = fig.add_subplot(gs[0])\n\n for idx, i in enumerate(floc):\n\n d = pd.read_csv(i)\n\n if idx == 0:\n fullpdet = d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']]\n else:\n fullpdet = pd.concat([ fullpdet,\\\n d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']] ])\n\n plt.scatter(d['f0'], d['Pdet_Kepler'], color='b',\\\n label=r\"$\\rm Kepler - 4\\ yrs$\" if idx == 0 else '')\n plt.scatter(d['f0'], d['Pdet_TESS365'], color='orange',\\\n label=r'$\\rm TESS - 1\\ yr$' if idx == 0 else '')\n plt.scatter(d['f0'], d['Pdet_TESS27'], color='g',\\\n label=r'$\\rm TESS - 27\\ days$' if idx == 0 else '')\n\n plt.axhline(fullpdet['Pdet_Kepler'].median(), color='b')\n plt.axhline(fullpdet['Pdet_TESS365'].median(), color='orange')\n plt.axhline(fullpdet['Pdet_TESS27'].median(), color='g')\n ax.legend(loc='lower right')\n plt.ylim([0,1])\n ax.set_ylabel(r'$P_{\\rm det}$')\n ax.set_xlabel(r'$\\nu / \\mu \\rm Hz$')\n\n bx = fig.add_subplot(gs[1])\n import seaborn as sns\n bw = 0.4\n sns.kdeplot(fullpdet['Pdet_Kepler'].values, shade=True, vertical=True, \\\n ax=bx, color='b', bw=bw)\n sns.kdeplot(fullpdet['Pdet_TESS365'].values, shade=True, vertical=True, \\\n ax=bx, color='orange', bw=bw)\n sns.kdeplot(fullpdet['Pdet_TESS27'].values, shade=True, vertical=True, \\\n ax=bx, color='g', bw=bw)\n bx.set_ylim([0.0,1.0])\n bx.set_xticks([])\n bx.set_yticks([])\n bx.set_xlabel(r'$\\rm Density$')\n plt.tight_layout()\n\n plt.show()\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\n 'DetTest_Diagnostic_plot3.pdf')\n sys.exit()","def plotPerLumiSection(options):\n name = options['name'] + '_perLS'\n f = openRootFileR(name)\n histname = plotName(options['title']+'_perLS', timestamp=False)\n filename = plotName(options['title']+'_perLS', timestamp=True)\n filepath = plotPath(options['title']+'_perLS', timestamp=True)\n print '<<< Save plot:', filepath\n hist = f.Get(histname)\n canvas = TCanvas()\n canvas.SetLogy(options['logy'])\n gStyle.SetOptStat(options['optstat'])\n hist.Draw()\n gPad.Update()\n hist.GetXaxis().SetTitle('Lumisection')\n hist.GetYaxis().SetTitle(options['ytitle'])\n hist.GetYaxis().SetTitleOffset(1.2)\n for axis in [hist.GetXaxis(), hist.GetYaxis()]:\n axis.SetTitleFont(133)\n axis.SetTitleSize(16)\n axis.SetLabelFont(133)\n axis.SetLabelSize(12)\n axis.CenterTitle()\n drawSignature(filename)\n gPad.Modified()\n gPad.Update()\n #canvas.Print(filepath)\n #canvas.Close()\n #closeRootFile(f, name)\n return [canvas, hist, f]","def plot_results(infer_images, inference_predicted_class, inference_predictions, class_names=['plants', 'water']):\n plt.style.use(['dark_background', 'bmh'])\n rc('figure', figsize=(8, 8), max_open_warning=False)\n rc('axes', facecolor='none')\n plt.figure(figsize=(15, 15))\n\n for i, (infer_img, _) in enumerate(infer_images.take(10)):\n ax = plt.subplot(5, 2, i + 1)\n plt.imshow(infer_img.numpy()/255)\n\n # Find the predicted class from predictions\n m = \"Predicted: {}, {:.2f}%\".format(\n class_names[inference_predicted_class[i]], inference_predictions[i]*100)\n plt.title(m)\n plt.axis(\"off\")\n plt.show()","def plot_visual_abstract():\n # Which generations to plot\n GENERATIONS = [100, 230, 350]\n\n # LunarLander CMA-ES\n experiment_path = glob(\"experiments/wann_LunarLander-v2_CMAES*\")\n assert len(experiment_path) == 1, \"There should be only one CMA-ES experiment with LunarLander-v2\"\n experiment_path = experiment_path[0]\n\n pivector_paths = glob(os.path.join(experiment_path, \"pivectors\", \"*\"))\n\n tsnes = []\n rewards = []\n for generation in GENERATIONS:\n # Find pivector files for specific generation, load them and store points\n generation_paths = [path for path in pivector_paths if \"gen_{}_\".format(generation) in path]\n\n population = [np.load(path) for path in generation_paths]\n population_tsnes = np.array([x[\"tsne\"] for x in population])\n population_rewards = np.array([x[\"average_episodic_reward\"] for x in population])\n tsnes.append(population_tsnes)\n rewards.append(population_rewards)\n\n figure, axs = pyplot.subplots(\n figsize=[2.5 * 3, 2.5],\n nrows=1,\n ncols=len(GENERATIONS),\n sharex=\"all\",\n sharey=\"all\"\n )\n\n min_reward = min(x.min() for x in rewards)\n max_reward = max(x.max() for x in rewards)\n scatter = None\n\n for idx in range(len(GENERATIONS)):\n population_tsne = tsnes[idx]\n population_rewards = rewards[idx]\n generation = GENERATIONS[idx]\n ax = axs[idx]\n\n scatter = ax.scatter(\n population_tsne[:, 0],\n population_tsne[:, 1],\n c=population_rewards,\n vmin=min_reward,\n vmax=max_reward,\n cmap=\"plasma\"\n )\n ax.set_title(\"Generation {}\".format(generation))\n ax.set_xticks([])\n ax.set_yticks([])\n ax.axis(\"off\")\n\n # Making room for colorbar\n # Stackoverflow #13784201\n figure.subplots_adjust(right=1.0)\n cbar = figure.colorbar(scatter)\n cbar.set_ticks([])\n cbar.ax.set_ylabel(\"Reward $\\\\rightarrow$\", rotation=90, fontsize=\"large\")\n\n figure.tight_layout()\n figure.savefig(\"figures/visual_abstract.pdf\", bbox_inches=\"tight\", pad_inches=0.05)","def plotting(self,job,input_zip,output_file,df,my_dpi):\n if len(job.Y2headers)>0:\n X1=df.loc[:,job.X1header].values\n X2=df.loc[:,job.X2header].values\n Y1=df.loc[:,job.Y1headers].values\n if (job.name.startswith(\"Morphine\") or job.name.startswith(\"Sarin\")) and os.path.exists(job.experimentalData):\n df2=pd.read_csv(job.experimentalData)\n Y2=np.array(df2.loc[:,job.Y2headers].values)\n X1=np.array(df2.loc[:,job.X1header].values[:Y2.shape[0]])\n Y1=np.array(df.loc[:,job.Y1headers].values[:Y2.shape[0]])\n X2=np.array(df.loc[:,job.X2header].values[:Y2.shape[0]])\n else:\n Y2=df.loc[:,job.Y2headers].values\n fig,ax = plt.subplots()\n fig.set_size_inches(w=job.imageWidth/my_dpi+3.1,h=job.imageHeight/my_dpi+1)\n \n if not os.path.exists(job.outputDir):\n os.mkdir(job.outputDir)\n \n if job.X1LowerBound and job.X1UpperBound:\n ax.set_xlim(job.X1LowerBound,job.X1UpperBound)\n elif job.X1LowerBound:\n ax.set_xlim(left=job.X1LowerBound)\n elif job.X1UpperBound:\n ax.set_xlim(right=job.X1UpperBound)\n\n if job.Y1LowerBound and job.Y1UpperBound:\n ax.set_ylim(job.Y1LowerBound,job.Y1UpperBound)\n elif job.Y1LowerBound:\n ax.set_ylim(bottom=job.Y1LowerBound)\n elif job.Y1UpperBound:\n ax.set_ylim(top=job.Y1UpperBound) \n \n ax.get_yaxis().set_major_locator(MaxNLocator(nbins=18,min_n_ticks=8))\n ax.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\n ax.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\n ax.set_xlabel(job.X1header,fontsize=job.fontSize)\n \n if job.Y1Label!=None:\n ax.set_ylabel(job.Y1Label,color=\"g\",fontsize=job.fontSize)\n else:\n ax.set_ylabel(job.Y1headers[0],color=\"g\",fontsize=job.fontSize)\n p1=ax.plot(X1,Y1,color=\"g\")\n\n ax2=ax.twinx()\n \n if job.Y2LowerBound and job.Y2UpperBound:\n ax2.set_ylim(job.Y2LowerBound,job.Y2UpperBound)\n elif job.Y2LowerBound:\n ax2.set_ylim(bottom=job.Y2LowerBound)\n elif job.Y2UpperBound:\n ax2.set_ylim(top=job.Y2UpperBound)\n \n ax2.get_yaxis().set_major_locator(MaxNLocator(nbins=18,min_n_ticks=8))\n ax2.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\n ax2.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\n ax2.set_xlabel(job.X1header,fontsize=job.fontSize)\n \n if job.Y2Label!=None:\n ax2.set_ylabel(job.Y2Label,color=\"b\",fontsize=job.fontSize)\n else:\n ax2.set_ylabel(job.Y2headers[0],color=\"b\",fontsize=job.fontSize)\n \n p2=ax2.plot(X2,Y2,color=\"b\")\n title=job.name+\"_\"\n title+=job.Y2headers[0]\n title = title + \"vs_\" + job.X1header\n \n if job.X2header != None and not job.X1header.lower() == job.X2header.lower():\n title = title + \"_\" + job.X2header\n # Override the constructed title if desired\n \n if job.titleOverride != None and not len(job.titleOverride)==0 and not job.titleOverride.lower() == \"None\".lower():\n title = job.titleOverride\n if job.log>=1:\n logging.info(\"Creating Graph:\"+title)\n \n if job.titleOverride !=\"None\":\n plt.title(title,fontsize=job.fontSize)\n \n if job.showGridLines:\n plt.grid(b=True, which='major', color='r', linestyle='--')\n \n if not job.removeAllLegends:\n p=p1+p2\n labs=[job.Y1headers[0],job.Y2headers[0]]\n ax.legend(p,labs)\n \n if \"(\" and \")\" in job.outputFilename:\n job.outputFilename=job.outputFilename.split(\"(\")[0]+\".jpg\"\n plt.savefig(os.path.join(job.outputDir,job.outputFilename),dpi=my_dpi)\n plt.close(\"all\")\n\n elif len(job.Y2headers)==0:\n X1=df.loc[:,job.X1header]\n Y1=df.loc[:,job.Y1headers]\n fig,ax = plt.subplots()\n fig.set_size_inches(w=job.imageWidth/my_dpi+3.1,h=job.imageHeight/my_dpi+1)\n \n if not os.path.exists(job.outputDir):\n os.mkdir(job.outputDir)\n \n if job.X1LowerBound and job.X1UpperBound:\n ax.set_xlim(job.X1LowerBound,job.X1UpperBound)\n elif job.X1LowerBound:\n ax.set_xlim(left=job.X1LowerBound)\n elif job.X1UpperBound:\n ax.set_xlim(right=job.X1UpperBound)\n\n if job.Y1LowerBound and job.Y1UpperBound:\n ax.set_ylim(job.Y1LowerBound,job.Y1UpperBound)\n elif job.Y1LowerBound:\n ax.set_ylim(bottom=job.Y1LowerBound)\n elif job.Y1UpperBound:\n ax.set_ylim(top=job.Y1UpperBound) \n \n ax.get_yaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=8))\n ax.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\n ax.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\n ax.set_xlabel(job.X1header,fontsize=job.fontSize)\n ax.set_ylabel(job.Y1headers[0],fontsize=job.fontSize)\n p=ax.plot(X1,Y1)\n title=job.name+\"_\"\n title = title + \"vs_\" + job.X1header\n \n if job.X2header != None and not job.X1header.lower() == job.X2header.lower():\n title = title + \"_\" + job.X2header\n \n # Override the constructed title if desired\n if job.titleOverride != None and not len(job.titleOverride)==0 and not job.titleOverride.lower() == \"None\".lower():\n title = job.titleOverride\n if job.log>=1:\n logging.info(\"Creating Graph:\"+title)\n \n if job.titleOverride !=\"None\":\n plt.title(title,fontsize=job.fontSize)\n \n if job.showGridLines:\n plt.grid(b=True, which='major', color='r', linestyle='--')\n \n if not job.removeAllLegends:\n labs=job.Y1headers\n plt.legend(p,labs)\n \n if \"(\" and \")\" in job.outputFilename:\n job.outputFilename=job.outputFilename.split(\"(\")[0]+\".jpg\"\n plt.savefig(os.path.join(job.outputDir,job.outputFilename),dpi=my_dpi)\n plt.close(\"all\")\n \n else:\n X1=df.loc[:,job.X1header]\n Y1=df.loc[:,job.Y1headers]\n fig,ax = plt.subplots()\n fig.set_size_inches(w=job.imageWidth/my_dpi+3.1,h=job.imageHeight/my_dpi+1)\n \n if not os.path.exists(job.outputDir):\n os.mkdir(job.outputDir)\n \n if job.X1LowerBound and job.X1UpperBound:\n ax.set_xlim(job.X1LowerBound,job.X1UpperBound)\n elif job.X1LowerBound:\n ax.set_xlim(left=job.X1LowerBound)\n elif job.X1UpperBound:\n ax.set_xlim(right=job.X1UpperBound)\n\n if job.Y1LowerBound and job.Y1UpperBound:\n ax.set_ylim(job.Y1LowerBound,job.Y1UpperBound)\n elif job.Y1LowerBound:\n ax.set_ylim(bottom=job.Y1LowerBound)\n elif job.Y1UpperBound:\n ax.set_ylim(top=job.Y1UpperBound) \n \n ax.get_yaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=8))\n ax.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\n ax.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\n ax.set_xlabel(job.X1header,fontsize=job.fontSize)\n ax.set_ylabel(job.Y1headers[0],fontsize=job.fontSize)\n p1=ax.plot(X1,Y1)\n title=job.name+\"_\"\n title = title + \"vs_\" + job.X1header\n \n if job.X2header != None and not job.X1header.lower() == job.X2header.lower():\n title = title + \"_\" + job.X2header\n \n # Override the constructed title if desired\n if job.titleOverride != None and not len(job.titleOverride)==0 and not job.titleOverride.lower() == \"None\".lower():\n title = job.titleOverride\n if job.log>=1:\n logging.info(\"Creating Graph:\"+title)\n \n if job.titleOverride !=\"None\":\n plt.title(title,fontsize=job.fontSize)\n \n if job.showGridLines:\n plt.grid(b=True, which='major', color='r', linestyle='--')\n \n if not job.removeAllLegends:\n labs=job.Y1headers\n ax.legend(p1, labs)\n \n if \"(\" and \")\" in job.outputFilename:\n job.outputFilename=job.outputFilename.split(\"(\")[0]+\".jpg\"\n plt.savefig(os.path.join(job.outputDir,job.outputFilename),dpi=my_dpi)\n plt.close(\"all\")","def generate_plots(self, headers: [str], barplot_name: str, barplot_data: [int],\n lineplot_name: str, multi_data: [[int]]):\n self.export_data(barplot_name, headers, barplot_data)\n title = 'Total IRTs (' + str(C.MAX_ITERATIONS) + ' Steps)'\n self.barplot(barplot_name, y_label='Total IRT', img_title=title)\n self.lineplot(lineplot_name, headers, multi_data, img_title='IRT Paths')","def plot_rates(save_dir, formation_rate, merger_rate, detection_rate, redshifts, chirp_masses, show_plot = False, mu0=0.035, muz=-0.23, sigma0=0.39, sigmaz=0., alpha=0):\n # sum things up across binaries\n total_formation_rate = np.sum(formation_rate, axis=0)\n total_merger_rate = np.sum(merger_rate, axis=0)\n total_detection_rate = np.sum(detection_rate, axis=0)\n \n # and across redshifts\n cumulative_detection_rate = np.cumsum(total_detection_rate)\n detection_rate_by_binary = np.sum(detection_rate, axis=1)\n\n ###########################\n #Start plotting\n\n # set some constants for the plots\n plt.rc('font', family='serif')\n fs = 20\n lw = 3\n\n fig, axes = plt.subplots(2, 2, figsize=(20, 20))\n\n axes[0,0].plot(redshifts, total_formation_rate, lw=lw)\n axes[0,0].set_xlabel('Redshift', fontsize=fs)\n axes[0,0].set_ylabel(r'Formation rate $[\\rm \\frac{\\mathrm{d}N}{\\mathrm{d}Gpc^3 \\mathrm{d}yr}]$', fontsize=fs)\n\n axes[0,1].plot(redshifts, total_merger_rate, lw=lw)\n axes[0,1].set_xlabel('Redshift', fontsize=fs)\n axes[0,1].set_ylabel(r'Merger rate $[\\rm \\frac{\\mathrm{d}N}{\\mathrm{d}Gpc^3 \\mathrm{d}yr}]$', fontsize=fs)\n\n axes[1,0].plot(redshifts[:len(cumulative_detection_rate)], cumulative_detection_rate, lw=lw)\n axes[1,0].set_xlabel('Redshift', fontsize=fs)\n axes[1,0].set_ylabel(r'Cumulative detection rate $[\\rm \\frac{\\mathrm{d}N}{\\mathrm{d}yr}]$', fontsize=fs)\n\n axes[1,1].hist(chirp_masses, weights=detection_rate_by_binary, bins=25, range=(0, 50))\n axes[1,1].set_xlabel(r'Chirp mass, $\\mathcal{M}_c$', fontsize=fs)\n axes[1,1].set_ylabel(r'Mass distribution of detections $[\\rm \\frac{\\mathrm{d}N}{\\mathrm{d}\\mathcal{M}_c \\mathrm{d}yr}]$', fontsize=fs)\n\n #########################\n #Plotvalues\n\n # Add text upper left corner\n axes[0,0].text(0.05,0.8, \"mu0=%s \\nmuz=%s \\nsigma0=%s \\nsigmaz=%s \\nalpha=%s\"%(mu0,muz,sigma0,sigmaz,alpha), transform=axes[0,0].transAxes, size = fs) \n\n for ax in axes.flatten():\n ax.tick_params(labelsize=0.9*fs)\n\n # Save and show :)\n plt.savefig(save_dir +'Rate_Info'+\"mu0%s_muz%s_alpha%s_sigma0%s_sigmaz%s\"%(mu0,muz,alpha,sigma0, sigmaz)+'.png', bbox_inches='tight') \n if show_plot:\n plt.show()\n else:\n plt.close()","def radial_graph(self):\n \n if self['M_RADIAL']['intens'] != None:\n name = self['name']\n id = self._getGraphId()\n figname = 'RADIAL_%s.eps' % id\n sxlabel = 'Pixel Radius' ; sylabel = 'Intens' \n title = 'Radial profile, %s' % (name,)\n y = self['M_RADIAL']['intens']\n x = self['M_RADIAL']['radii']\n xy = ((x,y),)\n Plot(xy,figname,sxlabel,sylabel,title)\n self['figures']['radial'] = figname\n else : pass","def plot_tiltres(setup, mtilt, ytilt, yfit, slit=None, outfile=None, show_QA=False, out_dir=None):\n\n plt.rcdefaults()\n plt.rcParams['font.family']= 'times new roman'\n\n # Outfil\n method = inspect.stack()[0][3]\n if (outfile is None) and (not show_QA):\n outfile = qa.set_qa_filename(setup, method, slit=slit, out_dir=out_dir)\n\n # Setup\n plt.figure(figsize=(8, 4.0))\n plt.clf()\n ax = plt.gca()\n\n # Scatter plot\n res = (mtilt-ytilt) - yfit\n ax.scatter(mtilt, res)\n\n rms = np.std(res)\n ax.text(0.90, 0.90, 'Slit {:d}: RMS (pix) = {:0.5f}'.format(slit, rms),\n transform=ax.transAxes, size='large', ha='right', color='black')\n # Label\n ax.set_xlabel('Row')\n ax.set_ylabel('Residual (pix)')\n\n # Finish\n plt.tight_layout(pad=0.2, h_pad=0.0, w_pad=0.0)\n if show_QA:\n plt.show()\n else:\n plt.savefig(outfile, dpi=400)\n plt.close()\n\n plt.rcdefaults()\n\n return","def make_posterior_plots(self, combined=False):\n import matplotlib.pyplot as plt\n plt.rcParams['text.usetex'] = True\n\n if combined:\n outdir = os.path.join(self.outdir, 'CombinedPosteriors')\n maintitle = self.make_main_title(end='Posteriors')\n else:\n outdir = os.path.join(self.outdir, 'IndividualPosteriors')\n maintitle = self.make_main_title(end='Posterior')\n mkdir(outdir)\n\n for injkey in self.values.keys():\n for fhkey in self.values[injkey].keys():\n # Set up multi-plot if needed\n if combined:\n num_rows = self.get_num_rows(\n data=self.values[injkey][fhkey],\n omit_metric=False\n )\n plt.figure(figsize=(20, 5*num_rows+2))\n subplotnum = 1\n else:\n subplotnum = None\n # Loop through the systematics\n for systkey in self.values[injkey][fhkey].keys():\n fittitle = self.make_fit_title(\n fhkey=fhkey,\n trials=self.num_trials\n )\n systunits = self.values[injkey][fhkey][systkey]['units']\n if systkey == 'metric_val':\n xlabel = self.tex_axis_label(\n self.values[injkey][fhkey][systkey]['type']\n )\n else:\n xlabel = self.tex_axis_label(systkey)\n if not systunits == 'dimensionless':\n xlabel += r' (%s)'%self.tex_axis_label(systunits)\n # Specify the subplot, if necessary\n if combined:\n plt.subplot(num_rows, 4, subplotnum)\n self.make_1d_hist_plot(\n data=np.array(\n self.values[injkey][fhkey][systkey]['vals']\n ),\n xlabel=xlabel,\n title=maintitle+r'\\\\'+fittitle,\n ylabel='Number of Trials',\n subplotnum=subplotnum\n )\n # Add the details i.e. injected/fiducial lines and priors\n plt.ylim(0, 1.35*plt.ylim()[1])\n if not systkey == 'metric_val':\n self.add_inj_fid_lines(\n injkey=injkey,\n systkey=systkey,\n fhkey=fhkey\n )\n self.add_prior_region(\n injkey=injkey,\n systkey=systkey,\n fhkey=fhkey\n )\n plt.legend(\n loc='upper left',\n fontsize=12,\n framealpha=1.0\n )\n plt.subplots_adjust(\n left=0.10,\n right=0.90,\n top=0.85,\n bottom=0.11\n )\n # Advance the subplot number, if necessary\n if combined:\n subplotnum += 1\n # Else, save/close this plot\n else:\n self.save_plot(\n fhkey=fhkey,\n outdir=outdir,\n end='%s_posterior'%systkey\n )\n plt.close()\n # Save the whole canvas, if necessary\n if combined:\n plt.suptitle(maintitle+r'\\\\'+fittitle, fontsize=36)\n plt.tight_layout()\n plt.subplots_adjust(top=0.9)\n self.save_plot(\n fhkey=fhkey,\n outdir=outdir,\n end='posteriors'\n )\n plt.close()","def plot_analysis(opt):\n LOG.debug(\"Plotting GetLLM analysis.\")\n mdl_analysis = opt.subnode in mdl_subnodes\n\n ps.set_style(\"standard\", MANUAL_STYLE)\n xmin = min(opt.xplot_xmin, opt.yplot_xmin)\n xmax = max(opt.xplot_xmax, opt.yplot_xmax)\n\n gs = gridspec.GridSpec(2, 1, height_ratios=[1, 1])\n ax_x = plt.subplot(gs[0])\n ax_y = None\n ir_pos = None\n\n paths = opt.path.split(',')\n\n if opt.label == 'None':\n if mdl_analysis:\n labels = [\"mo_\" + opt.path.rsplit('/', 1)[-1], \"me_\" + opt.path.rsplit('/', 1)[-1]]\n else:\n labels = paths\n else:\n labels = opt.label.split(',')\n\n for idx, path in enumerate(paths):\n data_x, data_y = get_data(path, opt.mainnode, opt.subnode)\n plot_data(ax_x, data_x, labels, idx, opt.change_marker)\n\n if ir_pos is None:\n ir_pos = get_irpos(data_x, opt.accel)\n\n if data_y is not None:\n if ax_y is None:\n ax_x.axes.get_xaxis().set_visible(False)\n ax_y = plt.subplot(gs[1])\n plot_data(ax_y, data_y, labels, idx, opt.change_marker)\n\n ax_x.set_xlim(xmin, xmax)\n ax_x.set_ylim(opt.xplot_ymin, opt.xplot_ymax)\n set_yaxis_label(ax_x, 'x', opt.subnode)\n\n if ax_y is not None:\n ax_y.set_xlim(xmin, xmax)\n ax_y.set_ylim(opt.yplot_ymin, opt.yplot_ymax)\n set_yaxis_label(ax_y, 'y', opt.subnode)\n ps.set_xaxis_label(ax_y)\n if ir_pos:\n ps.show_ir(ir_pos, ax_y, mode='outside')\n ps.show_ir(ir_pos, ax_x, mode='lines')\n else:\n ax_x.axes.get_xaxis().set_visible(True)\n ps.set_xaxis_label(ax_x)\n if ir_pos:\n ps.show_ir(ir_pos, ax_x, mode='outside')\n\n if int(opt.legendh) > 12:\n show_legend(ax_x, int(opt.legendx), int(opt.legendy))\n return gs","def plot(self, **kwargs):\n\n # get colors\n colors = kwargs.get(\"colors\", GW_OBSERVATORY_COLORS)\n\n # get Result samples\n self._samples = {\n label: value.posterior\n for label, value in self.results.items()\n if isinstance(value, Result)\n }\n\n # get Grid posteriors\n self._grids = {\n label: [value, value.ln_evidence] # store grid and log evidence\n for label, value in self.results.items()\n if isinstance(value, Grid)\n }\n\n # apply offsets for slightly nicer plots axes\n self.parameter_offsets = {parameter: 0.0 for parameter in self.parameters}\n if len(self._grids) == 0 and len(self._samples) == 1:\n for label in self._samples:\n for parameter in self.parameters:\n srange = [\n np.min(self._samples[label][parameter]),\n np.max(self._samples[label][parameter]),\n ]\n label_suffix = \"\"\n\n # offset values\n median = np.median(self._samples[label][parameter])\n relwidth = np.abs((srange[1] - srange[0]) / median)\n\n if relwidth < 1e-4:\n offsetstr = f\"{median:.4e}\"\n a, b = offsetstr.split(\"e\")\n\n if np.abs(int(b)) < 3:\n offsetstr = f\"{median:.4f}\"\n offset = float(offsetstr)\n else:\n offset = float(offsetstr)\n offsetstr = a + rf\"\\!\\times\\!10^{{{int(b)}}}\"\n\n self.parameter_offsets[parameter] = offset\n\n self._samples[label][parameter] -= offset\n label_suffix = rf\" [${{\\scriptstyle {offsetstr}}}$]\"\n\n self.latex_labels[parameter] += label_suffix\n\n colordicts = []\n for j, res in enumerate([self._samples, self._grids]):\n colordicts.append({})\n for i, key in enumerate(res):\n if key in colors:\n colordicts[-1][key] = colors[key]\n elif key.lower() == \"joint\":\n # if using \"Joint\" as the multi-detector analysis key, set the color to black\n colordicts[-1][key] = \"k\"\n else:\n # use PESummary color cycle\n colordicts[-1][key] = list(colorcycle)[\n (j * 2 + i) % len(colorcycle)\n ]\n\n # store original keywords arguments\n origkwargs = kwargs.copy()\n\n # plot samples\n fig = None\n if len(self._samples) > 0:\n kwargs[\"colors\"] = list(colordicts[0].values())\n if self._num_parameters == 1:\n fig = self._1d_plot_samples(**kwargs)\n elif self._num_parameters == 2 and self.plottype != \"corner\":\n fig = self._2d_plot_samples(**kwargs)\n else:\n fig = self._nd_plot_samples(**kwargs)\n\n # restore keywords\n kwargs = origkwargs\n\n if len(self._grids) > 0:\n kwargs[\"colors\"] = list(colordicts[1].values())\n if fig is not None and \"fig\" not in kwargs:\n kwargs[\"fig\"] = fig\n if self._num_parameters == 1:\n fig = self._1d_plot_grid(**kwargs)\n elif self._num_parameters == 2 and self.plottype != \"corner\":\n fig = self._2d_plot_grid(**kwargs)\n else:\n fig = self._nd_plot_grid(**kwargs)\n\n # add further figure information\n if self._num_parameters == 1:\n ax = fig.gca()\n\n # set figure bounds if outside defaults\n if self.parameters[0] in DEFAULT_BOUNDS:\n _set_axes_limits(ax, self.parameters[0], axis=\"x\")\n\n # add injection values\n if self.injection_parameters is not None:\n if self.injection_parameters[self.parameters[0]] is not None:\n ax.axvline(\n (\n self.injection_parameters[self.parameters[0]]\n - self.parameter_offsets[self.parameters[0]]\n ),\n color=kwargs.get(\"injection_color\", \"k\"),\n linewidth=1,\n )\n elif self._num_parameters == 2:\n if \"triangle\" in self.plottype:\n a1, a2, a3 = fig[1:]\n order = [\"x\", \"y\"] if self.plottype == \"triangle\" else [\"y\", \"x\"]\n params = (\n self.parameters[:2]\n if self.plottype == \"triangle\"\n else self.parameters[1::-1]\n )\n\n # set figure bounds if outside defaults\n for param, axes, axis in zip(params, [[a1, a2], [a2, a3]], order):\n for ax in axes:\n _set_axes_limits(ax, param, axis=axis)\n\n self.fig = fig\n return self.fig","def plot_evaluation(values, info, measures = ['Dice','Jaccard', 'TPR', 'TNR', '1-GCE', 'VS', 'RI', 'ARI', 'MI', '1-VOI', 'ICC','1/(1+PBD)', 'KAP', 'AUC', '1/(1+HD)', '1/(1+AVD)', 'MHD' ], colourmap=None, outfile='polar_results.png'):\n _min = info['minimum']\n _max = info['maximum']\n if colourmap is None:\n colourmap = [[86./255.,180./255.,233./255.] for ii in range(values.shape[0])]\n else:\n # normalize colourmap values between 0 and 1\n colourmap = (colourmap-_min)/(_max-_min)\n # apply cividis, returns the RBG1 values for cividis, for dots\n colourmap = [[cm.cividis(ii)] for ii in colourmap] \n\n # elements of the circle\n N = len(measures)\n # evenly space measures around circle\n x_as = [n / float(N) * 2 * pi for n in range(N)] \n\n # Set color of axes\n plt.rc('axes', linewidth=0.5, edgecolor=\"#888888\")\n\n # Create polar plot\n fig = plt.figure(figsize = (11,9.5))\n gs = gridspec.GridSpec(1, 3, width_ratios=[17,2,1])\n ax = plt.subplot(gs[0], polar=True)\n \n # Set position of y-labels\n ax.set_rlabel_position(0)\n\n # Set color and linestyle of grid\n ax.xaxis.grid(True, color=\"#888888\", linestyle='solid', linewidth=0.5)\n ax.yaxis.grid(True, color=\"#888888\", linestyle='solid', linewidth=0.5)\n\n # Set yticks\n plt.yticks([0.2, 0.4, 0.6, 0.8, 1.0], [\"0.2\", \"0.4\", \"0.6\", \"0.8\", \"1.0\"], fontsize=15)\n pos=ax.get_rlabel_position()\n ax.set_rlabel_position(pos+0.4*360./float(len(measures)))\n\n # Plot data\n for ii in np.arange(values.shape[0]):\n xx = np.asarray(x_as) + np.random.randn(len(x_as))*np.diff(x_as)[0]/15.\n data_norm = None\n if info['logplot']:\n data_norm = matplotlib.colors.LogNorm(vmin=_min, vmax=_max)\n sc = ax.scatter(xx, values[ii,:], 23, color=colourmap[ii]*len(xx), norm=data_norm, zorder=3) \n\n # Fill area\n # close the circle\n median = list(np.median(values, axis=0))\n median += median[:1]\n upper = list(np.percentile(values, 75, axis=0))\n upper += upper[:1]\n lower = list(np.percentile(values, 25, axis=0))\n lower += lower[:1]\n x_as += x_as[:1]\n ax.plot(x_as, median, color=[86./255.,180./255.,233./255.], zorder=5)\n ax.fill_between(x_as, upper, lower, zorder=4, color=[86./255.,180./255.,233./255.], alpha=0.3)\n\n # Set number of radial axes and remove labels\n plt.xticks(x_as[:-1], [])\n\n # Set axes limits\n plt.ylim(0, 1)\n\n # Draw ytick labels to make sure they fit properly\n for i in range(N):\n angle_rad = i / float(N) * 2 * pi-0.05\n text_size = 21\n if i in {3,8}:\n ax.text(angle_rad, 1.15, measures[i]+\"\\n(m=%0.2f)\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\"center\")\n elif i in {0}:\n ax.text(angle_rad, 1.25, measures[i]+\"\\n(m=%0.2f)\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\"center\")\n elif i in {1,5,7}:\n ax.text(angle_rad, 1.29, measures[i]+\"\\n(m=%0.2f)\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\"center\")\n elif i in {4}:\n ax.text(angle_rad, 1.32, measures[i]+\"\\n(m=%0.2f)\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\"top\")\n elif i in {10}:\n ax.text(angle_rad, 1.26, measures[i]+\"\\n(m=%0.2f)\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\"center\")\n elif i in {6}:\n ax.text(angle_rad, 1.25, measures[i]+\"\\n(m=%0.2f)\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\"center\")\n elif i in {9}:\n ax.text(angle_rad, 1.18, measures[i]+\"\\n(m=%0.2f)\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\"center\")\n else:\n ax.text(angle_rad, 1.22, measures[i]+\"\\n(m=%0.2f)\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\"center\")\n\n # colorbar location on figure\n cbaxes = plt.subplot(gs[2])\n\n # log scaling option\n norm = None\n if info['logplot']:\n norm = matplotlib.colors.LogNorm(vmin=_min,vmax=_max)\n\n img = plt.imshow(np.array([[_min,_max]]), aspect='auto', cmap=\"cividis\", norm=norm)\n img.set_visible(False)\n\n # initialize colorbar\n cbar = plt.colorbar(cax = cbaxes)\n\n # ticks and label\n c_values = cbar.get_ticks().tolist()\n \n ticklabels = [\"\" for ii in c_values]\n if _min < np.min(c_values):\n c_values = [_min] + c_values\n ticklabels = [\"%0.1f %s\" %(np.min(c_values), info['unit'])] + ticklabels\n else:\n ticklabels[0] = \"%0.1f %s\" %(np.min(c_values), info['unit'])\n\n if _max > np.max(c_values):\n c_values = c_values + [_max]\n ticklabels = ticklabels + [\"%0.1f %s\" %(np.max(c_values), info['unit'])]\n else:\n ticklabels[-1] = \"%0.1f %s\" %(np.max(c_values), info['unit'])\n \n cbar.set_ticks(c_values)\n cbar.set_ticklabels(ticklabels)\n cbaxes.yaxis.set_minor_formatter(matplotlib.ticker.NullFormatter())\n cbar.ax.set_ylabel(info[\"label\"], labelpad=-20)\n \n # font sizes for colorbar\n cbar.ax.yaxis.label.set_size(19)\n cbar.ax.tick_params(labelsize=14)\n\n # Save and show polar plot \n plt.savefig(outfile)\n if info['display']:\n plt.show()\n plt.clf()\n plt.close('all')","def walkplot(cons):\n # Call always after cons.runn()!\n if not hasattr(cons, \"outplot\"):\n print(\"Consortium must run before analyzing the output of the run!\")\n return\n global plt\n if not plt:\n import matplotlib.pyplot as plt\n\n # keep original inputs\n original_metplots = dcp(cons.mets_to_plot)\n original_outplot = dcp(cons.outplot)\n cons.outplot = \"tmp.png\"\n mets = [k for k in cons.media]\n # loop over metabolites, plot them and let the user close the window\n for m in range(0, len(mets), 4):\n cons.mets_to_plot = [mets[m], mets[m + 1], mets[m + 2], mets[m + 3]]\n plot_comm(cons)\n plt.show()\n print(\"Image number\", m / 4)\n\n # clean temporary files, return to orginal parameters\n plt.close(\"all\")\n os.remove(cons.outplot)\n cons.mets_to_plot = original_metplots\n cons.outplot = original_outplot\n return","def app_SN_combined_moisture_gradient(self, dfs, phase_dirs, sizer_val, styler_val):\n\n print('Currently plotting plot_SN_combined_moisture_gradients')\n\n for df, direc in zip(dfs, phase_dirs):\n self.plotter.plot_SN_combined_moisture_gradients(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['01_combined_plots'],\n sizer=self.formatter.sizer[sizer_val]['3x1_partial_width'],\n styler=self.formatter.styler[styler_val],\n xscale=self.xscale_var.get()\n )\n\n print('Done\\n')","def app_SN_combined_series_moist_vs_temp(self, dfs, phase_dirs, sizer_val, styler_val):\n\n print('Currently plotting plot_SN_combined_series_moist_vs_temp')\n\n for df, direc in zip(dfs, phase_dirs):\n # this iterates one or multiple times\n self.plotter.plot_SN_combined_series_moist_vs_temp(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['08_time_series_moisture_vs_temperature'],\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\n styler=self.formatter.styler[styler_val],\n )\n self.plotter.plot_SN_combined_series_moist_vs_temp(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['08_time_series_moisture_vs_temperature'],\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\n styler=self.formatter.styler[styler_val],\n xaxis_type='datetime',\n )\n self.plotter.plot_SN_combined_series_moist_vs_temp(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['08_time_series_moisture_vs_temperature'],\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\n styler=self.formatter.styler[styler_val],\n normalized=True,\n )\n\n print('Done\\n')","def plot_reion_properties(rank, size, comm, reion_ini_files, gal_ini_files,\n model_tags, reion_plots, output_dir, output_format):\n\n # Check to see if the output directory exists.\n if rank == 0:\n if not os.path.exists(output_dir):\n os.makedirs(output_dir)\n print(\"Made output directory {0}\".format(output_dir))\n\n MC_dir = \"{0}/MC\".format(output_dir)\n os.makedirs(MC_dir)\n print(\"Made directory {0}\".format(MC_dir))\n\n # First calculate all the properties and statistics we need.\n reion_data = generate_data(rank, size, comm, reion_ini_files,\n gal_ini_files, reion_plots, output_dir,\n model_tags, output_format)\n\n # Gather all the fractions onto the master process.\n # This will be used for many different plots. \n master_mass_frac = collective.collect_hist_across_tasks(rank, comm, \n reion_data[\"mass_frac_allmodels\"]) \n master_mass_frac = comm.bcast(master_mass_frac, root = 0)\n\n # Then find out what we need and plot em!\n if reion_plots[\"history\"] and rank == 0:\n\n \n duration_z, duration_t, reion_completed = \\\n calc_duration(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"],\n master_mass_frac, reion_plots[\"duration_definition\"])\n\n for model_number in range(len(master_mass_frac)):\n print(\"Model {0}: Start {1:.2f} \\tMid {2:.2f}\\tEnd {3:.2f}\\t\"\n \"dz {4:.2f}\\tdt {5:.1f}Myr\\tReion Completed {6}\" \\\n .format(model_number, duration_z[model_number][0],\n duration_z[model_number][1], duration_z[model_number][-1],\n duration_z[model_number][0]-duration_z[model_number][-1],\n duration_t[model_number][-1]-duration_t[model_number][0],\n reion_completed[model_number]))\n\n print(\"Plotting the reionization history.\")\n reionplot.plot_history(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n reion_data[\"t_bigbang_allmodels\"],\n master_mass_frac,\n model_tags, output_dir, \"history\",\n output_format)\n\n\n\n if reion_plots[\"nion\"]:\n\n master_nion = collective.collect_hist_across_tasks(rank, comm, \n reion_data[\"nion_allmodels\"])\n\n if rank == 0:\n print(\"Plotting the ionizing emissivity.\")\n reionplot.plot_nion(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n reion_data[\"t_bigbang_allmodels\"],\n master_nion,\n reion_data[\"nion_factor_allmodels\"], \n model_tags, output_dir, \"nion\", output_format)\n\n if reion_plots[\"ps_fixed_XHI\"]:\n k, P21, PHII = determine_ps_fixed_XHI(rank, size, comm,\n reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n master_mass_frac, \n reion_data[\"XHII_fbase_allmodels\"],\n reion_data[\"XHII_precision_allmodels\"],\n reion_data[\"density_fbase_allmodels\"],\n reion_data[\"density_precision_allmodels\"],\n reion_data[\"GridSize_allmodels\"],\n reion_data[\"boxsize_allmodels\"],\n reion_data[\"first_snap_allmodels\"],\n reion_plots[\"fixed_XHI_values\"])\n\n if rank == 0:\n print(\"Plotting PS at fixed neutral fraction.\")\n reionplot.plot_ps_fixed_XHI(k, P21, PHII,\n reion_plots[\"fixed_XHI_values\"],\n model_tags, output_dir, \"ps_fixed_XHI\",\n output_format)\n\n if reion_plots[\"contours\"] and rank == 0:\n # tau is used for multiple plots. So check if we need to calculate it.\n try:\n tau_allmodels\n except NameError:\n tau_allmodels = calc_tau(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n reion_data[\"helium_allmodels\"],\n master_mass_frac)\n\n # For the contours, only plot the optical depth at the highest z.\n tau_highz = []\n for model_number in range(len(tau_allmodels)):\n tau_highz.append(tau_allmodels[model_number][0])\n\n duration_z, duration_t, reion_completed = \\\n calc_duration(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"],\n master_mass_frac, reion_plots[\"duration_definition\"])\n\n print(\"Plotting contours of constant tau.\")\n reionplot.plot_tau_contours(tau_highz, reion_completed,\n reion_plots[\"alpha_beta_limits\"],\n output_dir, \"tau_contours\", output_format)\n\n print(\"Plotting contours of constant reionization duration.\")\n reionplot.plot_duration_contours(duration_t, reion_completed,\n reion_plots[\"alpha_beta_limits\"],\n output_dir, \"duration_contours\",\n output_format)\n\n if reion_plots[\"optical_depth\"] and rank == 0:\n # tau is used for multiple plots. So check if we need to calculate it.\n try:\n tau_allmodels\n except NameError:\n tau_allmodels = calc_tau(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n reion_data[\"helium_allmodels\"],\n master_mass_frac)\n\n print(\"Plotting the optical depth.\")\n reionplot.plot_tau(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"], \n reion_data[\"cosmology_allmodels\"],\n reion_data[\"t_bigbang_allmodels\"],\n tau_allmodels,\n model_tags, output_dir, \"optical_depth\",\n output_format)\n\n if reion_plots[\"optical_depth\"] and reion_plots[\"history\"] and rank == 0:\n print(\"Plotting the combined optical depth/ionization history.\")\n reionplot.plot_combined_history_tau(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"], \n reion_data[\"cosmology_allmodels\"],\n reion_data[\"t_bigbang_allmodels\"],\n master_mass_frac, tau_allmodels, \n model_tags, output_dir,\n \"history_tau\", output_format)\n\n if reion_plots[\"optical_depth\"] and reion_plots[\"nion\"] and rank == 0:\n print(\"Plotting the combined optical depth/ionizing emissivity.\")\n reionplot.plot_combined_nion_tau(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n reion_data[\"t_bigbang_allmodels\"],\n master_nion,\n reion_data[\"nion_factor_allmodels\"],\n tau_allmodels, model_tags, output_dir,\n \"nion_tau\", output_format)\n\n if reion_plots[\"ps_scales\"] or reion_plots[\"ps_scales_beta\"]:\n print(\"Gathering the 21cm Power Spectra across processors\")\n k, P21, PHII = gather_ps(rank, size, comm,\n reion_data[\"k_allmodels\"],\n reion_data[\"P21_allmodels\"],\n reion_data[\"PHII_allmodels\"],\n reion_data[\"first_snap_allmodels\"],\n reion_data[\"last_snap_allmodels\"])\n\n if rank == 0:\n print(\"Plotting the large scale power as a function of small \"\n \"scale.\")\n\n if reion_plots[\"ps_scales_beta\"]:\n calc_beta = True\n else:\n calc_beta = False \n\n # Now that we have all the PS on the master rank, calculate the\n # amplitude at the specified scales.\n scale_power_dict = calc_scale_power(k, P21, PHII,\n reion_data[\"z_array_reion_allmodels\"], \n reion_plots[\"small_scale_def\"],\n reion_plots[\"large_scale_def\"],\n reion_plots[\"small_scale_err\"],\n reion_plots[\"large_scale_err\"],\n calc_beta=calc_beta)\n\n k_small_scale = scale_power_dict[\"k_small_scale\"]\n k_large_scale = scale_power_dict[\"k_large_scale\"]\n\n P21_small_scale = scale_power_dict[\"P21_small_scale\"]\n P21_large_scale = scale_power_dict[\"P21_large_scale\"]\n\n PHII_small_scale = scale_power_dict[\"PHII_small_scale\"]\n PHII_large_scale = scale_power_dict[\"PHII_large_scale\"]\n\n if reion_plots[\"ps_scales\"]:\n reionplot.plot_ps_scales(P21_small_scale,\n P21_large_scale, master_mass_frac, \n reion_data[\"z_array_reion_allmodels\"],\n reion_plots[\"fixed_XHI_values\"],\n reion_plots[\"ps_scales_z\"],\n reion_plots[\"small_scale_def\"],\n reion_plots[\"large_scale_def\"],\n reion_plots[\"small_scale_err\"],\n reion_plots[\"large_scale_err\"],\n model_tags, output_dir, \"ps_scales\",\n output_format)\n\n if reion_plots[\"ps_scales_beta\"]:\n\n P21_beta = scale_power_dict[\"P21_beta\"]\n P21_beta_error = scale_power_dict[\"P21_beta_error\"]\n PHII_beta = scale_power_dict[\"PHII_beta\"]\n\n reionplot.plot_ps_beta(P21_beta, P21_beta_error,\n reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n reion_data[\"t_bigbang_allmodels\"],\n reion_plots[\"small_scale_def\"],\n reion_plots[\"large_scale_def\"],\n model_tags, output_dir,\n \"ps_scales_beta\", output_format)\n\n\n\n if reion_plots[\"slices_fixed_XHI\"] and rank == 0:\n print(\"Plotting slices at fixed XHI fractions.\")\n reionplot.plot_slices_XHI(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n master_mass_frac, \n reion_data[\"XHII_fbase_allmodels\"],\n reion_data[\"XHII_precision_allmodels\"],\n reion_data[\"GridSize_allmodels\"],\n reion_data[\"boxsize_allmodels\"],\n reion_data[\"first_snap_allmodels\"],\n reion_plots[\"fixed_XHI_values\"],\n reion_plots[\"cut_slice\"],\n reion_plots[\"cut_thickness\"],\n model_tags, output_dir, \"slices_XHI\",\n output_format)\n\n\n if reion_plots[\"bubble_size\"] and rank == 0:\n print(\"Determining bubble sizes at fixed XHI.\")\n reionplot.determine_bubble_size(reion_data[\"z_array_reion_allmodels\"],\n master_mass_frac,\n reion_data[\"first_snap_allmodels\"],\n reion_data[\"GridSize_allmodels\"],\n reion_data[\"boxsize_allmodels\"],\n reion_plots[\"fixed_XHI_values\"],\n model_tags, output_dir)\n\n if reion_plots[\"zreion_dens_cross\"] and rank == 0:\n print(\"Calculating the zreion-density cross correlation.\")\n k, crosspspec, crosscorr, bias = \\\n zreion_dens_cross(reion_data[\"density_fbase_allmodels\"],\n reion_data[\"density_precision_allmodels\"],\n reion_data[\"zreion_path_allmodels\"],\n reion_data[\"GridSize_allmodels\"],\n reion_data[\"boxsize_allmodels\"],\n reion_data[\"last_snap_allmodels\"])\n\n reionplot.plot_zreion_dens_cross(k, crosscorr, bias, model_tags,\n output_dir, \"zreion_dens_crosscorr\",\n output_format)\n\n if reion_plots[\"dens_ion_contours\"] and rank == 0:\n print(\"Plotting contours of density-ionization.\")\n reionplot.plot_dens_reion_contours(master_mass_frac,\n reion_data[\"XHII_fbase_allmodels\"],\n reion_data[\"XHII_precision_allmodels\"],\n reion_data[\"density_fbase_allmodels\"],\n reion_data[\"density_precision_allmodels\"],\n reion_data[\"GridSize_allmodels\"],\n reion_data[\"first_snap_allmodels\"],\n reion_plots[\"fixed_XHI_values\"],\n model_tags, output_dir,\n \"dens_ion_contours\", output_format)\n\n if reion_plots[\"dens_zreion_contours\"] and rank == 0:\n print(\"Plotting contours of density-zreion.\")\n reionplot.plot_dens_zreion_contours(reion_data[\"density_fbase_allmodels\"],\n reion_data[\"density_precision_allmodels\"],\n reion_data[\"zreion_path_allmodels\"],\n reion_data[\"GridSize_allmodels\"],\n reion_data[\"last_snap_allmodels\"],\n model_tags, output_dir,\n \"dens_zreion_contours\", output_format)","def plot_uv(self):\n self.current_plot = 'uv'\n self.ax_zoomed = False\n \n uu = self.uv.d_uv_data['UU']*1e6\n vv = self.uv.d_uv_data['VV']*1e6\n xx = self.uv.d_array_geometry['STABXYZ'][:,0]\n yy = self.uv.d_array_geometry['STABXYZ'][:,1]\n pmax, pmin = np.max([uu, vv])*1.1, np.min([uu,vv])*1.1\n\n \n fig = self.sp_fig\n plt.subplot(121, aspect='equal')\n ax = plt.plot(xx, yy, 'bo')\n for i in range(len(xx)):\n plt.text(xx[i], yy[i], self.uv.d_array_geometry['ANNAME'][i].strip('Stand').strip('Tile'))\n\n plt.title(\"Antenna positions\")\n plt.xlabel(\"X [m]\")\n plt.ylabel(\"Y [m]\")\n \n plt.subplot(122, aspect='equal')\n ax = plt.plot(uu, vv, 'b.')\n plt.title(\"UV data\")\n plt.xlabel(\"UU [$\\\\mu s$]\")\n plt.ylabel(\"VV [$\\\\mu s$]\")\n plt.xlim(pmin, pmax)\n plt.ylim(pmin, pmax)\n return fig, ax","def plot_lollipop(clinvar_path_count):\n os.chdir(\"/Users/Files/nogit/generisk/lollipop/figure\")\n app = '/Users/files/work/bin/lollipops'\n for i in x.itertuples(False, None):\n # uid, variants, gn\n os.system(\"%s -domain-labels=fit -U %s -o %s.svg %s\" % (app, i[0], i[2], i[1]))\n # os.system(\"rsvg-convert %s.svg -o %s_rsvg.png\"%(i[2],i[2]))\n os.system(\"convert -density 500 -units pixelsperinch %s.svg %s.png\" % (i[2], i[2]))","def plot_profiles(self, fig=0, title=''):\n plot_input.plot_profiles(self, fig, title)","def plot_dataset(\n self,\n out_dir: str = None,\n therm_frac: int = 0.,\n num_chains: int = None,\n ridgeplots: bool = True,\n profile: bool = False,\n ):\n tdict = {}\n dataset = self.get_dataset(therm_frac)\n for key, val in dataset.data_vars.items():\n t0 = time.time()\n if np.std(val.values.flatten()) < 1e-2:\n continue\n\n if len(val.shape) == 2: # shape: (chain, draw)\n val = val[:num_chains, :]\n\n if len(val.shape) == 3: # shape: (chain, leapfrogs, draw)\n val = val[:num_chains, :, :]\n\n fig, ax = plt.subplots(constrained_layout=True, figsize=set_size())\n _ = val.plot(ax=ax)\n if out_dir is not None:\n io.check_else_make_dir(out_dir)\n out_file = os.path.join(out_dir, f'{key}_xrPlot.png')\n fig.savefig(out_file, dpi=400, bbox_inches='tight')\n plt.close('all')\n plt.clf()\n\n if profile:\n tdict[key] = time.time() - t0\n io.log(f'time spent plotting {key}: {tdict[key]}')\n\n if out_dir is not None:\n out_dir = os.path.join(out_dir, 'ridgeplots')\n io.check_else_make_dir(out_dir)\n\n if ridgeplots:\n make_ridgeplots(dataset, num_chains=num_chains, out_dir=out_dir)\n\n return tdict","def plot_rose(ext_data, plot_label=None):\n result = ext_data.copy(deep=False)\n sectors = len(result)\n fig = plt.figure(figsize=(12, 12))\n ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=True)\n ax.set_theta_zero_location('N')\n ax.set_theta_direction(-1)\n ax.set_thetagrids(np.arange(0, 360, 360.0/sectors))\n sector_mid_points = []\n widths = []\n for i in result.index:\n angular_pos_start = (np.pi / 180.0) * float(i.split('-')[0])\n angular_pos_end = (np.pi / 180.0) * float(i.split('-')[-1])\n if angular_pos_start < angular_pos_end:\n sector_mid_points.append((angular_pos_start+angular_pos_end)/2.0)\n widths.append(angular_pos_end-angular_pos_start - (np.pi / 180))\n else:\n sector_mid_points.append((np.pi + (angular_pos_start + angular_pos_end)/2.0) % 360)\n widths.append(2*np.pi - angular_pos_start + angular_pos_end - (np.pi / 180))\n max_contour = (ext_data.max() + ext_data.std())\n contour_spacing = max_contour / 10\n num_digits_to_round = 0\n while contour_spacing*(10**num_digits_to_round) <= 1:\n num_digits_to_round += 1\n if 0.5 < contour_spacing < 1:\n contour_spacing = 1\n levels = np.arange(0, max_contour, round(contour_spacing, num_digits_to_round))\n ax.set_rgrids(levels, labels=[str(i) for i in levels], angle=0)\n ax.bar(sector_mid_points, result, width=widths, bottom=0.0, color=COLOR_PALETTE.primary,\n edgecolor=[COLOR_PALETTE.primary_35 for i in range(len(result))], alpha=0.8)\n ax.legend([plot_label])\n plt.close()\n return ax.get_figure()","def plotBatch(inp,output='spectra_plot.pdf',comparisons=None,classify=False,normalize=False,normrange=[0.9,1.4],layout=[2,2],basecolors=['k','m'],legend=[],fontscale=0.7,classify_kwargs={},plot_kwargs={},**kwargs):\n\n# alt keyword check\n for k in ['file','filename']: \n if kwargs.get(k,'') != '': output = kwargs[k]\n for k in ['legends','labels']: \n if kwargs.get(k,'') != '': legend = kwargs[k]\n\n# force input into a list\n if isinstance(inp,list): inputlist = copy.deepcopy(inp)\n else: inputlist = [inp]\n\n# if input is a string of filenames, read in each file to a spectrum object\n if isinstance(inputlist[0],str):\n# try a glob search string \n files = glob.glob(os.path.normpath(inputlist[0]))\n if len(files) > 1 or (len(files) == 1 and inputlist[0].find('*') != -1):\n inputlist = files\n# try reading in files into Spectrum object\n try:\n splist = [splat.Spectrum(file = f) for f in inputlist]\n except:\n raise ValueError('\\nCould not read in list of files {} - make sure the full path is specified and the files are correctly formatted'.format(inputlist))\n\n# if filenames, read in each file to a spectrum object\n elif isinstance(inputlist[0],splat.Spectrum):\n splist = copy.deepcopy(inputlist)\n else:\n raise ValueError('\\nInput should be list of splat.Spectrum objects or filenames')\n\n# normalize if desired\n if normalize==True:\n tmp = [sp.normalize(normrange) for sp in splist]\n\n# comparison files are present\n complist = []\n if comparisons != None:\n comp = copy.deepcopy(comparisons)\n if not isinstance(comp,list): comp = [comp]\n if isinstance(comp[0],str):\n try:\n complist = [splat.Spectrum(file = f) for f in comp]\n except:\n print('\\nCould not read in comparison files: ignoring comparisons')\n if isinstance(comp[0],splat.Spectrum):\n complist = comp\n if len(complist) < len(splist):\n while len(complist) < len(splist):\n complist.append(complist[-1])\n# normalize\n if normalize==True:\n tmp = [sp.normalize(normrange) for sp in complist]\n\n# set comparison files to be standards for spectral classification\n# overrules input comparison sample\n if classify == True:\n complist = []\n base_kwargs={\n 'return_standard': True,\n 'method': 'kirkpatrick',\n }\n base_kwargs.update(classify_kwargs)\n for sp in splist:\n complist.append(splat.classifyByStandard(sp,**base_kwargs))\n\n# prep for plotting\n plotlist = []\n clist = []\n for i,sp in enumerate(splist):\n if len(complist) == len(splist):\n plotlist.append([sp,complist[i]])\n clist.extend(basecolors)\n else:\n plotlist.append([sp])\n clist.extend(basecolors[0])\n\n# manage legends\n if len(legend) != 0:\n if not isinstance(legend,list): legend = [legend]\n if len(legend) < (len(splist)+len(complist)):\n# guess: just left out the comparison legends \n if len(complist) > 0 and len(legend) == len(splist):\n legtmp = []\n for i,l in enumerate(legend):\n legtmp.extend([l,'{}'.format(complist[i].name)])\n legend = legtmp\n else:\n# otherwise: pad the remaining legends with the last legend (pairs) \n while len(legend) < (len(splist)+len(complist)):\n if len(complist)>0:\n legend.extend([legend[-2],legend[-1]])\n else:\n legend.extend([legend[-1]])\n if len(legend) > (len(splist)+len(complist)):\n legend = legend[0:(len(splist)+len(complist))]\n else:\n legend = []\n for i,sp in enumerate(splist):\n l = []\n if 'name' in list(sp.__dict__.keys()): l.append(sp.name)\n else: l.append(os.path.basename(sp.filename))\n if len(complist)>0:\n if 'name' in list(complist[i].__dict__.keys()): l.append(complist[i].name)\n else: l.append(os.path.basename(complist[i].filename))\n legend.extend(l)\n\n# generate plot\n base_kwargs={\n 'multiplot': True,\n 'multipage': True,\n 'legends': legend,\n 'colors': clist,\n 'layout': layout,\n 'fontscale': fontscale,\n 'output': output,\n }\n base_kwargs.update(plot_kwargs)\n fig = plotSpectrum(plotlist,**base_kwargs)\n\n return fig","def multiple(folder_name: str,\r\n min_plant_pixels: int = MIN_PLANT_SIZE,\r\n output_options = [['rows',\r\n 'centers',\r\n 'row_ids',\r\n 'distances'],\r\n \r\n ['rows',\r\n 'centers',\r\n 'row_ids',\r\n 'numbers'],\r\n \r\n ['dirt',\r\n 'ditches',\r\n 'rows',\r\n 'clusters',\r\n 'centers',\r\n 'row_ids',\r\n 'numbers',\r\n 'lines']\r\n ]) -> None:\r\n\r\n # Go to the specified folder\r\n ls = listdir(folder_name)\r\n ls = [join(folder_name, i) for i in ls]\r\n\r\n # Check if the folder exists\r\n if join(folder_name, 'Analysis') in ls:\r\n\r\n # If it does, rename the old folder\r\n new_name = join(folder_name, 'Analysis')\r\n while new_name in ls:\r\n new_name += '_old'\r\n \r\n rename(join(folder_name,'Analysis'), new_name)\r\n\r\n # Create new folders inside the given directory\r\n mkdir(join(folder_name, 'Analysis'))\r\n mkdir(join(folder_name, 'Analysis/Images'))\r\n mkdir(join(folder_name, 'Analysis/Data'))\r\n \r\n # Gather the images to be analysed\r\n co = 0\r\n pics = [j for j in ls if isfile(j)]\r\n le = len(pics)\r\n\r\n # Analyze each of the pictures\r\n for i in pics:\r\n\r\n # Make the field\r\n field = just_field(i, min_plant_pixels)\r\n\r\n # Measure the field and save results\r\n print('Saving data...\\n')\r\n ruler = Ruler(field)\r\n \r\n ruler.output_distances(\r\n join(folder_name,\r\n 'Analysis/Data/{}_Distances.csv'.format(basename(i).split('.')[0])\r\n ) \r\n )\r\n \r\n ruler.output_row_info(\r\n join(folder_name,\r\n 'Analysis/Data/{}_Rows.csv'.format(basename(i).split('.')[0])\r\n )\r\n )\r\n\r\n # Make and save visuals\r\n print('Saving pictures...\\n')\r\n for k in range(len(output_options)):\r\n output_options[k]\r\n img = field.make_visual(ruler, output_options[k])\r\n img.save(\r\n join(folder_name,\r\n 'Analysis/Images/{}_Visual_{}.png'.format(basename(i).split('.')[0], k + 1)))\r\n\r\n # Increment the progress meter\r\n co += 1\r\n print('Completed {}/{} images\\n\\n'.format(co, le))","def main(fpath):\n\t# Load results data\n\twith open(fpath) as f:\n\t\tlines = f.readlines()\n\n\tresults = []\n\tfor line in lines:\n\t\tif not line.startswith(\"//\"):\n\t\t\tresults.append(json.loads(line))\n\n\t# Format relevent data\n\tresults = sorted(results, key=lambda k: k['data_lens'][\"mean\"])\n\t# x = [np.log(x[\"block_lens\"][\"mean\"]) for x in results]\n\tx = [x[\"data_lens\"][\"mean\"] for x in results]\n\ty = [x[\"mean\"] for x in results]\n\tyy = [x[\"block_lens\"][\"mean\"] for x in results]\n\n\n\t# Plot graphs\n\tplt.figure(figsize=(14,5))\n\tplt.subplot(1,2,1)\n\tplt.title('Ratio of Total Block Size to Primary Data Size Against Primary Data Size')\n\tplt.ylabel('Total Block Size / Primary Data Size')\n\t# plt.xlabel('log( Primary Data Size )')\n\tplt.xlabel('Primary Data Size (chars)')\n\tplt.plot(x, y)\n\n\tplt.subplot(1,2,2)\n\tplt.title('Total Block Size Against Primary Data Size')\n\tplt.ylabel('Total Block Size (chars)')\n\tplt.xlabel('Primary Data Size (chars)')\n\tplt.plot(x, yy)\n\n\n\tplt.show()","def plot_sector_ratio(sec_ratio, wdir, sec_ratio_dist, col_names, boom_dir_1=-1, boom_dir_2=-1):\n radians = np.radians(utils._get_dir_sector_mid_pts(sec_ratio_dist.index))\n fig = plt.figure(figsize=(10, 10))\n ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=True)\n ax.set_theta_zero_location('N')\n ax.set_theta_direction(-1)\n ax.set_thetagrids(utils._get_dir_sector_mid_pts(sec_ratio_dist.index))\n ax.plot(np.append(radians, radians[0]), sec_ratio_dist['Mean_Sector_Ratio'].append(sec_ratio_dist.iloc[0]),\n color=COLOR_PALETTE.primary, linewidth=4)\n # Get max and min levels and set chart axes\n max_level = sec_ratio_dist['Mean_Sector_Ratio'].max() + 0.05\n min_level = sec_ratio_dist['Mean_Sector_Ratio'].min() - 0.1\n ax.set_ylim(min_level, max_level)\n # Add boom dimensions to chart, if required\n width = np.pi / 108\n radii = max_level\n annotate = False\n annotation_text = '* Plot generated using '\n if boom_dir_1 >= 0:\n boom_dir_1_rad = np.radians(boom_dir_1)\n ax.bar(boom_dir_1_rad, radii, width=width, bottom=min_level, color=COLOR_PALETTE.fourth)\n if boom_dir_2 == -1:\n annotation_text += '{} (top mounted) divided by {} ({}° boom)'.format(col_names[1], col_names[0],\n boom_dir_1)\n annotate = True\n if boom_dir_2 >= 0:\n boom_dir_2_rad = np.radians(boom_dir_2)\n ax.bar(boom_dir_2_rad, radii, width=width, bottom=min_level, color=COLOR_PALETTE.fifth)\n if boom_dir_1 == -1:\n annotation_text += '{} ({}° boom) divided by {} (top mounted)'.format(col_names[1], boom_dir_2,\n col_names[0])\n annotate = True\n if boom_dir_2 >= 0 and boom_dir_1 >= 0:\n annotation_text += '{} ({}° boom) divided by {} ({}° boom)'.format(col_names[1], boom_dir_2,\n col_names[0], boom_dir_1)\n annotate = True\n if annotate:\n ax.annotate(annotation_text, xy=(0.5, 0.035), xycoords='figure fraction', horizontalalignment='center')\n ax.scatter(np.radians(wdir), sec_ratio, color=COLOR_PALETTE.secondary, alpha=0.3, s=1)\n plt.close()\n return ax.get_figure()","def run_and_plot(self):\n self.raw_processing()\n self.data_averaging_and_cleaning()\n\n print(self.organized_names)\n print(self.organized_film)\n print(self.organized_plank)\n\n height = self.organized_film\n bars = tuple(self.organized_names.copy())\n y_pos = np.arange(len(bars))\n\n plt.bar(y_pos, height)\n plt.xticks(y_pos, bars)\n plt.xlabel('TH% in 100ul water/TH mixture')\n plt.ylabel('CFU/mL count')\n plt.title('Experiment 2.5 (Sucrose Concentration) 7 Aug 2018')\n\n plt.show()\n\n height2 = self.organized_plank\n\n plt.bar(y_pos, height2)\n plt.xticks(y_pos, bars)\n plt.xlabel('TH% in 100ul water/TH mixture')\n plt.ylabel('Proportion of Biofilm CFUs to Planktonic CFUs')\n plt.title('Experiment 2.5 (Sucrose Concentration) 7 Aug 2018')\n\n plt.show()","def plot_data(\n self,\n out_dir: str = None,\n flags: AttrDict = None,\n therm_frac: float = 0.,\n params: AttrDict = None,\n ):\n plot_data(self.data, out_dir, flags,\n therm_frac=therm_frac, params=params)","def main():\n font = {'family' : 'normal',\n 'weight' : 'normal',\n 'size' : 18}\n\n matplotlib.rc('font', **font)\n\n ###Plot overviews\n\n# plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\"12co_combined_peak_full.png\",\n# show_shells=False,title=r\"Combined $^{12}$CO Peak T$_{MB}$\",\n# dist=orion_dist, vmin=None, vmax=None, scalebar_color='white',\n# scalebar_pc=1.,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325)\n \n plot_overview(plotname=\"../paper/figs/12co_nroonly_peak_full_shells.png\", show_shells=True,\n dist=orion_dist, vmin=None, vmax=None, scalebar_color='black', scale_factor = 1.,\n title=r\"\", shells_highlight=best_shells, circle_style='dotted', circle_linewidth=1.5,\n scalebar_pc=1. #,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325\n )\n\n # plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\"12co_combined_mom0_cometary.png\",\n # show_shells=False, title=r\"Combined Integrated $^{12}$CO\",\n # dist=orion_dist, scalebar_color='white', pmax=93., mode='mom0',\n # scale_factor=1./1000,\n # scalebar_pc=0.2,recenter=True, ra=83.99191, dec=-5.6611303, radius=0.117325)\n\n # plot_overview(plotname=\"12co_nroonly_mom0_cometary.png\", show_shells=False,\n # dist=orion_dist, scalebar_color='white', pmax=93., mode='mom0',\n # scale_factor=1./1000, title=r\"NRO Integrated $^{12}$CO\",\n # scalebar_pc=0.2,recenter=True, ra=83.99191, dec=-5.6611303, radius=0.117325)\n\n # plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\"12co_combined_peak_full_shells.png\",\n # show_shells=True, shells_highlight=shells_score3, title=r\"Combined $^{12}$CO Peak T$_{MB}$\",\n # dist=orion_dist, vmin=None, vmax=None, scalebar_color='white', circle_style='dotted',\n # scalebar_pc=1.,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325)\n\n # return\n\n mips_l1641_file = '../catalogs/MIPS_L1641a_24um.fits'\n mips_onc_file = '../catalogs/MIPS_ONC_24um.fits'\n\n irac1_l1641_file = '../catalogs/IRAC_L1641_ch1_merged_clean.fits'\n irac1_onc_file = '../catalogs/IRAC_ONC_ch1_merged_clean.fits'\n\n irac2_l1641_file = '../catalogs/IRAC_L1641_ch2_merged_clean.fits'\n irac2_onc_file = '../catalogs/IRAC_ONC_ch2_merged_clean.fits'\n\n irac4_l1641_file = '../catalogs/IRAC_L1641_ch4_merged_clean_northup.fits'\n irac4_onc_file = '../catalogs/IRAC_ONC_ch4_merged_clean_northup.fits'\n\n planck_herschel_file = '../catalogs/planck_herschel.fits'\n\n region_file = '../shell_candidates/AllShells.reg'\n vrange_file = '../shell_candidates/AllShells_vrange.txt'\n shell_list = get_shells(region_file=region_file, velocity_file=vrange_file)\n\n obaf_file = 'stars_obaf.txt'\n yso_file = \"../catalogs/spitzer_orion.fit\"\n\n obaf = ascii.read(obaf_file)\n obaf_ra, obaf_dec, obaf_label = np.array(obaf['RA']), np.array(obaf['DEC']), np.array([sp.strip(\"b'\") for sp in obaf['SP_TYPE']])\n yso = fits.open(yso_file)[1].data\n yso_ra, yso_dec, yso_label = yso['RAJ2000'], yso['DEJ2000'], yso['Cl']\n\n # for nshell in range(19,43):\n # shell = shell_list[nshell-1]\n # ra, dec, radius = shell.ra.value, shell.dec.value, shell.radius.value\n\n # #Check whether shell is in each mips image coverage.\n # l1641_xy = WCS(mips_l1641_hdu).all_world2pix(ra, dec, 0)\n \n # if (l1641_xy[0] >= 0) & (l1641_xy[0] <= mips_l1641_hdu.shape[1]) & \\\n # (l1641_xy[1] >= 0) & (l1641_xy[1] <= mips_l1641_hdu.shape[0]):\n # hdu = mips_l1641_hdu\n # else:\n # hdu = mips_onc_hdu\n\n # plot_stamp(map=hdu, ra=ra, dec=dec, radius=radius, circle_color='red',\n # pad_factor=1.5, contour_map=None, contour_levels=5., source_ra=None, source_dec=None, source_lists=None, \n # source_colors='cyan', plotname='{}shell{}_stamp.png'.format('MIPS',nshell), return_fig=False,\n # stretch='linear', plot_simbad_sources=False, dist=orion_dist, cbar_label=r'counts',\n # auto_scale=True, auto_scale_mode='min/max', auto_scale_pad_factor=1., vmin=0, vmax=3000)\n\n\n #cube_file = '../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits'\n cube_file = '../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits'\n ir_l1641_hdu = fits.open(irac4_l1641_file)[0]\n ir_onc_hdu = fits.open(irac4_onc_file)[0]\n\n spec_cube = SpectralCube.read(cube_file)\n ra_grid = spec_cube.spatial_coordinate_map[1].to(u.deg).value\n dec_grid = spec_cube.spatial_coordinate_map[0].to(u.deg).value\n vel_grid = spec_cube.spectral_axis\n pad_factor = 1.5\n\n #plot_overview(show_shells=True)\n #plot_overview(plotname=\"12co_nro_peak.png\", show_shells=False)\n #plot_overview(cube=\"/Volumes/Untitled/13co_pix_2.cm.fits\", plotname=\"13co_combined_peak.png\", show_shells=False)\n #return\n #channel_vmax = [12.9, 14]\n for nshell in range(17,18):\n shell = shell_list[nshell-1]\n ra, dec, radius = shell.ra.value, shell.dec.value, shell.radius.value\n\n l1641_xy = WCS(ir_l1641_hdu).wcs_world2pix(ra, dec, 0)\n #print(l1641_xy)\n if (l1641_xy[0] >= 0) & (l1641_xy[0] <= ir_l1641_hdu.shape[1]) & \\\n (l1641_xy[1] >= 0) & (l1641_xy[1] <= ir_l1641_hdu.shape[0]):\n ir_hdu = ir_l1641_hdu\n else:\n ir_hdu = ir_onc_hdu\n\n #Extract sub_cube around shell.\n subcube_mask = (abs(ra_grid - ra) < radius * pad_factor) &\\\n (abs(dec_grid - dec) < radius * pad_factor)\n sub_cube = spec_cube.with_mask(subcube_mask).minimal_subcube().spectral_slab(shell.vmin, shell.vmax)\n\n #Integrate between vmin and vmax.\n mom0_hdu = sub_cube.moment0().hdu\n\n # mask_inshell = (abs(ra_grid - ra) < radius) &\\\n # (abs(dec_grid - dec) < radius)\n # subcube_inshell = spec_cube.with_mask(mask_inshell).minimal_subcube().spectral_slab(shell.vmin, shell.vmax)\n # mom0_hdu_inshell = subcube_inshell.moment0().hdu\n\n #Calculate contour levels.\n empty_channel = spec_cube.closest_spectral_channel(500*u.Unit('m/s'))\n sigma = np.nanstd(spec_cube[empty_channel][subcube_mask]).value\n #print(\"sigma: {}\".format(sigma))\n delta_vel = (sub_cube.spectral_extrema[1] - sub_cube.spectral_extrema[0]).value\n #print(\"delta_vel: {}\".format(delta_vel))\n mom0_sigma = sigma * delta_vel\n #print(mom0_sigma) \n #contour_levels = np.linspace(5.*mom0_sigma, np.nanmax(mom0_hdu_inshell.data), 12)\n contour_levels = np.linspace(28.*mom0_sigma, 45.*mom0_sigma, 6 )\n\n #Get source coordinates.\n\n\n # plot_stamp(map=ir_hdu, ra=ra, dec=dec, radius=radius, circle_color='red',\n # pad_factor=pad_factor, contour_map=mom0_hdu, contour_levels=contour_levels, contour_color='white',\n # plotname='{}shell{}_{}{}to{}_stamp.png'.format('8µm', nshell, \"12CO\", shell.vmin.value, shell.vmax.value),\n # return_fig=False,\n # stretch='linear', plot_simbad_sources=False, dist=orion_dist,\n # auto_scale=True, auto_scale_mode='median', auto_scale_pad_factor=0.8, auto_scale_nsigma=4.,\n # cbar_label=\"Counts\", cmap='inferno',\n # source_ra=[obaf_ra, yso_ra], source_dec=[obaf_dec, yso_dec],\n # source_colors=['white', 'red'], source_markers=['*', 'None'], source_sizes=[300,50],\n # source_labels=[obaf_label, yso_label], dpi=300\n # )\n\n #cube_file = \"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\"\n \n \n # plot_channels(cube=cube_file, ra=ra, dec=dec, radius=radius,\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\n # plotname='12co_channels_shell'+str(nshell)+'.png', chan_step=2, plot_simbad_sources=False,\n # vmin=None, vmax=None, max_chans=12,\n # #cbar_label=\"Counts\",\n # source_ra=[obaf_ra, yso_ra], source_dec=[obaf_dec, yso_dec],\n # source_colors=['white', 'red'], source_markers=['*', '+'], source_sizes=[200,15], dpi=300)\n\n # angle = 90*u.deg\n # pv = plot_pv(cube=cube_file, ra_center=shell.ra, dec_center=shell.dec,\n # vel=[shell.vmin - 1*u.km/u.s, shell.vmax + 1*u.km/u.s], length=shell.radius*4.,\n # width=7.5*u.arcsec, angle=angle,\n # pad_factor=1., plotname='12co_pv_shell'+str(nshell)+'_angle'+str(angle.value)+'.png',\n # stretch='linear', auto_scale=True, dpi=900.)\n \n\n\n #simbad_brightstars(output='stars_obaf.txt', output_format='ascii', replace_ra='deg')\n\n\n #movie(test=False, labels=False) \n\n #cube_file = '../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits'\n # region_file = '../nro_maps/SouthShells.reg'\n # N = 2 # Number of shell candidates to plot\n # shell_list = get_shells(region_file=region_file)\n\n # cube_file = \"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\"\n # #cube_file = \"../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits\"\n\n # for n in range(1,2):\n # shell = shell_list[n]\n # for deg in np.linspace(0, 180, 13):\n # angle = deg*u.deg\n # pv = plot_pv(cube=cube_file, ra_center=shell.ra, dec_center=shell.dec,\n # vel=[4*u.km/u.s, 8*u.km/u.s], length=shell.radius*2.*4.,\n # width=7.5*u.arcsec, angle=105*u.deg,\n # pad_factor=1., plotname='12co_pv_shell'+str(n+1)+'_angle'+str(angle.value)+'morev.png', return_subplot=True,\n # stretch='linear', auto_scale=True)\n\n # cube_file = \"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\"\n # for n in range(N):\n # shell = shell_list[n]\n # plot_channels(cube=cube_file, ra=shell.ra.value, dec=shell.dec.value, radius=shell.radius.value,\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\n # plotname='12co_channels_shell'+str(n+1)+'.png', chan_step=2, plot_simbad_sources=True, simbad_color='blue')\n\n # cube_file = \"../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits\"\n # for n in range(N):\n # shell = shell_list[n]\n # plot_channels(cube=cube_file, ra=shell.ra.value, dec=shell.dec.value, radius=shell.radius.value,\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\n # plotname='13co_channels_shell'+str(n+1)+'.png', chan_step=2, plot_simbad_sources=True, simbad_color='blue')","def cloudy_hii_radial_hyd(props=['ne'],cols=['b'],model_name = '',**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n if p.add:\n ax = plt.gca()\n else:\n fig,ax = plt.subplots(figsize=(8,6))\n\n for prop,col in zip(props,cols):\n hyd = pd.read_table(p.d_cloudy_test + '%s.hyd' % model_name,skiprows=1,\\\n names=['depth','Te','nH','ne','HI/H','HII/H','H2/H','H2+/H','H3+/H','H-/H'])\n if '/' in prop:\n try:\n ax2.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'o',ms=5,color=col)\n ax2.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'-',lw=1,color=col,label=prop)\n except:\n print('no twinx axis, starting a new one')\n ax2 = ax.twinx()\n ax2.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'o',ms=5,color=col)\n ax2.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'-',lw=1,color=col,label=prop)\n else:\n ax.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'o',ms=5,color=col)\n ax.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'-',lw=1,color=col,label=prop)\n\n ax.set_xlabel('Depth [pc]')\n ax.set_ylabel('cm$^{-3}$')\n ax.legend()\n ax2.legend()\n\n if p.savefig:\n if not os.path.isdir(p.d_plot + 'cloudy/'): os.mkdir(p.d_plot + 'cloudy/') \n plt.savefig(p.d_plot + 'cloudy/%s_hyd.png' % (model_name), format='png', dpi=300, facecolor='w')","def plot_alleles(folder):\n\n abs_alt,perc_alt = parse_geno_file(folder,False)\n\n strain_matcher = re.compile('(.*) \\(.*\\)') ## regex to get strain name from radio button click\n strain_matcher2 = re.compile('(.*)-(.*)')\n \n fig, ax = plt.subplots()\n l, = plt.plot(perc_alt['MC'],perc_alt[S],'bs')\n ax.set_ylabel('Alternate Allele Percentage (MC)')\n ax.set_xlabel('Alternate Allele Percentage (MC)')\n \n rax1 = plt.axes([0.92, 0.1, 0.08, 0.8])\n radio1 = RadioButtons(rax1, ('MC (Sand)','CL (Sand)','CM (Sand)','CN (Sand)','TI (Sand)','DC (Sand)','MS (Sand)','CV (Sand)','PN (Rock)','AC (Rock)','LF (Rock)','MP (Rock)','MZ (Rock)','Sand-MC','Rock-MC','Sand-MZ','Rock-MZ','Rock-Sand'), active=0)\n\n rax2 = plt.axes([0.92, 0.9, 0.08, 0.1])\n radio2 = RadioButtons(rax2, ('%', 'Abs'), active=0)\n\n #for strain in perc_alt.keys():\n #print strain\n \n #ylabel = plt.axes([1,1,0.08,0.08])\n\n def update1(strain):\n if strain not in [\"Rock-MZ\",\"Sand-MC\",\"Rock-MC\",\"Sand-MZ\",\"Rock-Sand\"]:\n match = re.match(strain_matcher,strain)\n strain = match.group(1)\n global base\n base = 'MC'\n else:\n match = re.match(strain_matcher2,strain)\n strain = match.group(1)\n #global base \n base = match.group(2)\n\n #print D\n if(D == \"%\"):\n l.set_xdata(perc_alt[base])\n l.set_ydata(perc_alt[strain])\n ax.set_ylabel('Alternate Allele Percentage (%s)'%(strain))\n ax.set_xlabel('Alternate Allele Percentage (%s)'%(base))\n else:\n l.set_xdata(abs_alt[base])\n l.set_ydata(abs_alt[strain])\n ax.set_ylabel('Alternate Allele Absolute (%s)'%(strain))\n ax.set_xlabel('Alternate Allele Absolute (%s)'%(base))\n\n ax.relim()\n ax.autoscale()\n fig.canvas.draw_idle()\n global S \n #print S\n S = strain\n\n\n def update2(data):\n if(data == '%'):\n l.set_xdata(perc_alt[base])\n l.set_ydata(perc_alt[S])\n ax.relim()\n ax.autoscale()\n ax.set_ylabel('Alternate Allele Percentage (%s)'%(S))\n ax.set_xlabel('Alternate Allele Percentage (%s)'%(base))\n fig.canvas.draw_idle()\n if(data == 'Abs'):\n l.set_xdata(abs_alt[base])\n l.set_ydata(abs_alt[S])\n ax.relim()\n ax.autoscale()\n ax.set_ylabel('Alternate Allele Absolute (%s)'%(S))\n ax.set_xlabel('Alternate Allele Absolute (%s)'%(base))\n fig.canvas.draw_idle()\n \n global D\n D = data\n\n radio1.on_clicked(update1)\n radio2.on_clicked(update2)\n plt.show()","def createPrettyPlots(self, inputDir, outputDir, fnExtension = 'png'):\n number_of_entries_per_row = 4\n number_of_files_per_column = 2\n imageWidth = 200 # 1600 org is four times as large\n imageHeight = 150 # 1200\n nTmessage(\"Updating index files for input directory: %s\" % inputDir)\n if os.path.exists(outputDir):\n# nTmessage(\"Removing output directory: %s\" % outputDir)\n shutil.rmtree(outputDir)\n # end if\n# nTmessage(\"Creating output directory: %s\" % outputDir)\n os.mkdir(outputDir)\n# nTdebug(\"Doing copyCingHtmlJsAndCssToDirectory\")\n copyCingHtmlJsAndCssToDirectory(outputDir) \n# htmlDir = os.path.join(cingRoot, \"HTML\")\n fnMatchPattern = '*.' + fnExtension\n image_fn_list = glob(os.path.join(inputDir,fnMatchPattern)) \n inputDirBase = os.path.basename(inputDir)\n# nTdebug(\"Got relative part of inputDir: %s\" % inputDirBase) # e.g. plotTrend\n image_code_list = []\n for image_fn in image_fn_list:\n _root, image_code, _ext = nTpath(image_fn)\n image_code_list.append(image_code)\n # end for \n ## Get the number of files required for building an index\n number_of_images_all_present = len(image_code_list)\n number_of_images_per_file = number_of_entries_per_row * number_of_files_per_column\n ## Number of files with indexes in google style\n number_of_files = int(number_of_images_all_present / number_of_images_per_file)\n if number_of_images_all_present % number_of_images_per_file:\n number_of_files += 1\n # end if\n nTmessage(\"Creating %s pages for %s image codes\" % (number_of_files, number_of_images_all_present))\n# nTmessage(\"Generating %s index html files\" % (number_of_files))\n\n file_name = os.path.join (self.base_dir, \"data\", self.results_base, \"indexPplot.html\")\n file_content = open(file_name, 'r').read()\n old_string = r\"<!-- INSERT NEW TITLE HERE -->\"\n new_string = capitalizeFirst( inputDirBase )\n file_content = string.replace(file_content, old_string, new_string)\n old_string = r\"<!-- INSERT NEW FOOTER HERE -->\"\n file_content = string.replace(file_content, old_string, self.htmlFooter)\n old_string = r\"<!-- INSERT GOOGLE ANALYTICS TEMPLATE HERE -->\"\n file_content = string.replace(file_content, old_string, GOOGLE_ANALYTICS_TEMPLATE)\n old_string = r\"<!-- INSERT GOOGLE PLUS ONE TEMPLATE HERE -->\"\n file_content = string.replace(file_content, old_string, GOOGLE_PLUS_ONE_TEMPLATE)\n ## Count will track the number of entries done per index file\n images_done_per_file = 0\n ## Following variable will track all done sofar\n images_done_all = 0\n ## Tracking the number in the current row. Set for the rare case that there\n ## are no entries at all. Otherwise it will be initialize on first pass.\n num_in_row = 0\n ## Tracking the index file number\n file_id = 1\n ## Text per row in an index file to insert\n insert_text = ''\n ## Repeat for all entries plus a dummy pass for writing the last index file\n for image_code in image_code_list + [ None ]:\n ## Finish this index file\n ## The last index file will only be written once...\n if images_done_per_file == number_of_images_per_file or images_done_all == number_of_images_all_present:\n begin_image_count = number_of_images_per_file * (file_id - 1) + 1\n end_image_count = min(number_of_images_per_file * file_id,\n number_of_images_all_present)\n# nTdebug(\"begin_image_count, end_image_count, number_of_images_all_present: %5d %5d %5d\" % (\n# begin_image_count, end_image_count, number_of_images_all_present))\n # image_code is just the base name of the file name.\n new_string = \"Images: %s-%s of %s.\" % (\n begin_image_count,\n end_image_count,\n number_of_images_all_present\n )\n old_string = r\"<!-- INSERT NEW RESULT STRING HERE -->\" \n new_file_content = string.replace(file_content, old_string, new_string)\n # Always end the row by adding dummy columns\n if num_in_row != number_of_entries_per_row:\n insert_text += (number_of_entries_per_row - num_in_row) * 2 * r\"<td> </td>\" + r\"</tr>\"\n # end if\n ## Create the new index file from the example one by replacing a string\n ## with the new content.\n old_string = r\"<!-- INSERT NEW ROWS HERE -->\"\n new_file_content = string.replace(new_file_content, old_string, insert_text)\n\n first_string = '<a href=\"index_%s.html\">First < <</a>' % 1\n final_string = '<a href=\"index_%s.html\">Last > ></a>' % number_of_files\n prev_string = ''\n if file_id > 1:\n prev_string = '<a href=\"index_%s.html\">Previous <</a>' % ( file_id - 1)\n # end if\n next_string = ''\n if file_id < number_of_files:\n next_string = '<a href=\"index_%s.html\">> Next</a>' % ( file_id + 1)\n # end if\n first_link = max(1, file_id - number_of_files_per_column)\n last_link = min(number_of_files, file_id + number_of_files_per_column - 1)\n links_string = ''\n for link in range(first_link, last_link + 1):\n ## List link but don't include a link out for the current file_id\n if link == file_id:\n links_string += ' <B>%s</B>' % link\n else:\n links_string += ' <a href=\"index_%s.html\">%s</a>' % (\n link, link)\n # end if\n # end for\n old_string = r\"<!-- INSERT NEW LINKS HERE -->\"\n new_string = 'Result pages: ' + ' '.join([first_string, prev_string, links_string, next_string, final_string])\n new_file_content = string.replace(new_file_content, old_string, new_string)\n ## Make the first index file name still index.html\n new_file_name = os.path.join( outputDir, 'index_%s.html' % file_id)\n if not file_id:\n new_file_name = os.path.join( outputDir, '/index.html' )\n # end if \n writeTextToFile(new_file_name, new_file_content) \n images_done_per_file = 0\n num_in_row = 0\n insert_text = \"\"\n file_id += 1\n # end for\n ## Build on current index file\n ## The last iteration will not execute this block because of this clause\n if images_done_all < number_of_images_all_present:\n images_done_all += 1\n images_done_per_file += 1\n ## Get the html code right by abusing the formatting chars.\n ## as in sprintf etc.\n imageRelUrl = os.path.join( '..', inputDirBase, image_code + '.' + fnExtension)\n tmp_string = \"\"\"\n<td> <a href=\"%(imageRelUrl)s\"> <img SRC=\"%(imageRelUrl)s\" border=\"0\" width=\"%(imageWidth)s\" height=\"%(imageHeight)s\"> </a> </td>\"\"\" % dict(\n imageRelUrl=imageRelUrl, imageWidth=imageWidth, imageHeight=imageHeight)\n num_in_row = images_done_per_file % number_of_entries_per_row\n if num_in_row == 0:\n num_in_row = number_of_entries_per_row\n # end if\n if num_in_row == 1:\n # Start new row\n tmp_string = \"\\n<tr>\" + tmp_string\n elif (num_in_row == number_of_entries_per_row):\n # End this row\n tmp_string = tmp_string + \"\\n</tr>\"\n # end if\n insert_text += tmp_string\n # end if\n # end if\n index_file_first = 'index_1.html'\n index_file = os.path.join(outputDir, 'index.html')\n ## Assume that a link that is already present is valid and will do the job\n# nTdebug('Symlinking: %s %s' % (index_file_first, index_file))\n symlink(index_file_first, index_file)","def ex1_plots(instance, destination, prefix, save, animate):\n \n plts = ukf_plots(instance, destination, prefix, save, animate)\n\n truths = truth_parser(instance)\n nan_array= nan_array_parser(instance, truths, instance.base_model)\n #obs, obs_key = obs_parser(instance, True)\n obs_key = obs_key_parser(instance, True)\n preds = preds_parser(instance, True)\n #forecasts = forecasts_parser(instance, True)\n \n ukf_params = instance.ukf_params\n index2 = ukf_params[\"index2\"]\n \n \"remove agents not in model to avoid wierd plots\"\n #obs *= nan_array\n truths *= nan_array\n preds *= nan_array\n #forecasts*= nan_array\n \n \"indices for unobserved agents\"\n not_index2 = np.array([i for i in np.arange(truths.shape[1]) if i not in index2])\n plts.pair_frame(truths, preds, obs_key, 10, destination)\n plts.error_hist(truths[::instance.sample_rate,index2], \n preds[::instance.sample_rate,index2],\"Observed Errors\")\n if len(not_index2)>0:\n plts.error_hist(truths[::instance.sample_rate, not_index2], \n preds[::instance.sample_rate, not_index2],\"Unobserved Errors\")\n \n #plts.path_plots(obs[::instance.sample_rate] , \"Observed\")\n plts.path_plots(preds[::instance.sample_rate], \"Predicted\")\n plts.path_plots(truths, \"True\")\n #plts.path_plots(forecasts[::instance.sample_rate], \"Forecasts\")\n\n if animate:\n #plts.trajectories(truths, \"plots/\")\n plts.pair_frames(truths, preds, obs_key,\n truths.shape[0], \"../../plots/\")","def plot_files(n=15):\n lod = read_files(n)\n\n for i in range(len(lod)):\n plt.plot(range(len(lod[i])), lod[i])\n\n plt.show()","def plot_training_progress(model_output_path):\n try:\n results = load_results(model_output_path)\n except FileNotFoundError:\n print('monitor.csv file is not found!')\n\n results['l_moving_avg_100'] = results['l'].rolling(window=100).mean()\n results['r_moving_avg_100'] = results['r'].rolling(window=100).mean()\n results['t_per_M'] = results['t'] / 1000\n\n fig, axs = plt.subplots()\n results.plot(\n ax=axs,\n x='t_per_M', y='r_moving_avg_100',\n title='Training Progress',\n xlabel='Million Steps',\n ylabel='Mean Reward'\n )\n return results","def plot_Cmd_AngVel_EulerAng(data_fcs, data_vel, data_att, dest_folder=None):\n \n # Variables assignment\n t_fcs = data_fcs[:,0]\n delta_a = data_fcs[:,18]\n delta_e = data_fcs[:,6]\n delta_r = data_fcs[:,9]\n delta_t = data_fcs[:,20]\n \n t_vel = data_vel[:,0]\n p_rad = data_vel[:,4]\n q_rad = data_vel[:,5]\n r_rad = data_vel[:,6]\n \n t_att = data_att[:,0]\n phi_rad = data_att[:,1]\n the_rad = data_att[:,2]\n psi_rad = data_att[:,3]\n \n fig = plt.figure(figsize=(12.3,15))\n \n \n # Commands\n ax1a = fig.add_subplot(3,1,1)\n ax1a.plot(t_fcs, delta_a, ls='solid', color='r', label=r'$\\delta_a$')\n ax1a.plot(t_fcs, delta_e, ls='solid', color='g', label=r'$\\delta_e$')\n ax1a.plot(t_fcs, delta_r, ls='solid', color='b', label=r'$\\delta_r$')\n \n ax1a.set_title(\"Commands\") \n ax1a.set_xlabel(r'$t$ (s)')\n ax1a.set_ylabel(r'$\\delta_a$ , $\\delta_e$ , $\\delta_r$ (°)')\n ax1a.set_ylim(ymin=-1+np.floor(min(list(delta_a)+list(delta_e)+list(delta_r))),\n ymax=1+np.ceil(max(list(delta_a)+list(delta_e)+list(delta_r))))\n \n \n ax1b = ax1a.twinx()\n ax1b.plot(t_fcs, delta_t, ls='solid', color='0.65', label=r'$\\delta_t$')\n \n ax1b.set_ylabel(r'$\\delta_t$')\n ax1b.set_ylim(ymax=1, ymin=-0.05)\n \n handlesa, labelsa = ax1a.get_legend_handles_labels()\n handlesb, labelsb = ax1b.get_legend_handles_labels()\n ax1a.legend(handlesa+handlesb, labelsa+labelsb, ncol=4, loc='best')\n \n\n # Angular velocities\n ax2 = fig.add_subplot(3,1,2)\n \n ax2.plot(t_vel, (180/np.pi)*p_rad, color='r', label=r'$p$')\n ax2.plot(t_vel, (180/np.pi)*q_rad, color='g', label=r'$q$')\n ax2.plot(t_vel, (180/np.pi)*r_rad, color='b', label=r'$r$')\n \n ax2.set_title(\"Angular velocities\") \n ax2.set_xlabel(r'$t$ (s)')\n ax2.set_ylabel(r'$p$ , $q$ , $r$ (°/s)')\n \n handles, labels = ax2.get_legend_handles_labels()\n ax2.legend(handles, labels, ncol=3, loc='best')\n \n \n # Euler angles\n ax3a = fig.add_subplot(3,1,3)\n \n ax3a.plot(t_att, (180/np.pi)*phi_rad, color='r', label=r\"$\\phi$\")\n ax3a.plot(t_att, (180/np.pi)*the_rad, color='g', label=r\"$\\theta$\")\n \n ax3a.set_title(\"Euler angles\") \n ax3a.set_xlabel(r'$t$ (s)')\n ax3a.set_ylabel(r'$\\phi$ , $\\theta$ (°)')\n \n \n ax3b = ax3a.twinx()\n ax3b.plot(t_att, (180/np.pi)*psi_rad, color='b', label=r\"$\\psi$\")\n \n ax3b.set_ylabel(r'$\\psi$ (°)')\n \n handlesa, labelsa = ax3a.get_legend_handles_labels()\n handlesb, labelsb = ax3b.get_legend_handles_labels()\n ax3b.legend(handlesa+handlesb, labelsa+labelsb, ncol=3, loc='best')\n \n plt.tight_layout()\n \n \n # Export\n if dest_folder != None:\n plt.savefig(dest_folder+'plot_Cmd_AngVel_EulerAng.pdf')","def do_jet_pt_plots(tree, output_dir, cut=''):\n for logz, normx in product([True, False], [True, False]):\n make_2d_plot(tree, 'httL1', HTT_L1_STR, NB_HTT, HTT_MIN, HTT_MAX, 'pt', PT_L1_STR, NB_PT, PT_MIN, PT_MAX,\n os.path.join(output_dir, 'pt_httL1.pdf'), logz=logz, normx=normx,\n cut=cut, title=TITLE, diagonal_line=True)\n make_2d_plot(tree, 'httL1', HTT_L1_STR, NB_HTT, HTT_MIN, HTT_MAX, 'ptRef', PT_REF_STR, NB_PT, PT_MIN, PT_MAX,\n os.path.join(output_dir, 'ptRef_httL1.pdf'), logz=logz, normx=normx,\n cut=cut, title=TITLE, diagonal_line=True)\n make_2d_plot(tree, 'httRef', HTT_REF_STR, NB_HTT, HTT_MIN, HTT_MAX, 'pt', PT_L1_STR, NB_PT, PT_MIN, PT_MAX,\n os.path.join(output_dir, 'pt_httRef.pdf'), logz=logz, normx=normx,\n cut=cut, title=TITLE, diagonal_line=True)\n make_2d_plot(tree, 'httRef', HTT_REF_STR, NB_HTT, HTT_MIN, HTT_MAX, 'ptRef', PT_REF_STR, NB_PT, PT_MIN, PT_MAX,\n os.path.join(output_dir, 'ptRef_httRef.pdf'), logz=logz, normx=normx,\n cut=cut, title=TITLE, diagonal_line=True)","def plot_balance_list_output(balance_list, path, nframes=4):\n import matplotlib\n font = {'size' : 15, 'weight': 'normal'}\n matplotlib.rc('font', **font)\n\n nplots=len(balance_list)\n ncols=2\n nrows=int(np.ceil(nframes/ncols))\n _, axes = plt.subplots(nrows, ncols, figsize=(25, 5*nrows))\n for n in range(nframes):\n i = int(np.floor(n / ncols))\n j=n % ncols\n r_p = []\n for k in range(len(balance_list[n])-1):\n r_p.append(np.abs(balance_list[n][k]-balance_list[n][k+1])/balance_list[n][k])\n\n axes[i,j].plot(balance_list[n], label='balance', color='b')\n axes[i,j].set_title('Outer loop # '+ str(n))\n # axes[i,j].set_yscale('log')\n # axes[i,j].set_xscale('log')\n axes[i,j].grid(True)\n axes[i,j].set_ylabel('Balance norm')\n # axes[i,j].legend()\n axes[i,j].set_ylim([0, 10])\n # ax_2=axes[i,j].twinx()\n # ax_2.plot(r_p, 'g')\n # ax_2.set_yscale('log')\n # ax_2.set_ylabel('relative change')\n\n plt.savefig(path,transparent=True, dpi=400)","def plot_overview(cube=nro_12co,\n region_file='../shell_candidates/AllShells.reg', mode='peak', plotname='12co_peak_shells.png',\n interactive=False, show_shells=True, shells_highlight=None, dist=orion_dist, vmin=None, vmax=None,\n scalebar_color=\"white\", scalebar_pc = 1., scale_factor=1., pmin=0.25,\n pmax=99.75, cbar_label=r\"Peak T$_{\\rm MB}$ [K]\",\n circle_color='white', circle_linewidth=1, circle_style=\"solid\", return_fig=False, show=True,\n title=r\"$^{12}$CO Peak T$_{MB}$\", recenter=False, ra=None, dec=None, radius=None):\n try:\n cube = SpectralCube.read(cube)\n except ValueError:\n pass\n\n if mode == \"peak\":\n image = (cube.max(axis=0) * scale_factor).hdu\n \n\n if mode == \"mom0\":\n image = (cube.moment0() * scale_factor).hdu\n\n\n\n fig = FITSFigure(image)\n if show:\n fig.show_colorscale(cmap='viridis', vmin=vmin, vmax=vmax, pmin=pmin,\n pmax=pmax, interpolation='none')\n fig.tick_labels.set_yformat(\"dd:mm\")\n fig.tick_labels.set_xformat(\"hh:mm\")\n #fig.hide_yaxis_label()\n #fig.hide_ytick_labels()\n plt.title(title)\n plt.xlabel(\"RA (J2000)\")\n plt.ylabel(\"DEC (J2000)\")\n\n if show_shells:\n shell_list = get_shells(region_file=region_file)\n for i, shell in enumerate(shell_list):\n if shells_highlight:\n if i+1 in shells_highlight:\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle='solid', edgecolor=circle_color,\n facecolor='none', linewidth=3)\n else:\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle=circle_style, edgecolor=circle_color,\n facecolor='none', linewidth=circle_linewidth)\n else:\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle=circle_style, edgecolor=circle_color,\n facecolor='none', linewidth=circle_linewidth)\n\n #RECENTER\n if recenter:\n fig.recenter(ra, dec, radius)\n\n\n #SCALEBAR\n fig.add_scalebar(206265 * scalebar_pc / (dist.to(u.pc).value * 3600), color=scalebar_color)\n fig.scalebar.set_label(\"{} pc\".format(scalebar_pc))\n\n fig.add_colorbar()\n cb = fig.colorbar\n cb.set_axis_label_text(cbar_label)\n\n if return_fig:\n return fig\n else:\n fig.save(plotname, dpi=600)","def basic_stats_and_plots():\n \n basename = sys.argv[1]\n ops = (\"two_opt\", \"twoh_opt\", \"three_opt\", \"three_opt_broad\", \"swap\", \"swap_adj\")\n opfs = {\n \"two_opt\": tsp.two_opt,\n \"twoh_opt\": tsp.twoh_opt,\n \"three_opt\": tsp.three_opt,\n \"three_opt_broad\": tsp.three_opt_broad,\n \"swap\": tsp.swap_two,\n \"swap_adj\": tsp.swap_adj\n }\n \n lengths = range(6, 11)\n for length in lengths:\n stddev = []\n gini = []\n nneighbours = []\n prop_unique = []\n for op in ops:\n filename = os.path.join(basename,\n \"tsp_length_%d_%s\" % (length, op),\n \"TP_row0.dat\")\n print op, length\n x = np.genfromtxt(filename)\n # stats to get:\n stddev.append(np.std(x))\n gini.append(random_walks.gini_coeff(x))\n nneighbours.append(np.sum(x > 0))\n mu, sigma = rw_experiment_with_op(length, opfs[op])\n prop_unique.append((mu, sigma))\n\n gini_barchart(length, gini, ops)\n stddev_barchart(length, stddev, ops)\n plot_gini_v_nneighbours(length, gini, nneighbours, ops)\n plot_stddev_v_nneighbours(length, stddev, nneighbours, ops)\n plot_gini_v_prop_unique(length, gini, prop_unique, ops)\n plot_stddev_v_prop_unique(length, stddev, prop_unique, ops)"],"string":"[\n \"def plot_directory_profiles(path, outname=None, show=True, xscale=1, yscale=1,\\n xval='x', adjustRadial=True):\\n outdirs = np.sort(os.listdir(path))\\n plt.figure()\\n\\n #labels=['homogeneous','1D layering', '3D tomography'] #xscale=1e-3, yscale=1e2\\n for i,outdir in enumerate(outdirs):\\n pointsFile = os.path.join(path, outdir, 'points.h5')\\n #print(pointsFile)\\n #x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile, output='cyl',adjustRadial=adjustRadial)\\n #x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile)\\n #Load data\\n\\n x,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n #Y = uz / yscale\\n if xval == 'x':\\n X = x / xscale\\n Y1 = ux / yscale\\n elif xval == 'r':\\n X = np.hypot(x,y) / xscale\\n ur_fem = np.hypot(ux,uy)\\n Y1 = ur_fem / yscale\\n if adjustRadial: #fix sign from hypot square root\\n ur_fem = pu.radial2negative(Y1)\\n\\n x_fem = X #/ xscale #double scaling!\\n ur_fem = Y1 #/ yscale\\n uz_fem = uz / yscale\\n\\n #print(pointsFile)\\n print(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max())\\n\\n l, = plt.plot(x_fem,uz_fem,'.-',lw=3,label=outdir)\\n #l, = plt.plot(x_fem,uz_fem,'.-',lw=2,label=labels[i]) #for 3d heterogeneity example\\n plt.plot(x_fem,ur_fem,'.--',lw=3, mfc='w',color=l.get_color()) #mfc='none' transparent\\n\\n # Annotate\\n plt.axhline(color='k',lw=0.5)\\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\\n plt.legend()\\n\\n #NOTE: custom annotations for 3d heterogeneity\\n #plt.title('Elastic Heterogeneity Effects')\\n #plt.legend([l1,l2,l3],['homogeneous','1D layering', '3D tomography'])\\n\\n if outname: plt.savefig(outname)\\n if show: plt.show()\",\n \"def plot(profiler, outdir):\\n # go through the outputs of all morphisms\\n for cur_name, cur_output in profiler.profile.items():\\n cur_outdir = os.path.join(outdir, cur_name)\\n if not os.path.exists(cur_outdir):\\n os.makedirs(cur_outdir)\\n\\n ProfilePlotter.plot_morphism_output(cur_output, cur_outdir)\",\n \"def plot_morphism_output(data, outdir):\\n\\n # show the distributions for each variable separately\\n for col in data.columns:\\n ProfilePlotter._plot_1d(data[col], outfile = os.path.join(outdir, col + \\\".pdf\\\"))\\n\\n # later, maybe also show 2d plots etc.\",\n \"def plot_directory_numex(path, vals, param='density', outname=None, show=True,\\n xscale=1e-3,yscale=1e2):\\n #vals = arange(2300.0, 2800.0, 50.0)\\n outdirs = np.sort(os.listdir(path))\\n plt.figure()\\n\\n # Plot surface profiles for each parameter\\n for val,outdir in zip(vals,outdirs):\\n pointsFile = os.path.join(path, outdir, 'points.h5')\\n print(pointsFile)\\n x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile, output=True, adjustRadial=True)\\n x_fem = x_fem / xscale\\n ur_fem = ur_fem / yscale\\n uz_fem = uz_fem / yscale\\n l, = plt.plot(x_fem,uz_fem,'.-',label=str(val))\\n plt.plot(x_fem,ur_fem,'.-',color=l.get_color())\\n\\n # Annotate\\n plt.axhline(color='k') #zero displacement line\\n plt.title(param)\\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\\n plt.legend()\\n\\n if outname: plt.savefig(outname)\\n if show: plt.show()\",\n \"def plot_profile(outdir, xval='x', xscale=1, yscale=1, comp2los=False, adjustRadial=False,\\n fig=True):\\n #Load data\\n path = os.path.join(outdir,'points.h5')\\n x,y,z,ux,uy,uz = pu.extract_points(path)\\n\\n Y = uz / yscale\\n if xval == 'x':\\n X = x / xscale\\n Y1 = ux / yscale\\n elif xval == 'r':\\n X = np.hypot(x,y) / xscale\\n ur = np.hypot(ux,uy)\\n Y1 = ur / yscale\\n if adjustRadial: #fix sign from hypot square root\\n ur = pu.radial2negative(Y1)\\n\\n if fig:\\n plt.figure()\\n # otherwise profile added to active plot\\n\\n #plt.plot(X,uy/yscale,'r.-',label='Uy') #should be zero along EW axis\\n de = 90e3 / xscale #eastern data extent\\n if comp2los != False:\\n data_extents = (X<=de)\\n if comp2los == 'west': #switch sign of radial profile\\n #ux = -ux #move to comp2los function\\n X = -X\\n Y1 = -Y1\\n de = -de\\n data_extents = (X>=de)\\n\\n los = pu.comp2los(x,ux,uy,uz,track=comp2los)\\n plt.plot(X, los/yscale, 'k-', lw=2, label='Ulos_' + comp2los)\\n plt.fill_between(X,los/yscale, where=data_extents, color='gray',alpha=0.5)\\n\\n plt.plot(X, Y, 'b-', lw=2, label='Uz')\\n plt.plot(X, Y1, 'b--',lw=2, mfc='None',label='U{0}'.format(xval))\\n\\n # Annotate\\n plt.title(outdir)\\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n plt.ylabel('Uz [{}]'.format(get_unit(yscale)))\\n plt.axhline(color='k')\\n plt.axvline(de,color='k', linestyle='dashed', label='EW data extent') #EW extent of InSAR coverage\\n plt.legend(loc='best')\\n plt.grid(True)\\n plt.show()\",\n \"def plot_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2014/output',\\n\\t\\t\\t\\tsteps=['step01','step02'],\\n\\t\\t\\t\\t#labels='',\\n\\t\\t\\t\\tshow=True,\\n\\t\\t\\t\\txscale=1e3,\\n\\t\\t\\t\\tyscale=1e-2):\\n\\tplt.figure()\\n\\t#path = '/Users/scott/Desktop/elastic'\\n\\n\\t# Deep source\\n\\t#labels = ['no APMB', 'APMB']\\n\\t#if labels == '':\\n\\tlabels = steps\\n\\tdeep = {}\\n\\t#uzmax = 0.824873455364\\n\\t# NOT sure why hardcoded...\\n\\tuzmax = 1\\n\\tfor i,outdir in enumerate(steps):\\n\\t\\tpointsFile = os.path.join(path, outdir, 'points.h5')\\n\\t\\tprint(pointsFile)\\n\\t\\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n\\n\\t\\tX = x / xscale\\n\\t\\tY1 = ux / yscale\\n\\n\\t\\tx_fem = X #/ xscale #double scaling!\\n\\t\\tur_fem = Y1 #/ yscale\\n\\t\\tuz_fem = uz / yscale\\n\\n\\t\\t#print(pointsFile)\\n\\t\\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\\n\\n\\t\\t#normalize\\n\\t\\tuz_fem = uz_fem / uzmax\\n\\t\\tur_fem = ur_fem / uzmax\\n\\t\\tx_fem = x_fem / 30.0\\n\\n\\t\\tl, = plt.plot(x_fem,uz_fem,'o-',ms=4,lw=4,label=labels[i])\\n\\t\\tplt.plot(x_fem,ur_fem,'o--',ms=4,lw=4,color=l.get_color()) #mfc='none' transparent\\n\\t\\tdeep[outdir] = uz_fem/uz_fem\\n\\n\\t'''\\n\\t# Shallow Source\\n\\tshallow = {}\\n\\tuzmax = 0.949652827795\\n\\tfor i,outdir in enumerate(['step11','step12']):\\n\\t\\tpointsFile = os.path.join(path, outdir, 'points.h5')\\n\\n\\t\\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n\\n\\t\\tX = x / xscale\\n\\t\\tY1 = ux / yscale\\n\\n\\t\\tx_fem = X #/ xscale #double scaling!\\n\\t\\tur_fem = Y1 #/ yscale\\n\\t\\tuz_fem = uz / yscale\\n\\n\\t\\t#print(pointsFile)\\n\\t\\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\\n\\n\\t#normalize\\n\\tuz_fem = uz_fem / uzmax\\n\\tur_fem = ur_fem / uzmax\\n\\tx_fem = x_fem / 20.0\\n\\n\\t\\tl, = plt.plot(x_fem,uz_fem,'.-', mfc='w', lw=4,label=labels[i])\\n\\t\\tplt.plot(x_fem,ur_fem,'.--',lw=4, mfc='w',color=l.get_color()) #mfc='none' transparent\\n\\n\\t\\tshallow[outdir] = uz_fem/ur_fem\\n\\t'''\\n\\n\\t# Annotate\\n\\tplt.axhline(color='k',lw=0.5)\\n\\t#plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n\\t#plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\\n\\tplt.legend()\\n\\tplt.grid()\\n\\t#plt.ylim(-0.5, 3.5)\\n\\t#plt.savefig('deep.png',bbox_inches='tight')\\n\\t#plt.savefig('shallow.png',bbox_inches='tight')\\n\\n\\t# normalized\\n\\tplt.ylim(-0.5, 4)\\n\\tplt.xlim(0,10)\\n\\tplt.xlabel('Normalized Radial Distance [R / D]')\\n\\tplt.ylabel('Normalized Displacement [U / Uz_max]')\\n\\t#plt.savefig('normalized_deep.png',bbox_inches='tight')\\n\\tplt.savefig('normalized_shallow.png',bbox_inches='tight')\\n\\n\\n\\t# Plot ratios of uz versus NOTE: this plot is confusing,,, just keep ratio of uz_max to ur_max\\n\\t'''\\n\\tplt.figure()\\n\\tplt.plot(x_fem, deep['step01'], label='Deep no APMB')\\n\\tplt.plot(x_fem, deep['step02'], label='Deep w/ APMB')\\n\\tplt.plot(x_fem, shallow['step11'], label='Shallow no APMB')\\n\\tplt.plot(x_fem, shallow['step12'], label='Shallow w/ APMB')\\n\\tplt.xlabel('Distance [km]') #NOTE: maybe plot normailzed X-axis (R-d)\\n\\t#plt.xlabel('Normalized Distance [R/d]')\\n\\tplt.ylabel('Ratio [Uz/Ur]')\\n\\tplt.title('Ratio of vertical to radial displacement')\\n\\tplt.legend()\\n\\tplt.show()\\n\\t'''\",\n \"def plot_one_directory(args, dirnames, figname):\\n logdir = args.logdir\\n num = len(ATTRIBUTES)\\n fig, axes = subplots(num, figsize=(13,4*num))\\n\\n for (dd, cc) in zip(dirnames, COLORS):\\n A = np.genfromtxt(join(logdir, dd, 'log.txt'), \\n delimiter='\\\\t', \\n dtype=None, \\n names=True)\\n x = A['Iterations']\\n\\n for (i,attr) in enumerate(ATTRIBUTES):\\n axes[i].plot(x, A[attr], '-', lw=lw, color=cc, label=dd)\\n axes[i].set_ylabel(attr, fontsize=ysize)\\n axes[i].tick_params(axis='x', labelsize=tick_size)\\n axes[i].tick_params(axis='y', labelsize=tick_size)\\n axes[i].legend(loc='best', ncol=2, prop={'size':legend_size})\\n\\n axes[0].set_ylim([-10,10])\\n axes[1].set_ylim([-10,10])\\n axes[2].set_ylim([0,10])\\n axes[3].set_ylim([0,10])\\n\\n plt.tight_layout()\\n plt.savefig(figname)\",\n \"def create_plots(self):\\n if not os.path.exists(self.output_folder):\\n os.makedirs(self.output_folder)\\n self.sse_plot()\\n self.avg_sse_plot()\",\n \"def Plot(self):\\n\\n ### Create the path names ###\\n folder_string = self.params.folder+\\\"/plots/\\\"\\n u_string = self.params.folder+\\\"/plots/u.pdf\\\"\\n p_string = self.params.folder+\\\"/plots/p.pdf\\\"\\n\\n ### Check if folder exists ###\\n if not os.path.exists(folder_string): os.makedirs(folder_string)\\n\\n ### Plot the x component of velocity ###\\n plot(self.u_next[0],title=\\\"Velocity in the x Direction\\\")\\n plt.savefig(u_string)\\n plt.figure()\\n\\n ### Plot the pressure ###\\n plot(self.p_next,title=\\\"Pressure\\\")\\n plt.savefig(p_string)\\n plt.show()\",\n \"def run_plots(self):\\n # load the files\\n self.pre_dark_file = os.path.join(self.input_dir, 'step_lastframe.fits')\\n self.post_dark_file = os.path.join(self.input_dir, 'step_dark_current.fits')\\n self.jump_file = os.path.join(self.input_dir, 'step_jump.fits')\\n self.rate_file = os.path.join(self.input_dir, 'step_rate.fits')\\n self.ramp_file = glob.glob(os.path.join(self.input_dir, '*.fits'))[0]\\n\\n # plots\\n self.plot_jump_flags_image()\\n self.plot_groupdq_flags(pixel=[884, 550])\\n self.plot_ramps_pre_post_correction(pixel=[884, 550])\",\n \"def plot_it(self, ui=None, res_dir=None):\\r\\n print_it(\\\"plotting results\\\")\\r\\n plt_profile(self.sun, PltOpts.DD.value, res_dir, SubDir.profiles.value)\\r\\n plt_profile(self.sun, PltOpts.DDD.value, res_dir, SubDir.profiles.value)\\r\\n plt_profile(self.planet, PltOpts.DD.value, res_dir,\\r\\n SubDir.profiles.value)\\r\\n plt_profile(self.planet, PltOpts.DDD.value, res_dir,\\r\\n SubDir.profiles.value)\\r\\n plt_profile_approx(res_dir, SubDir.profiles.value)\\r\\n plt_contact(self.sun, self.planet, PltOpts.DD.value, res_dir,\\r\\n SubDir.contacts.value)\\r\\n plt_contact(self.sun, self.planet, PltOpts.DDD.value, res_dir,\\r\\n SubDir.contacts.value)\\r\\n\\r\\n plt_3d(self.sun.x_axis, self.sun.y_axis, self.sun.press,\\r\\n self.sun.x_label, self.sun.y_label, 'pressure in MPa',\\r\\n 'contact_pressure_sun', res_dir, SubDir.pressures.value,\\r\\n 'contact_pressure_sun')\\r\\n plt_2d_scatt_line(self.sun.x_axis, self.pv, self.sun.x_axis, self.pv,\\r\\n self.sun.x_label,\\r\\n 'pv_rel in {}'.format(Unit.pvrel.value), 'pv_rel',\\r\\n res_dir, SubDir.energy.value, 'pv_rel')\\r\\n plt_2d_scatt_line(self.sun.x_axis, self.sun.e_akin, self.sun.x_axis,\\r\\n self.sun.e_akin, self.sun.x_label,\\r\\n 'e_akin in {}'.format(Unit.eakin.value), 'e_akin',\\r\\n res_dir, SubDir.energy.value, 'sun.e_akin')\\r\\n plt_2d_scatt_line(self.planet.x_axis, self.planet.e_akin,\\r\\n self.planet.x_axis, self.planet.e_akin,\\r\\n self.planet.x_label,\\r\\n 'e_akin in {}'.format(Unit.eakin.value), 'e_akin',\\r\\n res_dir,\\r\\n SubDir.energy.value, 'planet.e_akin')\\r\\n plt_energy_ring_on_ring(self, res_dir, SubDir.energy.value,\\r\\n 'e-akin-vs-pv-rel')\",\n \"def main():\\n\\n\\timport numpy as np\\n\\timport matplotlib as mpl\\n\\n\\t# Parse arguments\\n\\targs = cli.parse_args()\\n\\n\\t# Check all files exist\\n\\tfor filepath in args.files:\\n\\t\\tif not os.path.isfile(filepath):\\n\\t\\t\\t_exit('file {} does not exist'.format(filepath))\\n\\n\\t# Use TK interactive backend as it should work on all installations\\n\\tmpl.use('tkagg')\\n\\n\\t# Turn on interactive plotting (pyplot import must come after call to use())\\n\\timport matplotlib.pyplot as plt\\n\\tplt.ion()\\n\\n\\t# Get torsion angle arrays for all input files\\n\\tarrays = []\\n\\tfor filepath in args.files:\\n\\t\\twith open(filepath) as fobj:\\n\\t\\t\\tchain = list(parse_pdb_chain(fobj))\\n\\t\\t\\tarrays.append(torsion_array(chain))\\n\\n\\tangles = np.concatenate(arrays, axis=0)\\n\\n\\t# Make the plot\\n\\tif args.plottype == 'hexbin':\\n\\t\\thb = ramachandran_hexbin(angles, log=args.log, degrees=not args.radians)\\n\\t\\tif args.cbar:\\n\\t\\t\\tplt.colorbar(hb)\\n\\n\\telif args.plottype == 'scatter':\\n\\t\\tramachandran_scatter(angles, degrees=not args.radians)\\n\\n\\telif args.plottype == 'kde':\\n\\t\\t_assert_seaborn_available('kde')\\n\\t\\tramachandran_kdeplot(angles, shade=True, degrees=not args.radians)\\n\\n\\telif args.plottype == 'joint':\\n\\t\\t_assert_seaborn_available('joint')\\n\\t\\tramachandran_jointplot(angles, kind='kde', degrees=not args.radians)\\n\\n\\telse:\\n\\t\\traise ValueError(args.plottype)\\n\\n\\t# Plot title\\n\\tif len(args.files) == 1:\\n\\t\\tfilename = os.path.basename(args.files[0])\\n\\telse:\\n\\t\\tfilename = '{} files'.format(len(args.files))\\n\\n\\tplt.gcf().suptitle('{} ({} residues)'.format(filename, angles.shape[0]))\\n\\n\\t# Show the plot, blocking until closed\\n\\tplt.show(block=True)\",\n \"def plot_potential_profile(rims_object):\\r\\n if not os.path.exists(rims_object.path_for_output):\\r\\n os.makedirs(rims_object.path_for_output)\\r\\n number_of_profiles = rims_object.potential_profile_mat.shape[0]\\r\\n x = [dx * pow(10, 4) for dx in rims_object.x_space_vec]\\r\\n fig, axs = plt.subplots(number_of_profiles)\\r\\n plt.suptitle('RIMS: Ratchet potential profiles', fontsize=14, fontweight='bold')\\r\\n\\r\\n for i_profile in range(number_of_profiles):\\r\\n y = [dy for dy in rims_object.potential_profile_mat[i_profile]]\\r\\n axs[i_profile].plot(x, y, color=YELLOW, label=\\\"V(x) potential profile\\\")\\r\\n axs[i_profile].tick_params(axis='y', labelcolor=YELLOW)\\r\\n ax2 = axs[i_profile].twinx()\\r\\n y = [dy * pow(10, -4) for dy in rims_object.electric_field_mat[i_profile]]\\r\\n ax2.plot(x, y, color=PURPLE, label=r\\\"E(x) electric field = -$\\\\nabla $V\\\")\\r\\n ax2.tick_params(axis='y', labelcolor=PURPLE)\\r\\n text_kwargs = dict(fontsize=10, color=YELLOW, fontweight='bold')\\r\\n fig.text(0.1, 0.91, 'V(x) potential profile [v]', text_kwargs)\\r\\n text_kwargs = dict(fontsize=10, color=PURPLE, fontweight='bold')\\r\\n fig.text(0.5, 0.91, r\\\"E(x) electric field = -$\\\\nabla $V [v/$\\\\mu $m]\\\", text_kwargs)\\r\\n axs[number_of_profiles-1].set_xlabel(r\\\"X [$\\\\mu $m]\\\")\\r\\n\\r\\n if number_of_profiles < 4:\\r\\n fig.tight_layout()\\r\\n plt.savefig(rims_object.path_for_output + 'Ratchet potential profiles.jpeg')\\r\\n plt.close()\\r\\n write_to_log(rims_object, \\\"potential profile plot saved\\\")\\r\\n return\",\n \"def generate_plots(path):\\n videos = glob(path + '/*.mkv')\\n print(path, len(videos), videos)\\n\\n if len(videos) == 0:\\n return\\n else:\\n videos = videos[0]\\n\\n metadata_list = glob(path + '/metadata.txt')\\n #print(path, len(metadata_list), metadata_list)\\n\\n if len(metadata_list) == 0:\\n return \\n\\n P = Preprocessor()\\n P.import_video(str(videos))\\n P.read_metadata(path)\\n P.preprocess()\\n Im = P.frames_processed\\n if len(Im) == 0:\\n print(len(Im))\\n return\\n\\n z_start = P.z_start\\n z_end = P.z_end\\n\\n mean, cov = analyze_image(Im)\\n\\n window_size = 10\\n mean_smoothed = smoothing.mean_moving_average(mean, window_size)\\n cov_smoothed = smoothing.cov_moving_average(cov, window_size)\\n\\n c = CubicFitRotated()\\n c.fit(mean=mean_smoothed, cov=cov_smoothed, z_start=z_start, z_end=z_end)\\n\\n try:\\n os.mkdir(path + '/analysis')\\n path += '/analysis'\\n except OSError:\\n pass\\n\\n\\n plots.plot_mean(mean, z_start, z_end).savefig(path + '/beam_center.png')\\n plots.plot_beta(cov, z_start, z_end).savefig(path + '/sigma_squared.png')\\n\\n export.export_mean(mean = mean, filename = path + '/center.csv', z_start = z_start, z_end = z_end)\\n export.export_cov(cov = cov, filename = path + '/cov.csv', z_start = z_start, z_end = z_end)\\n\\n plt.close('all')\",\n \"def plot(self):\\n\\t\\tplot_chain(self.database_path, self.temp_folder)\\n\\t\\tplot_density(self.database_path, self.temp_folder, self.cal_params)\",\n \"def plot_visualization(path_results, x_data, y_data, variant_mode, nb_classes, signal_test, args):\\n\\n\\t#path_tsne = path_results + \\\"/Visualization/train/\\\" + str(args.step) + \\\"_2d.csv\\\"\\n\\t#data_frame = pd.read_csv(path_tsne)\\n\\t\\n\\tpath_maping = path_results + \\\"/Maping/\\\" + str(args.subject).split(\\\".txt\\\")[0] + \\\"/\\\"\\n\\tfilename = path_maping + \\\"maping_\\\" + str(args.step) + \\\"_\\\" + str(args.subject).split(\\\".txt\\\")[0] + \\\"_stick\\\" + str(args.stick) + \\\".png\\\"\\n\\n\\tprint(\\\"path_save maping\\\", path_maping)\\n\\n\\tif not os.path.exists(path_maping):\\n\\t\\tos.makedirs(path_maping)\\n\\n\\t#print(\\\"path_tsne\\\", path_tsne)\\n\\n\\tlabel_maping = np.array([10])\\n\\n\\tx_data = np.concatenate((x_data,signal_test),axis=0)\\n\\ty_data = np.concatenate((y_data,label_maping),axis=0)\\n\\n\\tprint(\\\"x_data concatenate\\\",x_data.shape)\\n\\tprint(\\\"y_data concatenate\\\",y_data.shape)\\n\\n\\tdata_frame = tsne_2d(x_data, y_data)\\n\\n\\t\\n\\t\\n\\tgroups = data_frame.groupby('label')\\n\\n\\tcluster_names, cluster_colors = get_target_names_dr(nb_classes, args.mode, args, variant_mode)\\n\\n\\tfig = plt.figure(figsize=(20, 10))\\n\\tax = fig.add_subplot(111)\\n\\tax.margins(0.05) # Optional, just adds 5% padding to the autoscaling\\n\\tfor name, group in groups:\\n\\t\\t\\n\\t\\tif cluster_names[name] == str(args.subject):\\n\\t\\t\\tax.scatter(group.x, group.y, marker='D', s=150, edgecolors = 'face',label=cluster_names[name], color=cluster_colors[name])\\n\\t\\telse:\\n\\t\\t\\tax.scatter(group.x, group.y, marker='o', label=cluster_names[name], color=cluster_colors[name])\\n\\n\\tax.legend(numpoints=1) #show legend with only 1 point\\n\\tplt.savefig(filename) #save the plot\",\n \"def plot_dat_file(dat_paths: [str]):\\n import pandas as pd\\n import matplotlib.pyplot as plt\\n\\n fig, ax = plt.subplots(1, 3, sharey=\\\"all\\\", sharex=\\\"col\\\", figsize=(8, 6))\\n for i, dat_path in enumerate(dat_paths):\\n if i == i:\\n skipfoot = 11 + 9\\n else:\\n skipfoot = 11\\n dat_file = pd.read_csv(\\n dat_path,\\n skiprows=3,\\n skipfooter=skipfoot,\\n header=None,\\n delim_whitespace=True,\\n engine=\\\"python\\\",\\n )\\n depth = dat_file.values[:, 0]\\n vp = dat_file.values[:, 1]\\n vs = dat_file.values[:, 3]\\n dens = dat_file.values[:, 5]\\n\\n ax[0].plot(vp, depth, label=f\\\"nr {i}\\\")\\n\\n ax[1].plot(vs, depth)\\n ax[2].plot(dens, depth)\\n ax[0].set_ylim(ax[0].get_ylim()[::-1])\\n ax[0].legend()\\n plt.show()\",\n \"def plot_directory_surface_rmse(path, vals, param='Vp'):\\n\\n unw = '/home/scott/data/insar/cvz/t2282/geo/geo_stack282_8rlks.unw'\\n incidence = '/home/scott/data/insar/cvz/t2282/aux_files/geo_incidence_8rlks.unw'\\n dem = '/home/scott/data/dems/cgiar/uturuncu_1000_1000.tif'\\n #surface = '/home/scott/research/models/pylith/3d/uturuncu_layered/output/step01/surface.h5'\\n #geosurface = '/home/scott/research/models/pylith/scripts/geo_fem_Uz.tif'\\n\\n plt.figure()\\n outdirs = np.sort(os.listdir(path))\\n\\n # Calculate rmse\\n rmse = np.zeros_like(vals)\\n for i,outdir in enumerate(outdirs):\\n surface = os.path.join(path,outdir,'surface.h5')\\n los,fem_los,residual = pu.los2pylith(surface, dem, unw, incidence)\\n rmse[i] = rms_flat(residual[np.isfinite(residual)])\\n\\n plt.plot(vals,rmse,'b.-')\\n\\n # Annotate\\n #plt.title(param)\\n plt.xlabel('{} [km]'.format(param))\\n plt.ylabel('RMSE [cm]')\\n plt.legend()\\n plt.show()\",\n \"def plot_results(dir_path):\\n results, labels, dx = get_results_labels(dir_path)\\n\\n colors = plt.cm.get_cmap('tab10', len(labels)+1)\\n fig = plt.figure(figsize=(16, 9))\\n for i, (label, result) in enumerate(zip(labels, results)):\\n plt.plot(np.arange(result.shape[1]) * dx, np.mean(result, 0),\\n color=colors(i), linewidth=2, label=label)\\n plt.fill_between(np.arange(len(result[0])) * dx,\\n np.mean(result, 0) - np.std(result, 0),\\n np.mean(result, 0) + np.std(result, 0),\\n alpha=0.25, color=colors(i))\\n plt.title('Training Performance of Different Algorithms', fontsize=25)\\n plt.ylabel('Cumulative return', fontsize=20)\\n plt.xlabel('Steps', fontsize=20)\\n plt.xlim([0, results[0].shape[1] * dx])\\n plt.tick_params(labelsize=15)\\n plt.ticklabel_format(axis='both', style='sci', scilimits=(-2, 2))\\n plt.legend(fontsize=20)\\n plt.grid(linestyle=':')\\n plt.show()\\n\\n return fig\",\n \"def plot(cp_profile, *args, destination=\\\"browser\\\",\\n show_profiles=True, show_observations=True, show_residuals=False, show_rugs=False,\\n aggregate_profiles=None, selected_variables=None,\\n color=None, size=2, alpha=0.4,\\n color_pdps=None, size_pdps=None, alpha_pdps=None,\\n color_points=None, size_points=None, alpha_points=None,\\n color_residuals=None, size_residuals=None, alpha_residuals=None,\\n height=500, width=600,\\n plot_title='', yaxis_title='y',\\n print_observations=True,\\n **kwargs):\\n\\n params = dict()\\n params.update(kwargs)\\n params[\\\"variables\\\"] = _calculate_plot_variables(cp_profile, selected_variables)\\n params['color'] = \\\"_label_\\\" if args else color\\n params['show_profiles'] = show_profiles\\n params['show_observations'] = show_observations\\n params['show_rugs'] = show_rugs\\n params['show_residuals'] = show_residuals and (cp_profile.new_observation_true is not None)\\n params['add_table'] = print_observations\\n params['height'] = height\\n params['width'] = width\\n params['plot_title'] = plot_title\\n params['size_ices'] = size\\n params['alpha_ices'] = alpha\\n params = _params_update(params,\\n color_pdps=color_pdps, size_pdps=size_pdps, alpha_pdps=alpha_pdps,\\n size_points=size_points, alpha_points=alpha_points, color_points=color_points,\\n size_residuals=size_residuals, alpha_residuals=alpha_residuals,\\n color_residuals=color_residuals,\\n yaxis_title=yaxis_title)\\n\\n if aggregate_profiles in {'mean', 'median', None}:\\n params['aggregate_profiles'] = aggregate_profiles\\n else:\\n logging.warning(\\\"Incorrect function for profile aggregation: {}. Parameter ignored.\\\"\\n \\\"Available values are: 'mean' and 'median'\\\".format(aggregate_profiles))\\n params['aggregate_profiles'] = None\\n\\n all_profiles = [cp_profile] + list(args)\\n\\n plot_id = str(next(_PLOT_NUMBER))\\n plot_path, params_path, obs_path, profile_path = _get_data_paths(plot_id)\\n\\n with open(params_path, 'w') as f:\\n f.write(\\\"params = \\\" + json.dumps(params, indent=2) + \\\";\\\")\\n\\n save_observations(all_profiles, obs_path)\\n save_profiles(all_profiles, profile_path)\\n\\n with app.app_context():\\n data = render_template(\\\"plot_template.html\\\", i=plot_id, params=params)\\n\\n with open(plot_path, 'w') as f:\\n f.write(data)\\n\\n destination = _detect_plot_destination(destination)\\n if destination == \\\"notebook\\\":\\n from IPython.display import IFrame, display\\n display(IFrame(plot_path, width=int(width * 1.1), height=int(height * 1.1)))\\n else:\\n # open plot in a browser\\n if sys.platform == \\\"darwin\\\": # check if on OSX\\n plot_path = \\\"file://\\\" + os.path.abspath(plot_path)\\n webbrowser.open(plot_path)\",\n \"def combine_plot(qa_out_path,brain_path):\\n \\n #Get the scan volume of the brain.\\n brain_ref = nib.load(brain_path)\\n brain_ref_shape = brain_ref.shape[0:3]\\n \\n plots_list = ['Rotate_Z_axis_000000.png','Rotate_Z_axis_000001.png','Rotate_Z_axis_000002.png',\\n 'Rotate_Y_axis_000000.png','Rotate_Y_axis_000001.png','Rotate_Y_axis_000002.png',\\n 'Rotate_X_axis_000000.png','Rotate_X_axis_000001.png','Rotate_X_axis_000002.png']\\n y_labels = [\\\"Rotate with Z axis\\\",\\\"Rotate with Y axis\\\",\\\"Rotate with X axis\\\"]\\n x_labels = [\\\"angle=0\\\",\\\"angle=120\\\",\\\"angle=240\\\"]\\n \\n #Temporary list to store the image nparray:\\n im_arr=[] \\n \\n fig= plt.figure()\\n plt.title(f'QA_tractography. Scan volume = {brain_ref_shape} \\\\n\\\\n', fontsize=60,fontweight='bold')\\n plt.xticks([])\\n plt.yticks([])\\n plt.axis(\\\"off\\\")\\n\\n j = 0\\n for i in range(9):\\n #Load in the nine images into a nparray one by one.\\n im_arr = np.array(Image.open(qa_out_path + \\\"/\\\" + plots_list[i]))\\n #Change the background of the image into black:\\n im_arr = np.where(im_arr<=0.01, 255, im_arr) \\n ax = fig.add_subplot(3,3,i+1)\\n ax.imshow(im_arr,interpolation=\\\"none\\\",alpha=0.9)\\n \\n #Set the X labels and Y labels\\n if i<3:\\n ax.set_title(x_labels[i],fontsize=60,fontweight='bold')\\n if i % 3 == 0:\\n ax.set_ylabel(y_labels[j],fontsize=60,fontweight='bold')\\n j = j + 1\\n plt.xticks([])\\n plt.yticks([])\\n \\n fig.set_size_inches(40, 40, forward = True)\\n fig.savefig(qa_out_path + \\\"/\\\" + 'qa_tractography.png', format='png')\\n\\n #Delete the Nine images which used to generate the qa_tractography.png \\n for plot in plots_list:\\n if os.path.exists(qa_out_path + \\\"/\\\" + plot):\\n os.remove(qa_out_path + \\\"/\\\" + plot)\\n else:\\n print('No such file generated from streamlines window. Please check if the streamline.trk files is generated from the pipeline correctly or not')\",\n \"def matplotlib_plot(self, output_dir: Union[str, Path]):\\n keys2 = set.union(*[set(self.get_keys2(k)) for k in self.get_keys()])\\n for key2 in keys2:\\n keys = [k for k in self.get_keys() if key2 in self.get_keys2(k)]\\n plt = self._plot_stats(keys, key2)\\n p = Path(output_dir) / f\\\"{key2}.png\\\"\\n p.parent.mkdir(parents=True, exist_ok=True)\\n plt.savefig(p)\",\n \"def plot_parcles_run(k, v):\\n\\n L.info(f'Received Input: {v}')\\n\\n L.info(f\\\"Plotting results from: {v['filepath']}\\\")\\n\\n plotpath = Path(__file__).parent.parent / 'plots'\\n filename = v['id'] + '.png'\\n plotfile = str(plotpath / filename) \\n\\n plotTrajectoriesFile(v['filepath'], mode='2d', show_plt=False)\\n f = plt.gcf()\\n f.savefig(plotfile)\\n\\n L.info(f'Saved plot to: {plotfile}')\",\n \"def plot_all_LLRs(self, outdir):\\n\\t\\t#Iterate over all parameter groups\\n\\t\\tfor group in self.group_names:\\n\\t\\t\\tself.plot_group_LLR(groupname=group, outdir=outdir)\",\n \"def plot_track_rigidbody(params, datadir, pp=4, zoom=None):\\n h = params['h']\\n\\n # get dirs\\n xypath = sorted(glob.glob(datadir + 'xyv/'))[0]\\n # list files\\n xyfiles = sorted(glob.glob(xypath + '*.txt'))\\n\\n plt.clf()\\n ax1 = plt.subplot(5, 1, 1)\\n ax2 = plt.subplot(5, 1, 2)\\n ax3 = plt.subplot(5, 1, 3)\\n ax4 = plt.subplot(5, 1, 4)\\n ax5 = plt.subplot(5, 1, 5)\\n doall = range(0, len(xyfiles))\\n for i in doall:\\n iterind = (xyfiles[i].split('_')[-1]).split('.')[0]\\n t = float(iterind) * h\\n\\n x, y, theta, phi, psi = np.loadtxt(xyfiles[i], delimiter=',', usecols=(0, 1, 2, 3, 4), unpack=True)\\n # vX,vY,vtheta,vphi,vpsi = np.loadtxt(xyfiles[i],delimiter=',', usecols=(5,6,7,8,9), unpack=True)\\n\\n ax1.plot(t, x[pp], 'k.')\\n ax2.plot(t, y[pp], 'r.')\\n ax3.plot(t, theta[pp], 'r.')\\n ax4.plot(t, phi[pp], 'r.')\\n ax5.plot(t, psi[pp], 'g.')\\n\\n title = 'Tracking Single Gyro'\\n ax1.set_title(title)\\n ax5.set_xlabel('time')\\n ax1.set_ylabel('X')\\n ax2.set_ylabel('Y')\\n ax3.set_ylabel(r'$\\\\theta$')\\n ax4.set_ylabel(r'$\\\\phi$')\\n ax5.set_ylabel(r'$\\\\psi$')\\n\\n ax1.set_xlim([-h, t])\\n ax2.set_xlim([-h, t])\\n ax3.set_xlim([-h, t])\\n ax4.set_xlim([-h, t])\\n ax5.set_xlim([-h, t])\\n\\n ax1.set_xticks([])\\n ax2.set_xticks([])\\n ax3.set_xticks([])\\n ax4.set_xticks([])\\n\\n outname = datadir + 'Track.png'\\n plt.savefig(outname)\\n\\n if zoom != None:\\n ax1.set_xlim([-h, zoom])\\n ax2.set_xlim([-h, zoom])\\n ax3.set_xlim([-h, zoom])\\n ax4.set_xlim([-h, zoom])\\n ax5.set_xlim([-h, zoom])\\n\\n outname = datadir + 'Track_zoom.png'\\n plt.savefig(outname)\",\n \"def plot_pdf(pop_name, pop_val, pop_file, full_pop_file, outdir='.'):\\n try:\\n plt.style.use(\\n \\\"https://gist.githubusercontent.com/avivajpeyi/4d9839b1ceb7d3651cbb469bc6b0d69b/raw/4ee4a870126653d542572372ff3eee4e89abcab0/publication.mplstyle\\\")\\n except Exception:\\n pass\\n\\n plt.close('all')\\n all = pd.read_csv(full_pop_file, sep=\\\" \\\")\\n all['cos_theta_1'] = all['cos_tilt_1']\\n all = process_samples(all)\\n sub = pd.read_csv(pop_file, sep=\\\" \\\")\\n sub = process_samples(sub)\\n sub['cos_theta_1'] = sub['cos_tilt_1']\\n\\n fig, axes = plt.subplots(1, 2, figsize=(10, 5))\\n for ax, l in zip(axes, [\\\"cos_theta_1\\\", \\\"cos_theta_12\\\"]):\\n ax.hist(all[l], density=True, histtype='step', color=\\\"tab:blue\\\", label=\\\"ALL\\\", lw=2, alpha=0.8)\\n ax.scatter(all[l], [0 for _ in all[l]], color=\\\"tab:blue\\\",marker=\\\"+\\\")\\n ax.hist(sub[l], density=True, histtype='step', color=\\\"tab:purple\\\", label=\\\"HIGH SNR\\\", lw=2, alpha=0.6)\\n ax.scatter(sub[l], [0 for _ in sub[l]], color=\\\"tab:purple\\\", marker=\\\"+\\\")\\n\\n x = np.linspace(-1, 1, 100)\\n y1 = TruncatedNormal(mu=1, sigma=pop_val[0], minimum=-1, maximum=1).prob(x)\\n y2 = TruncatedNormal(mu=1, sigma=pop_val[1], minimum=-1, maximum=1).prob(x)\\n axes[1].plot(x, y2, color='tab:gray', zorder=-10, lw=3, label=\\\"TRUE\\\")\\n axes[0].plot(x, y1, color='tab:gray', zorder=-10, lw=3)\\n\\n for i in range(len(axes)):\\n if (i == 0):\\n axes[i].set_xlabel(r\\\"$\\\\cos\\\\ \\\\theta_1$\\\")\\n axes[i].set_ylabel(\\\"PDF\\\")\\n else:\\n axes[i].set_xlabel(r\\\"$\\\\cos\\\\ \\\\theta_{12}$\\\")\\n axes[i].set_yticklabels([])\\n axes[i].legend()\\n axes[i].grid(False)\\n axes[i].set_xlim(-1, 1)\\n\\n plt.suptitle(f\\\"POP {pop_name}\\\")\\n plt.tight_layout()\\n plt.savefig(f\\\"{outdir}/pop_trues_{pop_name}.png\\\")\",\n \"def plot_dir(main):\\n try:\\n wd = str(main.lineEdit_8.text())\\n if wd == '':\\n main.msg(\\\"Error \\\"+errorPath+\\\"plot_dir: Must choose directory first\\\")\\n return\\n for fi in os.listdir(wd):\\n dataPath = os.path.join(wd, fi)\\n main.msg(\\\"Plotting \\\"+str(fi))\\n img = mpimg.imread(str(dataPath))\\n imgObj = Img.Img(img, title=str(fi), filePath=str(dataPath))\\n main.imgObjList.append(imgObj)\\n func.update(main)\\n slider.slider_update(main)\\n except:\\n main.msg(\\\"Error \\\"+errorPath+\\\"plot_dir: Make sure all files are images (tiff, jpeg, etc.)\\\")\",\n \"def plot(path, subjects):\\n transformToXYZmm = np.array([[-3.125, 0, 0, 81.250], [0, 3.125, 0, -115.625], [0, 0, 6, -54.000], [0, 0, 0, 1.000]])\\n data = data_load.load_data(path, subjects)\\n dimx = int(data[0][\\\"meta\\\"][\\\"dimx\\\"][0])\\n dimy = int(data[0][\\\"meta\\\"][\\\"dimy\\\"][0])\\n dimz = int(data[0][\\\"meta\\\"][\\\"dimz\\\"][0])\\n coordToCol = data[0][\\\"meta\\\"][\\\"coordToCol\\\"][0][0]\\n images = {}\\n max_val = 0\\n voxels = np.load(\\\"data/general_selected_500_1.npy\\\")\\n directory = os.listdir(\\\"data/input/\\\")\\n bar = pyprind.ProgBar(len(directory), title='Info extraction and Image Building')\\n bar2 = pyprind.ProgBar(len(images.keys()), title='Saving Pictures')\\n for file in directory:\\n file_name = \\\"data/input/{}\\\".format(file)\\n fh = open(file_name)\\n activation_values = np.asarray(list(map(lambda x: float(x), filter(lambda x: x != '', fh.read().split(\\\",\\\")))))\\n fh.close()\\n plot_matrix = np.zeros((dimx, dimy, dimz))\\n for x in range(dimx):\\n for y in range(dimy):\\n for z in range(dimz):\\n indice = coordToCol[x][y][z]\\n if indice != 0:\\n if indice in list(voxels):\\n voxel_indice = list(voxels).index(indice)\\n value = activation_values[voxel_indice]\\n if abs(value) > max_val:\\n max_val = abs(value)\\n plot_matrix[x][y][z] = value\\n image = nib.Nifti1Image(plot_matrix, transformToXYZmm)\\n images[file_name] = image\\n bar.update(force_flush=True)\\n print(bar)\\n for image in images:\\n plotting.plot_glass_brain(images[image], display_mode='ortho', vmax=max_val, plot_abs=False, threshold=None, colorbar=True, output_file=\\\"{}-wom1.png\\\".format(image))\\n bar2.update(force_flush=True)\\n print(bar2)\",\n \"def plot_folder(folder, title, stochastic=True):\\n results = open_folder(folder, stochastic=stochastic)\\n assert len(results) > 0, 'Cannot find any results'\\n ce_values = np.concatenate(\\n [np.expand_dims(r.item()['train_xent'][:-1], 1) for r in results],\\n axis=1)\\n steps = np.concatenate(\\n [np.expand_dims(r.item()['step'][:-1], 1) for r in results], axis=1)\\n alpha_eff_values = np.concatenate(\\n [\\n np.expand_dims(r.item()['lr'] / (1.0 - r.item()['momentum']), 1)\\n for r in results\\n ],\\n axis=1)\\n condition = ['Manual', 'SMD']\\n plot_report_figure_combined(\\n steps,\\n ce_values,\\n alpha_eff_values,\\n condition,\\n title,\\n 'Loss',\\n 'Eff. Learning Rate',\\n os.path.join(\\n folder, 'combined_{}.pdf'.format('stoc' if stochastic else 'det')),\\n include_legend=True)\",\n \"def plot_PDs(output_path,M_max,max_dim,normalized=False,output_name=None):\\n plots_folder = os.path.join(output_path,'plots')\\n if output_name is None: \\n aux = ['PDs']\\n input_file = os.path.join(output_path,'outputs_PDS.csv')\\n else:\\n aux = [output_name,'PDs']\\n input_file = os.path.join(output_path,'%s_PDS.csv' % output_name)\\n if normalized is True:\\n aux.append('normalized')\\n plot_file_name = '-'.join(aux)+'.png'\\n plot_file_name = os.path.join(plots_folder,plot_file_name)\\n\\n \\n data = pd.read_csv(input_file,index_col = 0)\\n \\n\\n fig_size_aux = 15/(3-max_dim)\\n plt.figure(figsize=(fig_size_aux,5))\\n if(normalized):\\n for i in range(1,max_dim+2):\\n plt.subplot(1,max_dim+1,i, aspect='equal')\\n plt.plot(data[data.dimH==i-1].birth.values/np.float(M_max),data[data.dimH==i-1].death.values/np.float(M_max),'bo',alpha=.3,label='dim %i'%(i-1))\\n plt.xlim((0,1)); plt.ylim((0,1))\\n frame = plt.legend(loc=4,frameon=True,title='normalized')\\n frame = frame.get_frame()\\n frame.set_edgecolor('black')\\n plt.xlabel('birth'); plt.ylabel('death')\\n plt.plot([0, 1], [0, 1], ls=\\\"--\\\", c=\\\".3\\\")\\n plt.suptitle('Persistence Diagrams')\\n plt.savefig(plot_file_name)\\n print 'Saved PDs plots in %s'%plot_file_name\\n else:\\n for i in range(1,max_dim+2):\\n plt.subplot(1,max_dim+1,i, aspect='equal')\\n plt.plot(data[data.dimH==i-1].birth.values,data[data.dimH==i-1].death.values,'bo',alpha=.3,label='dim %i'%(i-1))\\n plt.xlim((0,M_max)); plt.ylim((0,M_max))\\n frame = plt.legend(loc=4,frameon=True)\\n frame = frame.get_frame()\\n frame.set_edgecolor('black')\\n plt.xlabel('birth'); plt.ylabel('death')\\n plt.plot([0, M_max], [0, M_max], ls=\\\"--\\\", c=\\\".3\\\")\\n plt.suptitle('Persistence Diagrams')\\n plt.savefig(plot_file_name)\\n print 'Saved PDs plots in %s'%plot_file_name\\n return()\",\n \"def plot_results(param_names, param_options, results, params):\\n\\n\\t# circuit/run_num where run_num is one before the existing one\\n\\tdirectory = params.circuit\\n\\tif not os.path.isdir(directory):\\n\\t\\tos.mkdir(directory)\\n\\truns = immediate_subdir(directory)\\n\\tlatest_run = 0\\n\\tif runs:\\n\\t\\tnatural_sort(runs)\\n\\t\\tlatest_run = get_trailing_num(runs[-1])\\n\\tdirectory = os.path.join(directory, \\\"run\\\" + str(latest_run+1))\\n\\n\\tprint(directory)\\n\\tif not os.path.isdir(directory):\\n\\t\\tos.mkdir(directory)\\n\\n\\twith Chdir(directory):\\n\\n\\t\\texport_results_to_csv(param_names, results, params)\\n\\n\\t\\tx = results.keys()\\n\\t\\ty = []\\n\\t\\tnext_figure = True\\n\\n\\t\\tp = 0\\n\\t\\tplt.figure()\\n\\t\\twhile p < len(param_names):\\n\\t\\t\\tprint(param_names[p])\\n\\n\\t\\t\\tif param_options[p]:\\n\\t\\t\\t\\tnf = True\\n\\t\\t\\t\\tfor option in param_options[p].split():\\n\\t\\t\\t\\t\\t# stopping has veto power (must all be True to pass)\\n\\t\\t\\t\\t\\tnf = nf and plot_options(option)\\n\\t\\t\\t\\tnext_figure = nf\\n\\n\\t\\t\\tif not next_figure:\\n\\t\\t\\t\\t# y becomes list of lists (for use with stackable plots)\\n\\t\\t\\t\\ty.append([result[p] for result in results.values()])\\n\\t\\t\\t\\tp += 1\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\telif not y:\\n\\t\\t\\t\\ty = [result[p] for result in results.values()]\\n\\n\\t\\t\\tlx = x[-1]\\n\\t\\t\\tly = y[-1]\\n\\t\\t\\tplot_method(x,y)\\n\\t\\t\\tplt.xlabel('iteration')\\n\\t\\t\\tplt.xlim(xmin=0)\\n\\t\\t\\t\\n\\t\\t\\tplt.ylabel(param_names[p])\\n\\n\\t\\t\\t# annotate the last value\\n\\t\\t\\tannotate_last(lx,ly)\\n\\n\\t\\t\\tif next_figure:\\n\\t\\t\\t\\tplt.savefig(param_names[p])\\n\\t\\t\\t\\tplt.figure()\\n\\n\\t\\t\\tp += 1\\n\\t\\t# in case the last figure hasn't been shuffled onto file yet\\n\\t\\tif not next_figure:\\n\\t\\t\\tplot_method(x,y)\\n\\t\\t\\tplt.savefig(param_names[-1])\",\n \"def generateTrajectoryPlots(dir_path, traj_list, plot_name='scecliptic', plot_vg=True, plot_sol=True, \\\\\\n plot_density=True, plot_showers=False):\\n\\n\\n\\n ### Plot Sun-centered geocentric ecliptic plots ###\\n\\n lambda_list = []\\n beta_list = []\\n vg_list = []\\n sol_list = []\\n\\n shower_no_list = []\\n shower_obj_dict = {}\\n\\n hypo_count = 0\\n jd_min = np.inf\\n jd_max = 0\\n for traj in traj_list:\\n\\n # Reject all hyperbolic orbits\\n if traj.orbit.e > 1:\\n hypo_count += 1\\n continue\\n\\n # Compute Sun-centered longitude\\n lambda_list.append(traj.orbit.L_g - traj.orbit.la_sun)\\n\\n beta_list.append(traj.orbit.B_g)\\n vg_list.append(traj.orbit.v_g/1000)\\n sol_list.append(np.degrees(traj.orbit.la_sun))\\n\\n # Track first and last observation\\n jd_min = min(jd_min, traj.jdt_ref)\\n jd_max = max(jd_max, traj.jdt_ref)\\n\\n\\n\\n if plot_showers:\\n\\n # Perform shower association and track the list of all showers\\n shower_obj = associateShowerTraj(traj)\\n\\n # If the trajectory was associated, sort it to the appropriate shower\\n if shower_obj is not None:\\n if shower_obj.IAU_no not in shower_no_list:\\n shower_no_list.append(shower_obj.IAU_no)\\n shower_obj_dict[shower_obj.IAU_no] = [shower_obj]\\n else:\\n shower_obj_dict[shower_obj.IAU_no].append(shower_obj)\\n\\n\\n\\n # Compute mean shower radiant for all associated showers\\n shower_obj_list = []\\n if plot_showers and shower_obj_dict:\\n for shower_no in shower_obj_dict:\\n\\n # Check if there are enough shower members for plotting\\n if len(shower_obj_dict[shower_no]) < MIN_SHOWER_MEMBERS:\\n continue\\n\\n la_sun_mean = meanAngle([sh.la_sun for sh in shower_obj_dict[shower_no]])\\n L_g_mean = meanAngle([sh.L_g for sh in shower_obj_dict[shower_no]])\\n B_g_mean = np.mean([sh.B_g for sh in shower_obj_dict[shower_no]])\\n v_g_mean = np.mean([sh.v_g for sh in shower_obj_dict[shower_no]])\\n\\n # Init a new shower object\\n shower_obj_mean = MeteorShower(la_sun_mean, L_g_mean, B_g_mean, v_g_mean, shower_no)\\n\\n shower_obj_list.append(shower_obj_mean)\\n\\n\\n\\n print(\\\"Hyperbolic percentage: {:.2f}%\\\".format(100*hypo_count/len(traj_list)))\\n\\n # Compute the range of solar longitudes\\n sol_min = np.degrees(jd2SolLonSteyaert(jd_min))\\n sol_max = np.degrees(jd2SolLonSteyaert(jd_max))\\n\\n\\n\\n # Plot SCE vs Vg\\n if plot_vg:\\n plotSCE(lambda_list, beta_list, vg_list, (sol_min, sol_max), \\n \\\"Sun-centered geocentric ecliptic coordinates\\\", \\\"$V_g$ (km/s)\\\", dir_path, plot_name + \\\"_vg.png\\\", \\\\\\n shower_obj_list=shower_obj_list, plot_showers=plot_showers)\\n\\n\\n # Plot SCE vs Sol\\n if plot_sol:\\n plotSCE(lambda_list, beta_list, sol_list, (sol_min, sol_max), \\\\\\n \\\"Sun-centered geocentric ecliptic coordinates\\\", \\\"Solar longitude (deg)\\\", dir_path, \\\\\\n plot_name + \\\"_sol.png\\\", shower_obj_list=shower_obj_list, plot_showers=plot_showers)\\n \\n\\n \\n # Plot SCE orbit density\\n if plot_density:\\n plotSCE(lambda_list, beta_list, None, (sol_min, sol_max), \\n \\\"Sun-centered geocentric ecliptic coordinates\\\", \\\"Count\\\", dir_path, plot_name + \\\"_density.png\\\", \\\\\\n density_plot=True, shower_obj_list=shower_obj_list, plot_showers=plot_showers)\",\n \"def plot_directory_surface(path,figsize=(17,11), comp=2, nrow=1, norm=None,\\n cbar='each', cloc='top', outname=None, labels='1', show=True):\\n outdirs = np.sort(os.listdir(path))\\n nplots = len(outdirs)\\n ncol = np.ceil(nplots/nrow).astype(np.int)\\n fig = plt.figure(figsize=figsize)\\n\\n grid = ImageGrid(fig, 111, # similar to subplot(111)\\n nrows_ncols = (nrow, ncol),\\n direction=\\\"row\\\",\\n axes_pad = 0.25,\\n add_all=True,\\n label_mode = labels, #'all', 'L', '1'\\n share_all = True,\\n cbar_location=cloc, #top,right\\n cbar_mode=cbar, #each,single,None\\n cbar_size=0.1,#\\\"7%\\\",\\n cbar_pad=0.0#,\\\"1%\\\",\\n )\\n\\n #NOTE: if cbar='single',cloc='right', a way to automatically normalize by grid[0]\\n #if normalize:\\n # verts,data,tris = load_h5(os.path.join(path,'step01/surface.h5'))\\n # if comp==3: #radial displacements\\n # z = np.hypot(data[:,:,0], data[:,:,1]).flatten()\\n # else:\\n # z = data[:,:,comp].flatten()\\n # norm = Normalize(vmin=np.nanmin(z), vmax=np.nanmax(z))\\n #else:\\n # norm=None\\n\\n for i,outdir in enumerate(outdirs):\\n ax = grid[i]\\n print(outdir)\\n im = plotSurface(os.path.join(path,outdir,'surface.h5'), comp=comp, ax=ax,\\n points=False, tris=False, profile=False, annotate=False, norm=norm,\\n xscale=1e-3, yscale=1e-3)\\n\\n # colorbar settings, not sure what's up with set_xticks...\\n ax.cax.colorbar(im)\\n #cmin = np.nanmin(data)\\n #cmax = np.nanmax(data)\\n #ax.cax.set_xticks([cmin,0,cmax])\\n\\n # label upper left\\n ax.text(0.05,0.95,outdir,\\n weight='bold',\\n ha='left',\\n va='top',\\n bbox=dict(facecolor='white'),\\n transform=ax.transAxes)\\n #ax.set_ylabel(outdir)\\n #ax.tick_params(labelbottom=0,labeltop=0,labelleft=0,labelright=0,\\n # bottom=0,top=0,left=0,right=0)\\n\\n #if cbar=='single':\\n # grid[0].cax.colorbar(im)\\n\\n # Annotate Plot\\n # don't show grid frames without data...\\n Nextra = grid.ngrids - nplots\\n if Nextra > 0:\\n for ax in grid[-Nextra:]:\\n #print(ax)\\n ax.set_visible(False)\\n ax.cax.set_visible(False)\\n fig.suptitle(path, fontsize=14, fontweight='bold')\\n if outname: plt.savefig(outname)\\n if show: plt.show()\",\n \"def plot_pipeline(differences_dir, plots_dir_intonation, num_quantiles = 31):\\n perf_list = ['54363310_1939750539', '540791114_1793842568']\\n difference_path_list = [os.path.join(differences_dir, perf_list[i] + \\\".npy\\\") for i in range(len(perf_list))]\\n comparisons_list = [np.load(path) for _, path in enumerate(difference_path_list)]\\n num_samples = 10000\\n # quantile indices\\n q_indices = (np.linspace(0, 1, num_quantiles)*(num_samples-1)).astype(np.int32)\\n plt.style.use('ggplot')\\n labels = ['perf. A', 'perf. B']\\n colors = ['blue', 'red']\\n linestyles = ['dotted', 'dashed']\\n grid = plt.GridSpec(2, 2)\\n ax1 = plt.subplot(grid[1, 0])\\n ax2 = plt.subplot(grid[1, 1])\\n ax4 = plt.subplot(grid[0, :])\\n ax4.plot(comparisons_list[0], color=colors[0], label=labels[0], linestyle=linestyles[0])\\n ax4.plot(comparisons_list[1], color=colors[1], label=labels[1], linestyle=linestyles[1])\\n ax4.set_title(\\\"Difference between MIDI and pYIN, two performances\\\")\\n ax4.set_ylabel(\\\"Cents\\\")\\n ax4.set_xlabel(\\\"Frames\\\")\\n ax4.axhline(y=200, linestyle=\\\"solid\\\", linewidth=0.7, c=\\\"black\\\", zorder=2, label=\\\"thresh.\\\")\\n ax4.axhline(y=-200, linestyle=\\\"solid\\\", linewidth=0.7, c=\\\"black\\\", zorder=2)\\n ax4.legend(loc=\\\"upper right\\\")\\n ax1.set_title(\\\"10k random sample of distances\\\")\\n ax1.set_ylabel(r\\\"$|$Cents$|$\\\")\\n ax1.set_xlabel(\\\"Frames sorted by distance\\\")\\n ax2.set_title(\\\"Sample quantiles\\\")\\n ax2.set_xlabel(\\\"Quantile indices\\\")\\n # run analysis song by song\\n for i, arr in enumerate(comparisons_list):\\n # random sample so all arrays have the same size\\n samples = np.random.choice(arr, num_samples, replace=True)\\n # sort\\n samples = np.sort(np.abs(samples))\\n # discard the high values (might be due to misalignment, etc...)\\n samples = samples[samples <= 200]\\n samples = np.random.choice(samples, num_samples, replace=True)\\n samples = np.sort(np.abs(samples))\\n ax1.plot(samples, color=colors[i], linestyle=linestyles[i], label=labels[i])\\n # get the quantiles\\n samples = samples[q_indices]\\n ax2.plot(samples, color=colors[i], linestyle=linestyles[i], label=labels[i])\\n ax1.legend()\\n ax2.legend()\\n plt.tight_layout()\\n plt.savefig(os.path.join(plots_dir_intonation, \\\"data processing pipeline.eps\\\"), format=\\\"eps\\\")\\n plt.show()\",\n \"def plot(model, results, filename):\\n\\n # c = model.compartments.get_one(id='c')\\n #\\n # rna_1 = model.species_types.get_one(id='rna_1').species.get_one(compartment=c)\\n # rna_2 = model.species_types.get_one(id='rna_2').species.get_one(compartment=c)\\n # rna_3 = model.species_types.get_one(id='rna_3').species.get_one(compartment=c)\\n #\\n pops = results.get('populations')\\n time = pops.index\\n pop_rna_1 = pops['rna_1[c]']\\n pop_rna_2 = pops['rna_2[c]']\\n pop_rna_3 = pops['rna_3[c]']\\n\\n pop_atp = pops['atp[c]']\\n pop_gtp = pops['gtp[c]']\\n pop_utp = pops['ctp[c]']\\n pop_ctp = pops['utp[c]']\\n\\n pop_amp = pops['amp[c]']\\n pop_gmp = pops['gmp[c]']\\n pop_ump = pops['cmp[c]']\\n pop_cmp = pops['ump[c]']\\n\\n print(pop_rna_1, pop_atp, pop_gtp, pop_utp, pop_ctp)\\n\\n fig1, axes1 = pyplot.subplots(nrows=3, ncols=1)\\n\\n axes1[0].plot(time / 3600, pop_rna_1)\\n axes1[0].plot(time / 3600, pop_rna_2)\\n axes1[0].plot(time / 3600, pop_rna_3)\\n axes1[0].set_xlim((time[0] / 3600, time[-1] / 3600))\\n axes1[0].set_ylim((0., 10.0))\\n axes1[0].legend(loc='upper right')\\n\\n axes1[1].plot(time / 3600, pop_atp)\\n axes1[1].plot(time / 3600, pop_gtp)\\n axes1[1].plot(time / 3600, pop_utp)\\n axes1[1].plot(time / 3600, pop_ctp)\\n axes1[1].set_xlim((time[0] / 3600, time[-1] / 3600))\\n # axes1[1].set_ylim((0., 10.0))\\n axes1[1].legend(loc='upper right')\\n\\n axes1[2].plot(time / 3600, pop_amp)\\n axes1[2].plot(time / 3600, pop_gmp)\\n axes1[2].plot(time / 3600, pop_ump)\\n axes1[2].plot(time / 3600, pop_cmp)\\n axes1[2].set_xlim((time[0] / 3600, time[-1] / 3600))\\n # axes1[2].set_ylim((0., 10.0))\\n axes1[2].legend(loc='upper right')\\n\\n fig1.savefig(filename.format('species'))\\n pyplot.close(fig1)\",\n \"def app_SN_combined_moisture_series(self, dfs, phase_dirs, sizer_val, styler_val):\\n\\n print('Currently plotting plot_SN_combined_moisture_series')\\n\\n for df, direc in zip(dfs, phase_dirs):\\n # this iterates one or multiple times\\n self.plotter.plot_SN_combined_moisture_series(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['01_combined_plots'],\\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\\n styler=self.formatter.styler[styler_val]\\n )\\n self.plotter.plot_SN_combined_moisture_series(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['01_combined_plots'],\\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\\n styler=self.formatter.styler[styler_val],\\n xaxis_type='datetime'\\n )\\n\\n print('Done\\\\n')\",\n \"def plot_visco_profiles(pointsh5, skip=slice(None,None,1), xscale=1e3, yscale=1e-2, tscale=3.1536e7, adjustRadial=False, benchmark=[], title=None):\\n\\tplt.figure()\\n\\n\\tcoords,data,number,times = pu.load_h5_visco(pointsh5)\\n\\n\\t#x = 1e3*np.loadtxt(points,usecols=[0]) # output_points2.txt\\n\\t#y = np.zeros_like(x)\\n\\tx = coords[:,0]\\n\\ty = np.zeros_like(x)\\n\\n\\t# NOTE: plot elastic solution by passing dictionary as showelastic\\n\\t# Plot analytic elastic solution (t=0)\\n\\t#print(benchmark)\\n\\tif len(benchmark)>=1:\\n\\t\\tur = zeros_like(x)\\n\\t\\tuz = np.zeros_like(x)\\n\\t\\tfor b in benchmark:\\n\\t\\t\\turi,uzi = m.calc_mogi_dp(x,y,**params)\\n\\t\\t\\tur += uri\\n\\t\\t\\tuz += uzi\\n\\t\\tplt.plot(x*xscale,uz*yscale,'ko',label='benchmark')\\n\\n\\t# Convert units\\n\\t#ur = np.hypot(data[:,:,0], data[:,:,1]) #assume progiles are along EW profile\\n\\tur = data[:,:,0]\\n\\tuz = data[:,:,2]\\n\\tx = x / xscale\\n\\tur = ur / yscale #cm\\n\\tuz = uz / yscale #cm\\n\\ttimes = times / tscale\\n\\t#times = times / 8.64e4 #days\\n\\t#times = times / 31536000 #years\\n\\n\\t#plots = np.arange(0,times.size,skip)\\n\\t#print(plots.size)\\n\\t#way to cycle through markers if plotting many lines\\n\\t#marker = itertools.cycle(['o','^','s','D']) #plot(marker=marker.next() iterates list)\\n\\t#way to use gradually changing colors from a colormap\\n\\t#color = plt.cm.jet(1.0*i/plots.size)\\n\\tindplots = np.arange(times.size-1)\\n\\tprint(indplots)\\n\\tindplots = indplots[skip]\\n\\tprint(indplots)\\n\\tfor i in indplots:\\n\\t\\tline, = plt.plot(x, uz[i], color=plt.cm.jet(1.0*i/indplots[-1]), label='{:.1f}'.format(times[i]))\\n\\t\\tplt.plot(x, ur[i], ls='dashed', color=line.get_color())\\n\\t#print uz[i]\\n\\t#print uz[i-1]\\n\\n\\tif title:\\n\\t\\tplt.title(title)\\n\\telse:\\n\\t\\tplt.title(pointsh5)\\n\\n\\tplt.axhline(color='k',linestyle='dashed')\\n\\tplt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n\\tplt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\\n\\tplt.show()\\n\\tplt.legend(title='{}'.format(get_unit(tscale)))\\n\\tplt.grid()\",\n \"def multi_plot(self, plottitle, gof_fileroot, indir, outdir,\\n legends, num_stations):\\n # Pick components and labels\\n xtick_loc = XTICK_LOC_0_01\\n xtick_label = XTICK_LABEL_0_01\\n\\n # Initialize data arrays\\n periods = [[] for _ in range(len(gof_fileroot))]\\n bias = [[] for _ in range(len(gof_fileroot))]\\n m90 = [[] for _ in range(len(gof_fileroot))]\\n p90 = [[] for _ in range(len(gof_fileroot))]\\n sigma = [[] for _ in range(len(gof_fileroot))]\\n sigma0 = [[] for _ in range(len(gof_fileroot))]\\n\\n bias_l = [[] for _ in range(len(gof_fileroot))]\\n bias_h = [[] for _ in range(len(gof_fileroot))]\\n conf_l = [[] for _ in range(len(gof_fileroot))]\\n conf_h = [[] for _ in range(len(gof_fileroot))]\\n\\n # Read data from all input files\\n for compnum in xrange(0, len(gof_fileroot)):\\n filenamebase = os.path.join(indir, gof_fileroot[compnum])\\n #print(\\\"Reading component files %s.*\\\" % (filenamebase))\\n periods[compnum], bias[compnum] = self.read_data(\\\"%s.bias\\\" %\\n (filenamebase),\\n 0.01)\\n periods[compnum], m90[compnum] = self.read_data(\\\"%s.m90\\\" %\\n (filenamebase),\\n 0.01)\\n periods[compnum], p90[compnum] = self.read_data(\\\"%s.p90\\\" %\\n (filenamebase),\\n 0.01)\\n periods[compnum], sigma[compnum] = self.read_data(\\\"%s.sigma\\\" %\\n (filenamebase),\\n 0.01)\\n periods[compnum], sigma0[compnum] = self.read_data(\\\"%s.sigma0\\\" %\\n (filenamebase),\\n 0.01)\\n\\n # Compute bias and conf interval lower/upper bounds\\n for i in xrange(0, len(bias[compnum])):\\n bias_l[compnum].append(bias[compnum][i] - sigma0[compnum][i])\\n bias_h[compnum].append(bias[compnum][i] + sigma0[compnum][i])\\n conf_l[compnum].append(m90[compnum][i])\\n conf_h[compnum].append(p90[compnum][i])\\n\\n num_periods = len(periods[0])\\n for comp in periods:\\n if len(comp) != num_periods:\\n print(\\\"Number of data points unequal across components\\\")\\n return\\n\\n # Construct baseline\\n baseline = [0.0 for _ in periods[0]]\\n\\n # Find max, min values\\n min_x = min([min(comp) for comp in periods])\\n max_x = max([max(comp) for comp in periods])\\n min_y = MIN_Y_AXIS\\n max_y = MAX_Y_AXIS\\n\\n # Start plots\\n num_plots = len(gof_fileroot)\\n # Make 1 column of \\\"num_plots\\\" rows\\n fig, axs = pylab.plt.subplots(num_plots, 1)\\n # Set plot dims\\n fig.set_size_inches(6, 10)\\n\\n #subplots_adjust(left=0.125)\\n #subplots_adjust(right=0.9)\\n #subplots_adjust(top=0.85)\\n fig.subplots_adjust(hspace=0.4)\\n fig.subplots_adjust(wspace=0.5)\\n\\n # Add subplots in a list\\n subfigs = []\\n for idx in range(0, num_plots):\\n subfigs.append(axs[idx])\\n\\n # Now walk through each subfig\\n for (subfig, subplot_title, cur_period,\\n cur_bias, cur_bias_h, cur_bias_l,\\n cur_conf_h, cur_conf_l) in zip(subfigs,\\n legends,\\n periods,\\n bias,\\n bias_h,\\n bias_l,\\n conf_h,\\n conf_l):\\n subfig.set_xlim(min_x, max_x)\\n subfig.set_ylim(min_y, max_y)\\n subfig.set_title(\\\"%s\\\" % subplot_title, size=10)\\n subfig.plot(cur_period, cur_bias, color='red', label='_nolegend_')\\n subfig.fill_between(cur_period, cur_bias_h,\\n cur_bias_l, color='cyan',\\n label='_nolegend_')\\n subfig.fill_between(cur_period, cur_conf_h,\\n cur_conf_l, color='yellow',\\n label='_nolegend_')\\n subfig.plot(cur_period, baseline, color='grey',\\n label='_nolegend_')\\n # Only put xlabel on bottom plot\\n if legends.index(subplot_title) == len(gof_fileroot) - 1:\\n subfig.set_xlabel(\\\"Period (sec)\\\", size=8)\\n subfig.set_ylabel(\\\"ln (data/model)\\\", size=8)\\n subfig.set_xscale('log')\\n # Old way to do it\\n # subfig.set_xticks(xtick_loc, xtick_label)\\n subfig.set_xticks(xtick_loc)\\n subfig.set_xticklabels(xtick_label)\\n subfig.tick_params(labelsize=8)\\n subfig.minorticks_on()\\n\\n fig.suptitle('%s\\\\nNumber of stations: %d' % (plottitle, num_stations),\\n size=12)\\n # Figure out output filename\\n outfile = gof_fileroot[0]\\n outfile = outfile[:outfile.rfind(\\\"-\\\")]\\n outfile = os.path.join(outdir, \\\"gof-%s.png\\\" % (outfile))\\n print(\\\"==> Created GoF plot: %s\\\" % (outfile))\\n fig.savefig(outfile, format=\\\"png\\\",\\n transparent=False, dpi=plot_config.dpi)\\n pylab.close()\",\n \"def plot_profiles(snap, profs, dust_species_to_plot, debug=False):\\n print('Plotting profiles...')\\n\\n units = {\\n 'position': 'au',\\n 'gas_velocity_radial_analytical': 'dimensionless',\\n 'dust_velocity_radial_analytical': 'dimensionless',\\n 'velocity_radial_numerical': 'dimensionless',\\n }\\n p = profs['gas'][0]\\n\\n if debug:\\n num_dust = snap.num_dust_species\\n ax = p.plot(x='radius', y=['velocity_pressure', 'velocity_visc'], units=units)\\n y = ['gas_velocity_radial']\\n y += [f'dust_velocity_radial_{idx+1:03}' for idx in range(num_dust)]\\n ax = p.plot(x='radius', y=y, units=units)\\n ax.legend().remove()\\n\\n fig, ax = plt.subplots()\\n\\n # Plot \\\"analytical\\\" radial drift velocity / velocity pressure component\\n p.plot(\\n x='radius',\\n y='gas_velocity_radial_analytical',\\n units=units,\\n color='black',\\n label='',\\n ax=ax,\\n )\\n y = [f'dust_velocity_radial_analytical_{idx+1:03}' for idx in dust_species_to_plot]\\n p.plot(x='radius', y=y, units=units, label='', ax=ax)\\n colors = [line.get_color() for line in ax.lines[1:]]\\n\\n # Plot \\\"numerical\\\" radial drift velocity / velocity pressure component\\n p.plot(\\n x='radius',\\n y='velocity_radial_numerical',\\n units=units,\\n color='black',\\n linestyle='',\\n marker='o',\\n markersize=4,\\n fillstyle='none',\\n label='gas',\\n std='shading',\\n ax=ax,\\n )\\n profs_to_plot = [\\n prof for idx, prof in enumerate(profs['dust']) if idx in dust_species_to_plot\\n ]\\n for species, prof, color in zip(dust_species_to_plot, profs_to_plot, colors):\\n label = f'{snap.properties[\\\"grain_size\\\"][species].to(\\\"cm\\\"):.1f~P}'\\n prof.plot(\\n x='radius',\\n y='velocity_radial_numerical',\\n units=units,\\n color=color,\\n linestyle='',\\n marker='o',\\n markersize=4,\\n fillstyle='none',\\n label=label,\\n std='shading',\\n ax=ax,\\n )\\n\\n ax.set_ylabel(r'$v_R / |v_P|$')\\n ax.grid()\\n\\n textstr = f't = {snap.properties[\\\"time\\\"].to(\\\"years\\\").m:.0f} years'\\n bbox = dict(boxstyle='round', facecolor='white', edgecolor='grey', alpha=0.8)\\n ax.text(\\n 0.97,\\n 0.97,\\n textstr,\\n transform=ax.transAxes,\\n horizontalalignment='right',\\n verticalalignment='top',\\n bbox=bbox,\\n )\\n ax.legend(framealpha=0.8, edgecolor='grey')\\n\\n return ax\",\n \"def main():\\n parser = argparse.ArgumentParser(description=\\n ('Plot and save data from DS9 projections. If only labels are '\\n 'given, it will just plot existing dat files.'\\n 'Other regions/objects in file are ignored.'))\\n\\n parser.add_argument('infile', help='Input DS9 region file (fk5 coords)')\\n parser.add_argument('datroot', help='Stem for output profile data')\\n\\n parser.add_argument('-p', '--pltroot', help='Stem for output plots')\\n parser.add_argument('-f', '--files', help=('Files (.fits) to be processed,'\\n ' one for each energy band'),\\n nargs='*')\\n\\n parser.add_argument('-l', '--labels', help='Band labels for plots/files',\\n nargs='+')\\n parser.add_argument('-v', '--verbose', action='store_true',\\n help='verbose mode')\\n parser.add_argument('-s', '--subplot', action='store_true',\\n help='Generate subplot plots')\\n\\n # Parse arguments\\n args = parser.parse_args()\\n regions_file = args.infile\\n pltroot, datroot = args.pltroot, args.datroot\\n bands, labels = args.files, args.labels # NOTE bands = args.files...\\n verbose, subplot = args.verbose, args.subplot\\n\\n # Check arguments for sanity\\n # If -p is supplied, output plots\\n # If -b is supplied, output data\\n if bands is None:\\n if not pltroot:\\n parser.error('Nothing to be done! Need bands or pltroot.')\\n else:\\n print 'No bands supplied, generating plots only'\\n else:\\n if len(bands) != len(labels):\\n raise ValueError(('Non-zero number of bands '\\n 'does not match number of labels!'))\\n elif not pltroot:\\n print 'No pltroot supplied, generating data only'\\n\\n # Parse projections\\n rspecs = get_projection_params(regions_file)\\n if verbose:\\n print 'Projections parsed from region file'\\n\\n # Generate data files, if desired\\n if bands is not None:\\n regparse.check_dir(datroot, verbose) # only create if saving data\\n generate_dat_files(rspecs, datroot, bands, labels)\\n\\n # Generate plots, if desired\\n if pltroot:\\n regparse.check_dir(pltroot, verbose)\\n generate_plots(rspecs, datroot, pltroot, labels, verbose, subplot)\\n\\n if verbose:\\n print 'Done!'\",\n \"def plot_physical_profiles(self, fig=2):\\n # Select the physical parameters\\n phys_parms = ['temperature', 'salinity', 'theta', 'N']\\n \\n # Plot these parameters\\n self.plot_profiles(phys_parms, fig)\",\n \"def compare_hist_2(results_dir_root):\\n plot_style = [\\n {'color': 'k', 'marker': 'none', 'lw': 1.5},\\n {'color': 'r', 'marker': 'none', 'lw': 1.5}\\n ]\\n unwrap_levels = ['r08']\\n\\n fig, axes = plt.subplots(figsize=(8, 10), nrows=5, ncols=2, sharex=True,\\n sharey=False)\\n fig.subplots_adjust(left=0.1, bottom=0.08, right=0.98, top=0.98,\\n hspace=0.05, wspace=0.15)\\n\\n print(axes.shape)\\n\\n results_dirs = [results_dir_root + '_0h', results_dir_root + '_4h']\\n\\n fig.text(0.5, 0.02, r'Baseline length (m)', ha='center')\\n fig.text(0.01, 0.5, r'Baseline count per bin', va='center',\\n rotation='vertical')\\n\\n # Loop over models\\n for i in range(7, 8):\\n models = ['ska1_v5', 'model%02i' % (i + 1)]\\n # Loop over 0h or 4h\\n for j in range(1):\\n idx = 0\\n ax = axes[i, j]\\n for model in models:\\n # Load saved psf results.\\n filename = join(results_dirs[j], '%s_uv_hist.p' % model)\\n print('-- Loading: %s' % filename)\\n hist = pickle.load(open(filename, 'rb'))\\n # Plot comparison of PSF profiles.\\n for tel in hist:\\n if tel == 'ska1_v5' or any(s in tel for s in unwrap_levels):\\n style = plot_style[idx % len(plot_style)]\\n x = hist[tel]['log']['hist_x']\\n y = hist[tel]['log']['hist_n']\\n cut_idx = np.argmax(x > 5e3)\\n x = x[:cut_idx]\\n y = y[:cut_idx]\\n ax.plot(x, y, color=style['color'],\\n linestyle='-',\\n label=tel + ' max')\\n idx += 1\\n length_str = 'snapshot' if j == 0 else '4 hours'\\n ax.text(0.02, 0.95, ('SKA1 v5 vs. Model %i\\\\n' % (i + 1)) + length_str,\\n weight='bold',\\n ha='left', va='top', transform=ax.transAxes,\\n fontsize='small')\\n # ax.legend(loc='best', fontsize='small', ncol=1)\\n # ax.set_xlabel('Baseline length (m)')\\n # ax.set_ylabel('Number of baselines per bin')\\n ax.set_xlim(10, 1e4)\\n if j == 1:\\n ax.set_ylim(1.5e3)\\n if j == 0:\\n ax.set_ylim(5)\\n ax.set_yscale('log')\\n ax.set_xscale('log')\\n # if i == 4:\\n # ax.set_xlabel('Baseline length (m)')\\n # ax.set_ylabel('Baseline count per bin')\\n ax.grid()\\n plt.show(True)\\n fig.savefig(join('compare_hist_%s.png' %\\n ('_'.join(unwrap_levels))))\\n plt.close(fig)\",\n \"def plot_folder(path):\\r\\n plt.figure(figsize=(20, 10))\\r\\n for filename in glob.glob(path + '/*.pspec'):\\r\\n x, y= np.loadtxt(fname=filename, delimiter='\\\\t',dtype=int, usecols = (1,2),\\r\\n skiprows=100, unpack = True)\\r\\n plt.plot(x, y)\\r\\n return plt.show()\",\n \"def make_plots(self):\\n n_rounds = self.run.n_rounds\\n\\n log.info('Making %d frames', n_rounds)\\n args = [self._get_for_parallel(i) for i in range(n_rounds)]\\n self.lbv.map(_plot_helper, args)\",\n \"def plot_skyplot(\\n self,\\n figure_name: str=\\\"plot_skyplot_{system}.{FIGURE_FORMAT}\\\",\\n ) -> List[pathlib.PosixPath]:\\n figure_paths = list()\\n \\n # Convert azimuth to range 0-360 degree\\n azimuth = self.dset.site_pos.azimuth\\n idx = azimuth < 0\\n azimuth[idx] = 2 * np.pi + azimuth[idx]\\n \\n # Convert zenith distance from radian to degree\\n zenith_distance = np.rad2deg(self.dset.site_pos.zenith_distance)\\n \\n # Generate x- and y-axis data per system\\n for sys in sorted(self.dset.unique(\\\"system\\\")):\\n x_arrays = []\\n y_arrays = []\\n labels = []\\n \\n figure_path = self.figure_dir / figure_name.replace(\\\"{system}\\\", sys).replace(\\\"{FIGURE_FORMAT}\\\", FIGURE_FORMAT)\\n figure_paths.append(figure_path)\\n \\n for sat in sorted(self.dset.unique(\\\"satellite\\\")):\\n if not sat.startswith(sys):\\n continue\\n idx = self.dset.filter(satellite= sat)\\n x_arrays.append(azimuth[idx])\\n y_arrays.append(zenith_distance[idx])\\n labels.append(sat)\\n \\n # Plot with polar projection\\n # TODO: y-axis labels are overwritten after second array plot. Why? What to do?\\n plot(\\n x_arrays=x_arrays,\\n y_arrays=y_arrays,\\n xlabel=\\\"\\\",\\n ylabel=\\\"\\\",\\n y_unit=\\\"\\\",\\n labels=labels,\\n figure_path=figure_path,\\n opt_args={\\n \\\"colormap\\\": \\\"hsv\\\",\\n \\\"figsize\\\": (7, 7.5),\\n \\\"legend\\\": True,\\n \\\"legend_ncol\\\": 6,\\n \\\"legend_location\\\": \\\"bottom\\\",\\n \\\"plot_to\\\": \\\"file\\\",\\n \\\"plot_type\\\": \\\"scatter\\\",\\n \\\"projection\\\": \\\"polar\\\",\\n \\\"title\\\": f\\\"Skyplot for {enums.gnss_id_to_name[sys]}\\\\n Azimuth [deg] / Elevation[deg]\\\",\\n \\\"xlim\\\": [0, 2 * np.pi],\\n \\\"ylim\\\": [0, 90],\\n \\\"yticks\\\": (range(0, 90, 30)), # sets 3 concentric circles\\n \\\"yticklabels\\\": (map(str, range(90, 0, -30))), # reverse labels from zenith distance to elevation\\n },\\n )\\n \\n return figure_paths\",\n \"def main(self, args):\\n for plot in args.plots:\\n if plot == 'no_plot':\\n break\\n print \\\"plotting\\\", plot\\n\\n fig = self.plot_figure(plot)\\n\\n fformat = '{plot}_{index}.{ext}'\\n fname = fformat.format(plot=plot, index=self.index, ext='png')\\n fpath = os.path.join(plot_dir, fname)\\n fig.savefig(fpath)\\n\\n if args.distributions == 'all':\\n distributions = ['Uf', 'Wf', 'uf_abs',\\n 'vorticity', 'vertical_shear']\\n else:\\n distributions = args.distributions\\n for dist in distributions:\\n range = self.properties[dist]['range']\\n name = self.properties[dist]['name']\\n print \\\"plotting distribution\\\", dist, name\\n fig = self.plot_distribution(getattr(self, dist), range, name)\\n\\n fformat = 'distribution_{q}_{index}.{ext}'\\n fname = fformat.format(q=dist, index=self.index, ext='png')\\n fpath = os.path.join(plot_dir, fname)\\n fig.savefig(fpath)\\n\\n if args.funcs:\\n for func in args.funcs:\\n print \\\"multiprocessing\\\", func\\n f = getattr(self, 'plot_' + func)\\n f()\",\n \"def plotSpectrums2D(path_fsrcnn, path_liif, path_msrn, path_esrgan, path_bicubic, out_path):\\n radial_FSRCNN = []\\n radial_LIIF = []\\n radial_MSRN = []\\n radial_ESRGAN = []\\n radial_BICUBIC = []\\n\\n for FSRCNN_path, LIIF_path, MSRN_path, ESRGAN_path, bicubic_path in zip(sorted(glob.glob(path_fsrcnn)), sorted(glob.glob(path_liif)), sorted(glob.glob(path_msrn)), sorted(glob.glob(path_esrgan)), sorted(glob.glob(path_bicubic))):\\n print(FSRCNN_path)\\n radialProfile_FSRCNN = spectrum2D(FSRCNN_path)\\n print(len(radialProfile_FSRCNN))\\n radial_FSRCNN.append(radialProfile_FSRCNN)\\n print(LIIF_path)\\n radialProfile_LIIF = spectrum2D(LIIF_path)\\n radial_LIIF.append(radialProfile_LIIF)\\n print(MSRN_path)\\n radialProfile_msrn = spectrum2D(MSRN_path)\\n radial_MSRN.append(radialProfile_msrn)\\n print(ESRGAN_path)\\n radialProfile_esrgan = spectrum2D(ESRGAN_path)\\n radial_ESRGAN.append(radialProfile_esrgan)\\n print(bicubic_path)\\n radialProfile_bicubic = spectrum2D(bicubic_path)\\n radial_BICUBIC.append(radialProfile_bicubic)\\n\\n image_name = FSRCNN_path.split('/')[-1]\\n if not os.path.exists(out_path):\\n os.makedirs(out_path)\\n\\n plt.figure()\\n plt.plot(radialProfile_FSRCNN, label='FSRCNN')\\n plt.plot(radialProfile_LIIF, label='LIIF')\\n plt.plot(radialProfile_msrn, label='MSRN')\\n plt.plot(radialProfile_esrgan, label='ESRGAN')\\n plt.plot(radialProfile_bicubic, label='BICUBIC')\\n plt.legend()\\n plt.title(image_name)\\n plt.yscale('log')\\n plt.savefig(out_path + image_name)\\n\\n mean_FSRCNN = tolerant_mean(radial_FSRCNN)\\n mean_LIIF = tolerant_mean(radial_LIIF)\\n mean_MSRN = tolerant_mean(radial_MSRN)\\n mean_ESRGAN = tolerant_mean(radial_ESRGAN)\\n mean_BICUBIC = tolerant_mean(radial_BICUBIC)\\n plt.figure()\\n plt.plot(mean_FSRCNN, label='FSRCNN')\\n plt.plot(mean_LIIF, label='LIIF')\\n plt.plot(mean_MSRN, label='MSRN')\\n plt.plot(mean_ESRGAN, label='ESRGAN')\\n plt.plot(mean_BICUBIC, label='BICUBIC')\\n plt.legend()\\n plt.title('MEAN')\\n plt.yscale('log')\\n plt.savefig(out_path + 'mean')\\n #return radialProfile_FSRCNN.shape, radialProfile_LIIF.shape, radialProfile_msrn.shape\",\n \"def plot_profiles(self, parameters, fig=1):\\n # Make sure the parameters are a list\\n if isinstance(parameters, str) or isinstance(parameters, unicode):\\n parameters = [parameters]\\n \\n # Decide how many subplots to create\\n nrows = int(len(parameters) / 3)\\n if len(parameters) % 3 > 0:\\n nrows += 1\\n \\n # Initialize a figure for plotting\\n width = 8\\n height = 4 * nrows\\n plt.figure(fig, figsize=(width, height))\\n plt.clf()\\n \\n # Plot each parameter\\n for parm in parameters:\\n ax = plt.subplot(nrows, 3, parameters.index(parm)+1)\\n self.plot_parameter(parm)\\n \\n plt.tight_layout()\\n \\n plt.show()\",\n \"def PlotProfile():\\n (metadata, data) = Parse('/tmp/sdcard-scalability.txt')\\n gp = Gnuplot.Gnuplot(persist=1)\\n gp('set data style impulses')\\n gp('set xtics 1')\\n gp('set pointsize 2')\\n gp.clear()\\n gp.xlabel('writer process')\\n gp.ylabel('duration in second')\\n gp.title(metadata.AsTitle())\\n\\n dataset = data[0]\\n x = numpy.array(dataset.time, dtype='int_')\\n d = Gnuplot.Data(x, dataset.data,\\n title=dataset.name,\\n with_='linespoints')\\n gp.replot(d)\\n gp.hardcopy('/tmp/%s-%s-%f.png' %\\n (metadata.name, metadata.kernel, metadata.duration),\\n terminal='png')\",\n \"def stm_profile_plot(flat_file, points, scan_dir=0, cmap=None, vmin=None, vmax=None, xy_ticks=4, z_ticks=4):\\n nm = 10 ** -9 # Define the nanometer to meter conversion.\\n\\n fig, ax = plt.subplots() # Create an instance of a pyplot figure and axis.\\n\\n # Set the minimum of the scan data to zero.\\n figure_data = (flat_file[scan_dir].data - np.amin(flat_file[scan_dir].data)) / nm\\n\\n if cmap is None: # If no color scheme is given use hot as default.\\n cmap = 'hot'\\n\\n if vmin is None: # If no z-axis minimum is given use minimum of the image data.\\n vmin = np.amin(figure_data)\\n if vmax is None: # If no z-axis maxmimum is given use 125% of the maximum in the image data.\\n vmax = 1.25 * np.amax(figure_data)\\n\\n # Add image plot to the axis and define it so that the color map can be generated.\\n cax = ax.imshow(figure_data, origin='lower', cmap=cmap, vmin=vmin, vmax=vmax)\\n\\n # Convert nanometer values into pixel numbers.\\n for point in range(len(points)):\\n points[point][0] = nm2pnt(points[point][0], flat_file, axis='x')\\n points[point][1] = nm2pnt(points[point][1], flat_file, axis='y')\\n\\n # Plot the line profile points on the axis.\\n ax.plot(points[:, 0], points[:, 1], 'bo-')\\n\\n xy_units = flat_file[scan_dir].info['unitxy'] # Get xy units.\\n\\n x_res = flat_file[scan_dir].info['xres'] # Get number of x-axis pixels.\\n y_res = flat_file[scan_dir].info['yres'] # Get number of y-axis pixels.\\n\\n x_max = flat_file[scan_dir].info['xreal'] # Get x-axis image size.\\n y_max = flat_file[scan_dir].info['yreal'] # get y-axis image size.\\n\\n # Set the x-axis ticks from number given.\\n ax.set_xticks([x for x in np.arange(0, x_res + 1, x_res / xy_ticks)])\\n # Set the x-axis tick labels from image size.\\n ax.set_xticklabels([str(np.round(x, 1)) for x in np.arange(0, x_max + 1, x_max / xy_ticks)])\\n\\n # Set the y-axis ticks from number given\\n ax.set_yticks([y for y in np.arange(0, y_res + 1, y_res / xy_ticks)])\\n # Set the y-axis tick labels from image size.\\n ax.set_yticklabels([str(np.round(y, 1)) for y in np.arange(0, y_max + 1, y_max / xy_ticks)])\\n\\n # Set the x- and y-axis labels.\\n ax.set_xlabel(xy_units, size=16, weight='bold')\\n ax.set_ylabel(xy_units, size=16, weight='bold')\\n\\n # Define the limits of the plot.\\n ax.set_xlim([0, x_res])\\n ax.set_ylim([0, y_res])\\n\\n # St the plot title with the image setpoint parameters.\\n ax.set_title('Set-Points: {voltage} V, {current} pA'.format(voltage=flat_file[scan_dir].info['vgap'],\\n current=np.round(\\n flat_file[scan_dir].info['current']*10**12)))\\n\\n # Define list containing the z-axis ticks from number given.\\n cbar_ticks = [z for z in np.arange(vmin, vmax * 1.01, vmax / z_ticks)]\\n # Define the z-axis tick labels.\\n cbar_ticklabels = [str(np.round(z, 1)) for z in np.arange(vmin, vmax + 1, vmax / z_ticks)]\\n # Create color bar.\\n cbar = fig.colorbar(cax, ticks=cbar_ticks)\\n # Set the color bar tick labels.\\n cbar.ax.set_yticklabels(cbar_ticklabels, size=16)\\n # Set color bar label.\\n cbar.set_label('Height [' + xy_units + ']', size=18, weight='bold')\\n\\n plt.show()\",\n \"def generate_plots(self, env):\\n print(' Generating diagnostic plots for : {0}'.format(self.__class__.__name__))\\n\\n # chdir into the working directory\\n os.chdir(env['WORKDIR'])\\n\\n for nclPlotFile in self._ncl:\\n # copy the NCL command to the workdir\\n shutil.copy2('{0}/{1}'.format(env['NCLPATH'],nclPlotFile), '{0}/{1}'.format(env['WORKDIR'], nclPlotFile))\\n\\n nclFile = '{0}/{1}'.format(env['WORKDIR'],nclPlotFile)\\n rc, err_msg = cesmEnvLib.checkFile(nclFile, 'read')\\n if rc:\\n try:\\n print(' calling NCL plot routine {0}'.format(nclPlotFile))\\n subprocess.check_call(['ncl', '{0}'.format(nclFile)], env=env)\\n except subprocess.CalledProcessError as e:\\n print('WARNING: {0} call to {1} failed with error:'.format(self.name(), nclFile))\\n print(' {0}'.format(e.cmd))\\n print(' rc = {0}'.format(e.returncode))\\n else:\\n print('{0}... continuing with additional plots.'.format(err_msg))\",\n \"def app_SN_combined_temperature_series(self, dfs, phase_dirs, sizer_val, styler_val): # need to implement other options\\n\\n print('Currently plotting plot_SN_combined_temperature_series')\\n\\n for df, direc in zip(dfs, phase_dirs):\\n # this iterates one or multiple times\\n self.plotter.plot_SN_combined_temperature_series(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['01_combined_plots'],\\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\\n styler=self.formatter.styler[styler_val]\\n )\\n self.plotter.plot_SN_combined_temperature_series(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['01_combined_plots'],\\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\\n styler=self.formatter.styler[styler_val],\\n xaxis_type='datetime'\\n )\\n\\n print('Done\\\\n')\",\n \"def make_plots(srcdir, outdir, include_subdir=False, level=3):\\n srcfiles = get_ordered_srcfiles(srcdir, include_subdir)\\n nodelist = get_f_nodelist(srcfiles)\\n for n in nodelist:\\n print(os.path.basename(n.name))\\n for m in n.dependencies:\\n print(' ' + os.path.basename(m.name))\\n print('')\\n\\n if not os.path.isdir(outdir):\\n raise Exception('output directory does not exist')\\n\\n for n in nodelist:\\n filename = os.path.join(outdir, os.path.basename(n.name) + '.png')\\n print('Creating ' + filename)\\n graph = pydot.Dot(graph_type='digraph')\\n node_dict = {}\\n ilev = 0\\n add_pydot_nodes(graph, node_dict, n, ilev, level)\\n edge_set = set()\\n ilev = 1\\n add_pydot_edges(graph, node_dict, edge_set, n, ilev, level)\\n graph.write_png(filename)\\n\\n return\",\n \"def plots():\\n out = interactive_output(generate_plots, {'gsize':gridSlider, 'ra':RABox, 'ra':RASlider, 'dec':DECBox, 'dec':DECSlider, 'ang':radBox, 'ang':radSlider, 'style':hexDrop})\\n return display(widgrid, out)\",\n \"def plotPaperFigures(folder='results/'):\\n #model Example\\n _AiryDisc(amplitude=1e6, center_x=10.0, center_y=10.0, radius=0.5, focus=0.4, size=21)\\n _CCDkernel(CCDx=10, CCDy=10, width_x=0.35, width_y=0.4, size=21)\\n plotModelExample()\\n\\n #simulation figures\\n theta1 = (2.e5, 9.9, 10.03, 0.41, 0.51, 10., 10., 0.291, 0.335)\\n try:\\n _plotDifferenceIndividualVsJoined(individuals='simulatedResults/RunI*.pkl',\\n joined='results/simulated800nmJoint.pkl',\\n title='Simulated Data: CCD PSF Recovery', truthx=theta1[7], truthy=theta1[8],\\n requirementE=None, requirementFWHM=None, requirementR2=None)\\n _plotModelResiduals(id='RunI1', folder='simulatedResults/', out='Residual1.pdf', individual=True)\\n except:\\n print 'No simulated data to plot...'\\n\\n #real data\\n _plotDifferenceIndividualVsJoined(individuals=folder+'I800nm?.pkl', joined=folder+'J800nm.pkl', title='800nm',\\n FWHMlims=(7.3, 11.8))\\n\\n _plotModelResiduals(id='I800nm2', folder=folder, out='ResidualData.pdf', individual=True)\\n _plotModelResiduals(id='RunI2', folder='simulatedResults/', out='Residual2.pdf', individual=True)\\n\\n #_plotModelResiduals(id='G600nm0', folder=folder, out='ResidualG600.pdf', individual=True)\\n #_plotModelResiduals(id='G700nm0', folder=folder, out='ResidualG700.pdf', individual=True)\\n _plotModelResiduals(id='G800nm0', folder=folder, out='ResidualG800.pdf', individual=True)\\n #_plotModelResiduals(id='G890nm0', folder=folder, out='ResidualG890.pdf', individual=True)\\n\\n #wavelength dependency\\n plotLambdaDependency()\\n\\n #brighter fatter\\n plotBrighterFatter()\",\n \"def generate_plots(rspecs, datroot, pltroot, labels,\\n verbose=False, subplot=False):\\n\\n if subplot:\\n n = len(labels)\\n plt.figure(figsize=(4*n,4))\\n else:\\n plt.figure(figsize=(6,4))\\n\\n if verbose:\\n print 'Generating {} plots...'.format(len(rspecs))\\n print 'First plot will hang a little longer'\\n\\n # Make a plot for each region\\n for i in xrange(len(rspecs)):\\n # Plot line/points for each label\\n for flab, j in zip(labels, xrange(n)):\\n dat_fname = '{0}_{1:02d}_band_{2}.dat'.format(datroot, i+1, flab)\\n a = np.loadtxt(dat_fname)\\n if subplot:\\n plt.subplot(1, n, j+1) # j indexes labels\\n plt.plot(a[:,0], a[:,1], '-o') # Use default color cycle\\n plt.title('Region {:g}, band {}'.format(i+1, flab))\\n fplot('Radial dist. (?)', 'Intensity? (?)')\\n else:\\n plt.plot(a[:,0], a[:,1], '-o') # Use default color cycle\\n # Format overall plot\\n if not subplot:\\n fplot('Radial dist. (?)', 'Intensity? (?)')\\n plt.title('Region %g' % (i+1))\\n plt.legend(labels, loc='best')\\n plt.tight_layout()\\n plt.savefig('{0}_{1:02d}.png'.format(pltroot, i+1), dpi=150)\\n plt.clf()\\n if verbose:\\n print 'Saved: {0}_{1:02d}.png'.format(pltroot, i+1)\",\n \"def plot_results(path: Path, output_dir: Path, skip: int = 100) -> Path:\\n with xr.open_dataset(path) as ds:\\n lons = ds.lon.values\\n lats = ds.lat.values\\n status = ds.status.values\\n stranded_flag = get_stranded_flag_from_status(ds)\\n\\n _ = plt.figure(figsize=(10, 10))\\n ax = plt.axes(projection=ccrs.PlateCarree(central_longitude=180))\\n ax.set_extent(\\n [-210, -140, 45, 75],\\n crs=ccrs.PlateCarree()\\n )\\n nparticles = len(lons)\\n if nparticles > skip:\\n iter_particles = np.arange(0, nparticles, skip)\\n else:\\n iter_particles = np.arange(0, nparticles)\\n\\n for particle in iter_particles:\\n # Create mask for stranded or not moving particles\\n mask = np.logical_and(\\n status[particle, :] <= 1,\\n status[particle, :] >= 0\\n )\\n # Cannot save figure if you plot something that is completely masked\\n # Cartopy will raise an error on save\\n if not np.any(mask):\\n continue\\n ax.plot(\\n lons[particle, mask],\\n lats[particle, mask],\\n color='g',\\n transform=ccrs.PlateCarree()\\n )\\n\\n # Starting position\\n ax.scatter(\\n ds.lon[particle, 0],\\n ds.lat[particle, 0],\\n c='b',\\n transform=ccrs.PlateCarree()\\n )\\n stranded_ix = ds.status[particle, :] == stranded_flag\\n\\n # Stranded particles\\n if np.any(stranded_ix):\\n ax.scatter(\\n ds.lon[particle, stranded_ix],\\n ds.lat[particle, stranded_ix],\\n c='r',\\n transform=ccrs.PlateCarree()\\n )\\n\\n ax.coastlines()\\n ax.add_feature(cartopy.feature.LAND.with_scale('110m'))\\n ax.gridlines(draw_labels=True)\\n\\n fname = path.name.replace('.nc', '.png')\\n outpath = output_dir / fname\\n\\n plt.tight_layout()\\n plt.savefig(outpath)\\n plt.close()\\n\\n return outpath\",\n \"def plot_path_statistics( self, path_file=\\\"tse_ensemble.json\\\" ):\\n from matplotlib import pyplot as plt\\n with open(path_file,'r') as infile:\\n data = json.load(infile)\\n try:\\n paths = data[\\\"transition_paths\\\"]\\n except KeyError:\\n paths = [data]\\n total_product_indicator = np.zeros(len(paths[0][\\\"symbols\\\"]))\\n total_reactant_indicator = np.zeros(len(paths[0][\\\"symbols\\\"]))\\n self.nuc_mc.min_size_product = paths[0][\\\"min_size_product\\\"]\\n self.nuc_mc.max_size_reactant = paths[0][\\\"max_size_reactant\\\"]\\n for path in paths:\\n product_indicator = []\\n reactant_indicator = []\\n reactant_indicator, product_indicator = self.get_basin_indicators(path)\\n\\n total_product_indicator += np.cumsum(product_indicator)/float( len(product_indicator) )\\n total_reactant_indicator += np.cumsum(reactant_indicator)/float( len(reactant_indicator) )\\n\\n total_reactant_indicator /= float( len(paths) )\\n total_product_indicator /= float( len(paths) )\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(1,1,1)\\n ax.plot( total_product_indicator, label=\\\"Product\\\" )\\n ax.plot( total_reactant_indicator, label=\\\"Reactant\\\" )\\n ax.set_xlabel( \\\"MC sweeps\\\" )\\n ax.set_ylabel( \\\"Indicator\\\" )\\n ax.spines[\\\"right\\\"].set_visible(False)\\n ax.spines[\\\"top\\\"].set_visible(False)\\n ax.legend( frameon=False, loc=\\\"best\\\" )\\n return fig\",\n \"def main():\\n import argparse\\n import os\\n parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)\\n parser.add_argument('--dirs', help='List of log directories', nargs='*', default=['./log'])\\n parser.add_argument('--num_timesteps', type=int, default=int(10e6))\\n parser.add_argument('--xaxis', help='Varible on X-axis', default=X_TIMESTEPS)\\n parser.add_argument('--task_name', help='Title of plot', default='Breakout')\\n args = parser.parse_args()\\n args.dirs = [os.path.abspath(folder) for folder in args.dirs]\\n plot_results(args.dirs, args.num_timesteps, args.xaxis, args.task_name)\\n plt.show()\",\n \"def save_plots(self):\\n pdir = os.path.splitext(self.filename)[0] + '_plots'\\n if not os.path.exists(pdir):\\n os.mkdir(pdir)\\n\\n for ii in range(self.uv.n_ant):\\n fig, ax = self.plot_single_baseline_dual_pol(ii+1, ii+1)\\n print \\\"Saving ant %i\\\"%ii\\n plt.savefig(os.path.join(pdir, 'ant-%i.png'%ii))\\n plt.clf()\",\n \"def app_SN_combined_temperature_gradient(self, dfs, phase_dirs, sizer_val, styler_val): # need to implement other options\\n\\n print('Currently plotting plot_SN_combined_temperature_gradient')\\n\\n for df, direc in zip(dfs, phase_dirs):\\n # this iterates one or multiple times\\n self.plotter.plot_SN_combined_temperature_gradient(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['01_combined_plots'],\\n sizer=self.formatter.sizer[sizer_val]['3x1_partial_width'],\\n styler=self.formatter.styler[styler_val],\\n xscale=self.xscale_var.get()\\n )\\n\\n print('Done\\\\n')\",\n \"def Diagnostic_plot3(self):\\n\\n floc = glob.glob('/home/mxs191/Desktop/MathewSchofield/TRG/DetTest/DetTest1_results/Info2Save/*.csv')\\n fig = plt.figure()\\n plt.rc('font', size=18)\\n #fig, ax = generalPlot(xaxis=r'$\\\\nu / \\\\mu$Hz', yaxis=r'$P_{\\\\rm det}$')\\n gs = gridspec.GridSpec(1, 2, width_ratios=(4,1))\\n ax = fig.add_subplot(gs[0])\\n\\n for idx, i in enumerate(floc):\\n\\n d = pd.read_csv(i)\\n\\n if idx == 0:\\n fullpdet = d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']]\\n else:\\n fullpdet = pd.concat([ fullpdet,\\\\\\n d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']] ])\\n\\n plt.scatter(d['f0'], d['Pdet_Kepler'], color='b',\\\\\\n label=r\\\"$\\\\rm Kepler - 4\\\\ yrs$\\\" if idx == 0 else '')\\n plt.scatter(d['f0'], d['Pdet_TESS365'], color='orange',\\\\\\n label=r'$\\\\rm TESS - 1\\\\ yr$' if idx == 0 else '')\\n plt.scatter(d['f0'], d['Pdet_TESS27'], color='g',\\\\\\n label=r'$\\\\rm TESS - 27\\\\ days$' if idx == 0 else '')\\n\\n plt.axhline(fullpdet['Pdet_Kepler'].median(), color='b')\\n plt.axhline(fullpdet['Pdet_TESS365'].median(), color='orange')\\n plt.axhline(fullpdet['Pdet_TESS27'].median(), color='g')\\n ax.legend(loc='lower right')\\n plt.ylim([0,1])\\n ax.set_ylabel(r'$P_{\\\\rm det}$')\\n ax.set_xlabel(r'$\\\\nu / \\\\mu \\\\rm Hz$')\\n\\n bx = fig.add_subplot(gs[1])\\n import seaborn as sns\\n bw = 0.4\\n sns.kdeplot(fullpdet['Pdet_Kepler'].values, shade=True, vertical=True, \\\\\\n ax=bx, color='b', bw=bw)\\n sns.kdeplot(fullpdet['Pdet_TESS365'].values, shade=True, vertical=True, \\\\\\n ax=bx, color='orange', bw=bw)\\n sns.kdeplot(fullpdet['Pdet_TESS27'].values, shade=True, vertical=True, \\\\\\n ax=bx, color='g', bw=bw)\\n bx.set_ylim([0.0,1.0])\\n bx.set_xticks([])\\n bx.set_yticks([])\\n bx.set_xlabel(r'$\\\\rm Density$')\\n plt.tight_layout()\\n\\n plt.show()\\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\\\\n 'DetTest_Diagnostic_plot3.pdf')\\n sys.exit()\",\n \"def plotPerLumiSection(options):\\n name = options['name'] + '_perLS'\\n f = openRootFileR(name)\\n histname = plotName(options['title']+'_perLS', timestamp=False)\\n filename = plotName(options['title']+'_perLS', timestamp=True)\\n filepath = plotPath(options['title']+'_perLS', timestamp=True)\\n print '<<< Save plot:', filepath\\n hist = f.Get(histname)\\n canvas = TCanvas()\\n canvas.SetLogy(options['logy'])\\n gStyle.SetOptStat(options['optstat'])\\n hist.Draw()\\n gPad.Update()\\n hist.GetXaxis().SetTitle('Lumisection')\\n hist.GetYaxis().SetTitle(options['ytitle'])\\n hist.GetYaxis().SetTitleOffset(1.2)\\n for axis in [hist.GetXaxis(), hist.GetYaxis()]:\\n axis.SetTitleFont(133)\\n axis.SetTitleSize(16)\\n axis.SetLabelFont(133)\\n axis.SetLabelSize(12)\\n axis.CenterTitle()\\n drawSignature(filename)\\n gPad.Modified()\\n gPad.Update()\\n #canvas.Print(filepath)\\n #canvas.Close()\\n #closeRootFile(f, name)\\n return [canvas, hist, f]\",\n \"def plot_results(infer_images, inference_predicted_class, inference_predictions, class_names=['plants', 'water']):\\n plt.style.use(['dark_background', 'bmh'])\\n rc('figure', figsize=(8, 8), max_open_warning=False)\\n rc('axes', facecolor='none')\\n plt.figure(figsize=(15, 15))\\n\\n for i, (infer_img, _) in enumerate(infer_images.take(10)):\\n ax = plt.subplot(5, 2, i + 1)\\n plt.imshow(infer_img.numpy()/255)\\n\\n # Find the predicted class from predictions\\n m = \\\"Predicted: {}, {:.2f}%\\\".format(\\n class_names[inference_predicted_class[i]], inference_predictions[i]*100)\\n plt.title(m)\\n plt.axis(\\\"off\\\")\\n plt.show()\",\n \"def plot_visual_abstract():\\n # Which generations to plot\\n GENERATIONS = [100, 230, 350]\\n\\n # LunarLander CMA-ES\\n experiment_path = glob(\\\"experiments/wann_LunarLander-v2_CMAES*\\\")\\n assert len(experiment_path) == 1, \\\"There should be only one CMA-ES experiment with LunarLander-v2\\\"\\n experiment_path = experiment_path[0]\\n\\n pivector_paths = glob(os.path.join(experiment_path, \\\"pivectors\\\", \\\"*\\\"))\\n\\n tsnes = []\\n rewards = []\\n for generation in GENERATIONS:\\n # Find pivector files for specific generation, load them and store points\\n generation_paths = [path for path in pivector_paths if \\\"gen_{}_\\\".format(generation) in path]\\n\\n population = [np.load(path) for path in generation_paths]\\n population_tsnes = np.array([x[\\\"tsne\\\"] for x in population])\\n population_rewards = np.array([x[\\\"average_episodic_reward\\\"] for x in population])\\n tsnes.append(population_tsnes)\\n rewards.append(population_rewards)\\n\\n figure, axs = pyplot.subplots(\\n figsize=[2.5 * 3, 2.5],\\n nrows=1,\\n ncols=len(GENERATIONS),\\n sharex=\\\"all\\\",\\n sharey=\\\"all\\\"\\n )\\n\\n min_reward = min(x.min() for x in rewards)\\n max_reward = max(x.max() for x in rewards)\\n scatter = None\\n\\n for idx in range(len(GENERATIONS)):\\n population_tsne = tsnes[idx]\\n population_rewards = rewards[idx]\\n generation = GENERATIONS[idx]\\n ax = axs[idx]\\n\\n scatter = ax.scatter(\\n population_tsne[:, 0],\\n population_tsne[:, 1],\\n c=population_rewards,\\n vmin=min_reward,\\n vmax=max_reward,\\n cmap=\\\"plasma\\\"\\n )\\n ax.set_title(\\\"Generation {}\\\".format(generation))\\n ax.set_xticks([])\\n ax.set_yticks([])\\n ax.axis(\\\"off\\\")\\n\\n # Making room for colorbar\\n # Stackoverflow #13784201\\n figure.subplots_adjust(right=1.0)\\n cbar = figure.colorbar(scatter)\\n cbar.set_ticks([])\\n cbar.ax.set_ylabel(\\\"Reward $\\\\\\\\rightarrow$\\\", rotation=90, fontsize=\\\"large\\\")\\n\\n figure.tight_layout()\\n figure.savefig(\\\"figures/visual_abstract.pdf\\\", bbox_inches=\\\"tight\\\", pad_inches=0.05)\",\n \"def plotting(self,job,input_zip,output_file,df,my_dpi):\\n if len(job.Y2headers)>0:\\n X1=df.loc[:,job.X1header].values\\n X2=df.loc[:,job.X2header].values\\n Y1=df.loc[:,job.Y1headers].values\\n if (job.name.startswith(\\\"Morphine\\\") or job.name.startswith(\\\"Sarin\\\")) and os.path.exists(job.experimentalData):\\n df2=pd.read_csv(job.experimentalData)\\n Y2=np.array(df2.loc[:,job.Y2headers].values)\\n X1=np.array(df2.loc[:,job.X1header].values[:Y2.shape[0]])\\n Y1=np.array(df.loc[:,job.Y1headers].values[:Y2.shape[0]])\\n X2=np.array(df.loc[:,job.X2header].values[:Y2.shape[0]])\\n else:\\n Y2=df.loc[:,job.Y2headers].values\\n fig,ax = plt.subplots()\\n fig.set_size_inches(w=job.imageWidth/my_dpi+3.1,h=job.imageHeight/my_dpi+1)\\n \\n if not os.path.exists(job.outputDir):\\n os.mkdir(job.outputDir)\\n \\n if job.X1LowerBound and job.X1UpperBound:\\n ax.set_xlim(job.X1LowerBound,job.X1UpperBound)\\n elif job.X1LowerBound:\\n ax.set_xlim(left=job.X1LowerBound)\\n elif job.X1UpperBound:\\n ax.set_xlim(right=job.X1UpperBound)\\n\\n if job.Y1LowerBound and job.Y1UpperBound:\\n ax.set_ylim(job.Y1LowerBound,job.Y1UpperBound)\\n elif job.Y1LowerBound:\\n ax.set_ylim(bottom=job.Y1LowerBound)\\n elif job.Y1UpperBound:\\n ax.set_ylim(top=job.Y1UpperBound) \\n \\n ax.get_yaxis().set_major_locator(MaxNLocator(nbins=18,min_n_ticks=8))\\n ax.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\\n ax.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\\n ax.set_xlabel(job.X1header,fontsize=job.fontSize)\\n \\n if job.Y1Label!=None:\\n ax.set_ylabel(job.Y1Label,color=\\\"g\\\",fontsize=job.fontSize)\\n else:\\n ax.set_ylabel(job.Y1headers[0],color=\\\"g\\\",fontsize=job.fontSize)\\n p1=ax.plot(X1,Y1,color=\\\"g\\\")\\n\\n ax2=ax.twinx()\\n \\n if job.Y2LowerBound and job.Y2UpperBound:\\n ax2.set_ylim(job.Y2LowerBound,job.Y2UpperBound)\\n elif job.Y2LowerBound:\\n ax2.set_ylim(bottom=job.Y2LowerBound)\\n elif job.Y2UpperBound:\\n ax2.set_ylim(top=job.Y2UpperBound)\\n \\n ax2.get_yaxis().set_major_locator(MaxNLocator(nbins=18,min_n_ticks=8))\\n ax2.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\\n ax2.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\\n ax2.set_xlabel(job.X1header,fontsize=job.fontSize)\\n \\n if job.Y2Label!=None:\\n ax2.set_ylabel(job.Y2Label,color=\\\"b\\\",fontsize=job.fontSize)\\n else:\\n ax2.set_ylabel(job.Y2headers[0],color=\\\"b\\\",fontsize=job.fontSize)\\n \\n p2=ax2.plot(X2,Y2,color=\\\"b\\\")\\n title=job.name+\\\"_\\\"\\n title+=job.Y2headers[0]\\n title = title + \\\"vs_\\\" + job.X1header\\n \\n if job.X2header != None and not job.X1header.lower() == job.X2header.lower():\\n title = title + \\\"_\\\" + job.X2header\\n # Override the constructed title if desired\\n \\n if job.titleOverride != None and not len(job.titleOverride)==0 and not job.titleOverride.lower() == \\\"None\\\".lower():\\n title = job.titleOverride\\n if job.log>=1:\\n logging.info(\\\"Creating Graph:\\\"+title)\\n \\n if job.titleOverride !=\\\"None\\\":\\n plt.title(title,fontsize=job.fontSize)\\n \\n if job.showGridLines:\\n plt.grid(b=True, which='major', color='r', linestyle='--')\\n \\n if not job.removeAllLegends:\\n p=p1+p2\\n labs=[job.Y1headers[0],job.Y2headers[0]]\\n ax.legend(p,labs)\\n \\n if \\\"(\\\" and \\\")\\\" in job.outputFilename:\\n job.outputFilename=job.outputFilename.split(\\\"(\\\")[0]+\\\".jpg\\\"\\n plt.savefig(os.path.join(job.outputDir,job.outputFilename),dpi=my_dpi)\\n plt.close(\\\"all\\\")\\n\\n elif len(job.Y2headers)==0:\\n X1=df.loc[:,job.X1header]\\n Y1=df.loc[:,job.Y1headers]\\n fig,ax = plt.subplots()\\n fig.set_size_inches(w=job.imageWidth/my_dpi+3.1,h=job.imageHeight/my_dpi+1)\\n \\n if not os.path.exists(job.outputDir):\\n os.mkdir(job.outputDir)\\n \\n if job.X1LowerBound and job.X1UpperBound:\\n ax.set_xlim(job.X1LowerBound,job.X1UpperBound)\\n elif job.X1LowerBound:\\n ax.set_xlim(left=job.X1LowerBound)\\n elif job.X1UpperBound:\\n ax.set_xlim(right=job.X1UpperBound)\\n\\n if job.Y1LowerBound and job.Y1UpperBound:\\n ax.set_ylim(job.Y1LowerBound,job.Y1UpperBound)\\n elif job.Y1LowerBound:\\n ax.set_ylim(bottom=job.Y1LowerBound)\\n elif job.Y1UpperBound:\\n ax.set_ylim(top=job.Y1UpperBound) \\n \\n ax.get_yaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=8))\\n ax.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\\n ax.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\\n ax.set_xlabel(job.X1header,fontsize=job.fontSize)\\n ax.set_ylabel(job.Y1headers[0],fontsize=job.fontSize)\\n p=ax.plot(X1,Y1)\\n title=job.name+\\\"_\\\"\\n title = title + \\\"vs_\\\" + job.X1header\\n \\n if job.X2header != None and not job.X1header.lower() == job.X2header.lower():\\n title = title + \\\"_\\\" + job.X2header\\n \\n # Override the constructed title if desired\\n if job.titleOverride != None and not len(job.titleOverride)==0 and not job.titleOverride.lower() == \\\"None\\\".lower():\\n title = job.titleOverride\\n if job.log>=1:\\n logging.info(\\\"Creating Graph:\\\"+title)\\n \\n if job.titleOverride !=\\\"None\\\":\\n plt.title(title,fontsize=job.fontSize)\\n \\n if job.showGridLines:\\n plt.grid(b=True, which='major', color='r', linestyle='--')\\n \\n if not job.removeAllLegends:\\n labs=job.Y1headers\\n plt.legend(p,labs)\\n \\n if \\\"(\\\" and \\\")\\\" in job.outputFilename:\\n job.outputFilename=job.outputFilename.split(\\\"(\\\")[0]+\\\".jpg\\\"\\n plt.savefig(os.path.join(job.outputDir,job.outputFilename),dpi=my_dpi)\\n plt.close(\\\"all\\\")\\n \\n else:\\n X1=df.loc[:,job.X1header]\\n Y1=df.loc[:,job.Y1headers]\\n fig,ax = plt.subplots()\\n fig.set_size_inches(w=job.imageWidth/my_dpi+3.1,h=job.imageHeight/my_dpi+1)\\n \\n if not os.path.exists(job.outputDir):\\n os.mkdir(job.outputDir)\\n \\n if job.X1LowerBound and job.X1UpperBound:\\n ax.set_xlim(job.X1LowerBound,job.X1UpperBound)\\n elif job.X1LowerBound:\\n ax.set_xlim(left=job.X1LowerBound)\\n elif job.X1UpperBound:\\n ax.set_xlim(right=job.X1UpperBound)\\n\\n if job.Y1LowerBound and job.Y1UpperBound:\\n ax.set_ylim(job.Y1LowerBound,job.Y1UpperBound)\\n elif job.Y1LowerBound:\\n ax.set_ylim(bottom=job.Y1LowerBound)\\n elif job.Y1UpperBound:\\n ax.set_ylim(top=job.Y1UpperBound) \\n \\n ax.get_yaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=8))\\n ax.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\\n ax.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\\n ax.set_xlabel(job.X1header,fontsize=job.fontSize)\\n ax.set_ylabel(job.Y1headers[0],fontsize=job.fontSize)\\n p1=ax.plot(X1,Y1)\\n title=job.name+\\\"_\\\"\\n title = title + \\\"vs_\\\" + job.X1header\\n \\n if job.X2header != None and not job.X1header.lower() == job.X2header.lower():\\n title = title + \\\"_\\\" + job.X2header\\n \\n # Override the constructed title if desired\\n if job.titleOverride != None and not len(job.titleOverride)==0 and not job.titleOverride.lower() == \\\"None\\\".lower():\\n title = job.titleOverride\\n if job.log>=1:\\n logging.info(\\\"Creating Graph:\\\"+title)\\n \\n if job.titleOverride !=\\\"None\\\":\\n plt.title(title,fontsize=job.fontSize)\\n \\n if job.showGridLines:\\n plt.grid(b=True, which='major', color='r', linestyle='--')\\n \\n if not job.removeAllLegends:\\n labs=job.Y1headers\\n ax.legend(p1, labs)\\n \\n if \\\"(\\\" and \\\")\\\" in job.outputFilename:\\n job.outputFilename=job.outputFilename.split(\\\"(\\\")[0]+\\\".jpg\\\"\\n plt.savefig(os.path.join(job.outputDir,job.outputFilename),dpi=my_dpi)\\n plt.close(\\\"all\\\")\",\n \"def generate_plots(self, headers: [str], barplot_name: str, barplot_data: [int],\\n lineplot_name: str, multi_data: [[int]]):\\n self.export_data(barplot_name, headers, barplot_data)\\n title = 'Total IRTs (' + str(C.MAX_ITERATIONS) + ' Steps)'\\n self.barplot(barplot_name, y_label='Total IRT', img_title=title)\\n self.lineplot(lineplot_name, headers, multi_data, img_title='IRT Paths')\",\n \"def plot_rates(save_dir, formation_rate, merger_rate, detection_rate, redshifts, chirp_masses, show_plot = False, mu0=0.035, muz=-0.23, sigma0=0.39, sigmaz=0., alpha=0):\\n # sum things up across binaries\\n total_formation_rate = np.sum(formation_rate, axis=0)\\n total_merger_rate = np.sum(merger_rate, axis=0)\\n total_detection_rate = np.sum(detection_rate, axis=0)\\n \\n # and across redshifts\\n cumulative_detection_rate = np.cumsum(total_detection_rate)\\n detection_rate_by_binary = np.sum(detection_rate, axis=1)\\n\\n ###########################\\n #Start plotting\\n\\n # set some constants for the plots\\n plt.rc('font', family='serif')\\n fs = 20\\n lw = 3\\n\\n fig, axes = plt.subplots(2, 2, figsize=(20, 20))\\n\\n axes[0,0].plot(redshifts, total_formation_rate, lw=lw)\\n axes[0,0].set_xlabel('Redshift', fontsize=fs)\\n axes[0,0].set_ylabel(r'Formation rate $[\\\\rm \\\\frac{\\\\mathrm{d}N}{\\\\mathrm{d}Gpc^3 \\\\mathrm{d}yr}]$', fontsize=fs)\\n\\n axes[0,1].plot(redshifts, total_merger_rate, lw=lw)\\n axes[0,1].set_xlabel('Redshift', fontsize=fs)\\n axes[0,1].set_ylabel(r'Merger rate $[\\\\rm \\\\frac{\\\\mathrm{d}N}{\\\\mathrm{d}Gpc^3 \\\\mathrm{d}yr}]$', fontsize=fs)\\n\\n axes[1,0].plot(redshifts[:len(cumulative_detection_rate)], cumulative_detection_rate, lw=lw)\\n axes[1,0].set_xlabel('Redshift', fontsize=fs)\\n axes[1,0].set_ylabel(r'Cumulative detection rate $[\\\\rm \\\\frac{\\\\mathrm{d}N}{\\\\mathrm{d}yr}]$', fontsize=fs)\\n\\n axes[1,1].hist(chirp_masses, weights=detection_rate_by_binary, bins=25, range=(0, 50))\\n axes[1,1].set_xlabel(r'Chirp mass, $\\\\mathcal{M}_c$', fontsize=fs)\\n axes[1,1].set_ylabel(r'Mass distribution of detections $[\\\\rm \\\\frac{\\\\mathrm{d}N}{\\\\mathrm{d}\\\\mathcal{M}_c \\\\mathrm{d}yr}]$', fontsize=fs)\\n\\n #########################\\n #Plotvalues\\n\\n # Add text upper left corner\\n axes[0,0].text(0.05,0.8, \\\"mu0=%s \\\\nmuz=%s \\\\nsigma0=%s \\\\nsigmaz=%s \\\\nalpha=%s\\\"%(mu0,muz,sigma0,sigmaz,alpha), transform=axes[0,0].transAxes, size = fs) \\n\\n for ax in axes.flatten():\\n ax.tick_params(labelsize=0.9*fs)\\n\\n # Save and show :)\\n plt.savefig(save_dir +'Rate_Info'+\\\"mu0%s_muz%s_alpha%s_sigma0%s_sigmaz%s\\\"%(mu0,muz,alpha,sigma0, sigmaz)+'.png', bbox_inches='tight') \\n if show_plot:\\n plt.show()\\n else:\\n plt.close()\",\n \"def radial_graph(self):\\n \\n if self['M_RADIAL']['intens'] != None:\\n name = self['name']\\n id = self._getGraphId()\\n figname = 'RADIAL_%s.eps' % id\\n sxlabel = 'Pixel Radius' ; sylabel = 'Intens' \\n title = 'Radial profile, %s' % (name,)\\n y = self['M_RADIAL']['intens']\\n x = self['M_RADIAL']['radii']\\n xy = ((x,y),)\\n Plot(xy,figname,sxlabel,sylabel,title)\\n self['figures']['radial'] = figname\\n else : pass\",\n \"def plot_tiltres(setup, mtilt, ytilt, yfit, slit=None, outfile=None, show_QA=False, out_dir=None):\\n\\n plt.rcdefaults()\\n plt.rcParams['font.family']= 'times new roman'\\n\\n # Outfil\\n method = inspect.stack()[0][3]\\n if (outfile is None) and (not show_QA):\\n outfile = qa.set_qa_filename(setup, method, slit=slit, out_dir=out_dir)\\n\\n # Setup\\n plt.figure(figsize=(8, 4.0))\\n plt.clf()\\n ax = plt.gca()\\n\\n # Scatter plot\\n res = (mtilt-ytilt) - yfit\\n ax.scatter(mtilt, res)\\n\\n rms = np.std(res)\\n ax.text(0.90, 0.90, 'Slit {:d}: RMS (pix) = {:0.5f}'.format(slit, rms),\\n transform=ax.transAxes, size='large', ha='right', color='black')\\n # Label\\n ax.set_xlabel('Row')\\n ax.set_ylabel('Residual (pix)')\\n\\n # Finish\\n plt.tight_layout(pad=0.2, h_pad=0.0, w_pad=0.0)\\n if show_QA:\\n plt.show()\\n else:\\n plt.savefig(outfile, dpi=400)\\n plt.close()\\n\\n plt.rcdefaults()\\n\\n return\",\n \"def make_posterior_plots(self, combined=False):\\n import matplotlib.pyplot as plt\\n plt.rcParams['text.usetex'] = True\\n\\n if combined:\\n outdir = os.path.join(self.outdir, 'CombinedPosteriors')\\n maintitle = self.make_main_title(end='Posteriors')\\n else:\\n outdir = os.path.join(self.outdir, 'IndividualPosteriors')\\n maintitle = self.make_main_title(end='Posterior')\\n mkdir(outdir)\\n\\n for injkey in self.values.keys():\\n for fhkey in self.values[injkey].keys():\\n # Set up multi-plot if needed\\n if combined:\\n num_rows = self.get_num_rows(\\n data=self.values[injkey][fhkey],\\n omit_metric=False\\n )\\n plt.figure(figsize=(20, 5*num_rows+2))\\n subplotnum = 1\\n else:\\n subplotnum = None\\n # Loop through the systematics\\n for systkey in self.values[injkey][fhkey].keys():\\n fittitle = self.make_fit_title(\\n fhkey=fhkey,\\n trials=self.num_trials\\n )\\n systunits = self.values[injkey][fhkey][systkey]['units']\\n if systkey == 'metric_val':\\n xlabel = self.tex_axis_label(\\n self.values[injkey][fhkey][systkey]['type']\\n )\\n else:\\n xlabel = self.tex_axis_label(systkey)\\n if not systunits == 'dimensionless':\\n xlabel += r' (%s)'%self.tex_axis_label(systunits)\\n # Specify the subplot, if necessary\\n if combined:\\n plt.subplot(num_rows, 4, subplotnum)\\n self.make_1d_hist_plot(\\n data=np.array(\\n self.values[injkey][fhkey][systkey]['vals']\\n ),\\n xlabel=xlabel,\\n title=maintitle+r'\\\\\\\\'+fittitle,\\n ylabel='Number of Trials',\\n subplotnum=subplotnum\\n )\\n # Add the details i.e. injected/fiducial lines and priors\\n plt.ylim(0, 1.35*plt.ylim()[1])\\n if not systkey == 'metric_val':\\n self.add_inj_fid_lines(\\n injkey=injkey,\\n systkey=systkey,\\n fhkey=fhkey\\n )\\n self.add_prior_region(\\n injkey=injkey,\\n systkey=systkey,\\n fhkey=fhkey\\n )\\n plt.legend(\\n loc='upper left',\\n fontsize=12,\\n framealpha=1.0\\n )\\n plt.subplots_adjust(\\n left=0.10,\\n right=0.90,\\n top=0.85,\\n bottom=0.11\\n )\\n # Advance the subplot number, if necessary\\n if combined:\\n subplotnum += 1\\n # Else, save/close this plot\\n else:\\n self.save_plot(\\n fhkey=fhkey,\\n outdir=outdir,\\n end='%s_posterior'%systkey\\n )\\n plt.close()\\n # Save the whole canvas, if necessary\\n if combined:\\n plt.suptitle(maintitle+r'\\\\\\\\'+fittitle, fontsize=36)\\n plt.tight_layout()\\n plt.subplots_adjust(top=0.9)\\n self.save_plot(\\n fhkey=fhkey,\\n outdir=outdir,\\n end='posteriors'\\n )\\n plt.close()\",\n \"def plot_analysis(opt):\\n LOG.debug(\\\"Plotting GetLLM analysis.\\\")\\n mdl_analysis = opt.subnode in mdl_subnodes\\n\\n ps.set_style(\\\"standard\\\", MANUAL_STYLE)\\n xmin = min(opt.xplot_xmin, opt.yplot_xmin)\\n xmax = max(opt.xplot_xmax, opt.yplot_xmax)\\n\\n gs = gridspec.GridSpec(2, 1, height_ratios=[1, 1])\\n ax_x = plt.subplot(gs[0])\\n ax_y = None\\n ir_pos = None\\n\\n paths = opt.path.split(',')\\n\\n if opt.label == 'None':\\n if mdl_analysis:\\n labels = [\\\"mo_\\\" + opt.path.rsplit('/', 1)[-1], \\\"me_\\\" + opt.path.rsplit('/', 1)[-1]]\\n else:\\n labels = paths\\n else:\\n labels = opt.label.split(',')\\n\\n for idx, path in enumerate(paths):\\n data_x, data_y = get_data(path, opt.mainnode, opt.subnode)\\n plot_data(ax_x, data_x, labels, idx, opt.change_marker)\\n\\n if ir_pos is None:\\n ir_pos = get_irpos(data_x, opt.accel)\\n\\n if data_y is not None:\\n if ax_y is None:\\n ax_x.axes.get_xaxis().set_visible(False)\\n ax_y = plt.subplot(gs[1])\\n plot_data(ax_y, data_y, labels, idx, opt.change_marker)\\n\\n ax_x.set_xlim(xmin, xmax)\\n ax_x.set_ylim(opt.xplot_ymin, opt.xplot_ymax)\\n set_yaxis_label(ax_x, 'x', opt.subnode)\\n\\n if ax_y is not None:\\n ax_y.set_xlim(xmin, xmax)\\n ax_y.set_ylim(opt.yplot_ymin, opt.yplot_ymax)\\n set_yaxis_label(ax_y, 'y', opt.subnode)\\n ps.set_xaxis_label(ax_y)\\n if ir_pos:\\n ps.show_ir(ir_pos, ax_y, mode='outside')\\n ps.show_ir(ir_pos, ax_x, mode='lines')\\n else:\\n ax_x.axes.get_xaxis().set_visible(True)\\n ps.set_xaxis_label(ax_x)\\n if ir_pos:\\n ps.show_ir(ir_pos, ax_x, mode='outside')\\n\\n if int(opt.legendh) > 12:\\n show_legend(ax_x, int(opt.legendx), int(opt.legendy))\\n return gs\",\n \"def plot(self, **kwargs):\\n\\n # get colors\\n colors = kwargs.get(\\\"colors\\\", GW_OBSERVATORY_COLORS)\\n\\n # get Result samples\\n self._samples = {\\n label: value.posterior\\n for label, value in self.results.items()\\n if isinstance(value, Result)\\n }\\n\\n # get Grid posteriors\\n self._grids = {\\n label: [value, value.ln_evidence] # store grid and log evidence\\n for label, value in self.results.items()\\n if isinstance(value, Grid)\\n }\\n\\n # apply offsets for slightly nicer plots axes\\n self.parameter_offsets = {parameter: 0.0 for parameter in self.parameters}\\n if len(self._grids) == 0 and len(self._samples) == 1:\\n for label in self._samples:\\n for parameter in self.parameters:\\n srange = [\\n np.min(self._samples[label][parameter]),\\n np.max(self._samples[label][parameter]),\\n ]\\n label_suffix = \\\"\\\"\\n\\n # offset values\\n median = np.median(self._samples[label][parameter])\\n relwidth = np.abs((srange[1] - srange[0]) / median)\\n\\n if relwidth < 1e-4:\\n offsetstr = f\\\"{median:.4e}\\\"\\n a, b = offsetstr.split(\\\"e\\\")\\n\\n if np.abs(int(b)) < 3:\\n offsetstr = f\\\"{median:.4f}\\\"\\n offset = float(offsetstr)\\n else:\\n offset = float(offsetstr)\\n offsetstr = a + rf\\\"\\\\!\\\\times\\\\!10^{{{int(b)}}}\\\"\\n\\n self.parameter_offsets[parameter] = offset\\n\\n self._samples[label][parameter] -= offset\\n label_suffix = rf\\\" [${{\\\\scriptstyle {offsetstr}}}$]\\\"\\n\\n self.latex_labels[parameter] += label_suffix\\n\\n colordicts = []\\n for j, res in enumerate([self._samples, self._grids]):\\n colordicts.append({})\\n for i, key in enumerate(res):\\n if key in colors:\\n colordicts[-1][key] = colors[key]\\n elif key.lower() == \\\"joint\\\":\\n # if using \\\"Joint\\\" as the multi-detector analysis key, set the color to black\\n colordicts[-1][key] = \\\"k\\\"\\n else:\\n # use PESummary color cycle\\n colordicts[-1][key] = list(colorcycle)[\\n (j * 2 + i) % len(colorcycle)\\n ]\\n\\n # store original keywords arguments\\n origkwargs = kwargs.copy()\\n\\n # plot samples\\n fig = None\\n if len(self._samples) > 0:\\n kwargs[\\\"colors\\\"] = list(colordicts[0].values())\\n if self._num_parameters == 1:\\n fig = self._1d_plot_samples(**kwargs)\\n elif self._num_parameters == 2 and self.plottype != \\\"corner\\\":\\n fig = self._2d_plot_samples(**kwargs)\\n else:\\n fig = self._nd_plot_samples(**kwargs)\\n\\n # restore keywords\\n kwargs = origkwargs\\n\\n if len(self._grids) > 0:\\n kwargs[\\\"colors\\\"] = list(colordicts[1].values())\\n if fig is not None and \\\"fig\\\" not in kwargs:\\n kwargs[\\\"fig\\\"] = fig\\n if self._num_parameters == 1:\\n fig = self._1d_plot_grid(**kwargs)\\n elif self._num_parameters == 2 and self.plottype != \\\"corner\\\":\\n fig = self._2d_plot_grid(**kwargs)\\n else:\\n fig = self._nd_plot_grid(**kwargs)\\n\\n # add further figure information\\n if self._num_parameters == 1:\\n ax = fig.gca()\\n\\n # set figure bounds if outside defaults\\n if self.parameters[0] in DEFAULT_BOUNDS:\\n _set_axes_limits(ax, self.parameters[0], axis=\\\"x\\\")\\n\\n # add injection values\\n if self.injection_parameters is not None:\\n if self.injection_parameters[self.parameters[0]] is not None:\\n ax.axvline(\\n (\\n self.injection_parameters[self.parameters[0]]\\n - self.parameter_offsets[self.parameters[0]]\\n ),\\n color=kwargs.get(\\\"injection_color\\\", \\\"k\\\"),\\n linewidth=1,\\n )\\n elif self._num_parameters == 2:\\n if \\\"triangle\\\" in self.plottype:\\n a1, a2, a3 = fig[1:]\\n order = [\\\"x\\\", \\\"y\\\"] if self.plottype == \\\"triangle\\\" else [\\\"y\\\", \\\"x\\\"]\\n params = (\\n self.parameters[:2]\\n if self.plottype == \\\"triangle\\\"\\n else self.parameters[1::-1]\\n )\\n\\n # set figure bounds if outside defaults\\n for param, axes, axis in zip(params, [[a1, a2], [a2, a3]], order):\\n for ax in axes:\\n _set_axes_limits(ax, param, axis=axis)\\n\\n self.fig = fig\\n return self.fig\",\n \"def plot_evaluation(values, info, measures = ['Dice','Jaccard', 'TPR', 'TNR', '1-GCE', 'VS', 'RI', 'ARI', 'MI', '1-VOI', 'ICC','1/(1+PBD)', 'KAP', 'AUC', '1/(1+HD)', '1/(1+AVD)', 'MHD' ], colourmap=None, outfile='polar_results.png'):\\n _min = info['minimum']\\n _max = info['maximum']\\n if colourmap is None:\\n colourmap = [[86./255.,180./255.,233./255.] for ii in range(values.shape[0])]\\n else:\\n # normalize colourmap values between 0 and 1\\n colourmap = (colourmap-_min)/(_max-_min)\\n # apply cividis, returns the RBG1 values for cividis, for dots\\n colourmap = [[cm.cividis(ii)] for ii in colourmap] \\n\\n # elements of the circle\\n N = len(measures)\\n # evenly space measures around circle\\n x_as = [n / float(N) * 2 * pi for n in range(N)] \\n\\n # Set color of axes\\n plt.rc('axes', linewidth=0.5, edgecolor=\\\"#888888\\\")\\n\\n # Create polar plot\\n fig = plt.figure(figsize = (11,9.5))\\n gs = gridspec.GridSpec(1, 3, width_ratios=[17,2,1])\\n ax = plt.subplot(gs[0], polar=True)\\n \\n # Set position of y-labels\\n ax.set_rlabel_position(0)\\n\\n # Set color and linestyle of grid\\n ax.xaxis.grid(True, color=\\\"#888888\\\", linestyle='solid', linewidth=0.5)\\n ax.yaxis.grid(True, color=\\\"#888888\\\", linestyle='solid', linewidth=0.5)\\n\\n # Set yticks\\n plt.yticks([0.2, 0.4, 0.6, 0.8, 1.0], [\\\"0.2\\\", \\\"0.4\\\", \\\"0.6\\\", \\\"0.8\\\", \\\"1.0\\\"], fontsize=15)\\n pos=ax.get_rlabel_position()\\n ax.set_rlabel_position(pos+0.4*360./float(len(measures)))\\n\\n # Plot data\\n for ii in np.arange(values.shape[0]):\\n xx = np.asarray(x_as) + np.random.randn(len(x_as))*np.diff(x_as)[0]/15.\\n data_norm = None\\n if info['logplot']:\\n data_norm = matplotlib.colors.LogNorm(vmin=_min, vmax=_max)\\n sc = ax.scatter(xx, values[ii,:], 23, color=colourmap[ii]*len(xx), norm=data_norm, zorder=3) \\n\\n # Fill area\\n # close the circle\\n median = list(np.median(values, axis=0))\\n median += median[:1]\\n upper = list(np.percentile(values, 75, axis=0))\\n upper += upper[:1]\\n lower = list(np.percentile(values, 25, axis=0))\\n lower += lower[:1]\\n x_as += x_as[:1]\\n ax.plot(x_as, median, color=[86./255.,180./255.,233./255.], zorder=5)\\n ax.fill_between(x_as, upper, lower, zorder=4, color=[86./255.,180./255.,233./255.], alpha=0.3)\\n\\n # Set number of radial axes and remove labels\\n plt.xticks(x_as[:-1], [])\\n\\n # Set axes limits\\n plt.ylim(0, 1)\\n\\n # Draw ytick labels to make sure they fit properly\\n for i in range(N):\\n angle_rad = i / float(N) * 2 * pi-0.05\\n text_size = 21\\n if i in {3,8}:\\n ax.text(angle_rad, 1.15, measures[i]+\\\"\\\\n(m=%0.2f)\\\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\\\"center\\\")\\n elif i in {0}:\\n ax.text(angle_rad, 1.25, measures[i]+\\\"\\\\n(m=%0.2f)\\\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\\\"center\\\")\\n elif i in {1,5,7}:\\n ax.text(angle_rad, 1.29, measures[i]+\\\"\\\\n(m=%0.2f)\\\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\\\"center\\\")\\n elif i in {4}:\\n ax.text(angle_rad, 1.32, measures[i]+\\\"\\\\n(m=%0.2f)\\\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\\\"top\\\")\\n elif i in {10}:\\n ax.text(angle_rad, 1.26, measures[i]+\\\"\\\\n(m=%0.2f)\\\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\\\"center\\\")\\n elif i in {6}:\\n ax.text(angle_rad, 1.25, measures[i]+\\\"\\\\n(m=%0.2f)\\\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\\\"center\\\")\\n elif i in {9}:\\n ax.text(angle_rad, 1.18, measures[i]+\\\"\\\\n(m=%0.2f)\\\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\\\"center\\\")\\n else:\\n ax.text(angle_rad, 1.22, measures[i]+\\\"\\\\n(m=%0.2f)\\\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\\\"center\\\")\\n\\n # colorbar location on figure\\n cbaxes = plt.subplot(gs[2])\\n\\n # log scaling option\\n norm = None\\n if info['logplot']:\\n norm = matplotlib.colors.LogNorm(vmin=_min,vmax=_max)\\n\\n img = plt.imshow(np.array([[_min,_max]]), aspect='auto', cmap=\\\"cividis\\\", norm=norm)\\n img.set_visible(False)\\n\\n # initialize colorbar\\n cbar = plt.colorbar(cax = cbaxes)\\n\\n # ticks and label\\n c_values = cbar.get_ticks().tolist()\\n \\n ticklabels = [\\\"\\\" for ii in c_values]\\n if _min < np.min(c_values):\\n c_values = [_min] + c_values\\n ticklabels = [\\\"%0.1f %s\\\" %(np.min(c_values), info['unit'])] + ticklabels\\n else:\\n ticklabels[0] = \\\"%0.1f %s\\\" %(np.min(c_values), info['unit'])\\n\\n if _max > np.max(c_values):\\n c_values = c_values + [_max]\\n ticklabels = ticklabels + [\\\"%0.1f %s\\\" %(np.max(c_values), info['unit'])]\\n else:\\n ticklabels[-1] = \\\"%0.1f %s\\\" %(np.max(c_values), info['unit'])\\n \\n cbar.set_ticks(c_values)\\n cbar.set_ticklabels(ticklabels)\\n cbaxes.yaxis.set_minor_formatter(matplotlib.ticker.NullFormatter())\\n cbar.ax.set_ylabel(info[\\\"label\\\"], labelpad=-20)\\n \\n # font sizes for colorbar\\n cbar.ax.yaxis.label.set_size(19)\\n cbar.ax.tick_params(labelsize=14)\\n\\n # Save and show polar plot \\n plt.savefig(outfile)\\n if info['display']:\\n plt.show()\\n plt.clf()\\n plt.close('all')\",\n \"def walkplot(cons):\\n # Call always after cons.runn()!\\n if not hasattr(cons, \\\"outplot\\\"):\\n print(\\\"Consortium must run before analyzing the output of the run!\\\")\\n return\\n global plt\\n if not plt:\\n import matplotlib.pyplot as plt\\n\\n # keep original inputs\\n original_metplots = dcp(cons.mets_to_plot)\\n original_outplot = dcp(cons.outplot)\\n cons.outplot = \\\"tmp.png\\\"\\n mets = [k for k in cons.media]\\n # loop over metabolites, plot them and let the user close the window\\n for m in range(0, len(mets), 4):\\n cons.mets_to_plot = [mets[m], mets[m + 1], mets[m + 2], mets[m + 3]]\\n plot_comm(cons)\\n plt.show()\\n print(\\\"Image number\\\", m / 4)\\n\\n # clean temporary files, return to orginal parameters\\n plt.close(\\\"all\\\")\\n os.remove(cons.outplot)\\n cons.mets_to_plot = original_metplots\\n cons.outplot = original_outplot\\n return\",\n \"def app_SN_combined_moisture_gradient(self, dfs, phase_dirs, sizer_val, styler_val):\\n\\n print('Currently plotting plot_SN_combined_moisture_gradients')\\n\\n for df, direc in zip(dfs, phase_dirs):\\n self.plotter.plot_SN_combined_moisture_gradients(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['01_combined_plots'],\\n sizer=self.formatter.sizer[sizer_val]['3x1_partial_width'],\\n styler=self.formatter.styler[styler_val],\\n xscale=self.xscale_var.get()\\n )\\n\\n print('Done\\\\n')\",\n \"def app_SN_combined_series_moist_vs_temp(self, dfs, phase_dirs, sizer_val, styler_val):\\n\\n print('Currently plotting plot_SN_combined_series_moist_vs_temp')\\n\\n for df, direc in zip(dfs, phase_dirs):\\n # this iterates one or multiple times\\n self.plotter.plot_SN_combined_series_moist_vs_temp(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['08_time_series_moisture_vs_temperature'],\\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\\n styler=self.formatter.styler[styler_val],\\n )\\n self.plotter.plot_SN_combined_series_moist_vs_temp(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['08_time_series_moisture_vs_temperature'],\\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\\n styler=self.formatter.styler[styler_val],\\n xaxis_type='datetime',\\n )\\n self.plotter.plot_SN_combined_series_moist_vs_temp(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['08_time_series_moisture_vs_temperature'],\\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\\n styler=self.formatter.styler[styler_val],\\n normalized=True,\\n )\\n\\n print('Done\\\\n')\",\n \"def plot_reion_properties(rank, size, comm, reion_ini_files, gal_ini_files,\\n model_tags, reion_plots, output_dir, output_format):\\n\\n # Check to see if the output directory exists.\\n if rank == 0:\\n if not os.path.exists(output_dir):\\n os.makedirs(output_dir)\\n print(\\\"Made output directory {0}\\\".format(output_dir))\\n\\n MC_dir = \\\"{0}/MC\\\".format(output_dir)\\n os.makedirs(MC_dir)\\n print(\\\"Made directory {0}\\\".format(MC_dir))\\n\\n # First calculate all the properties and statistics we need.\\n reion_data = generate_data(rank, size, comm, reion_ini_files,\\n gal_ini_files, reion_plots, output_dir,\\n model_tags, output_format)\\n\\n # Gather all the fractions onto the master process.\\n # This will be used for many different plots. \\n master_mass_frac = collective.collect_hist_across_tasks(rank, comm, \\n reion_data[\\\"mass_frac_allmodels\\\"]) \\n master_mass_frac = comm.bcast(master_mass_frac, root = 0)\\n\\n # Then find out what we need and plot em!\\n if reion_plots[\\\"history\\\"] and rank == 0:\\n\\n \\n duration_z, duration_t, reion_completed = \\\\\\n calc_duration(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"],\\n master_mass_frac, reion_plots[\\\"duration_definition\\\"])\\n\\n for model_number in range(len(master_mass_frac)):\\n print(\\\"Model {0}: Start {1:.2f} \\\\tMid {2:.2f}\\\\tEnd {3:.2f}\\\\t\\\"\\n \\\"dz {4:.2f}\\\\tdt {5:.1f}Myr\\\\tReion Completed {6}\\\" \\\\\\n .format(model_number, duration_z[model_number][0],\\n duration_z[model_number][1], duration_z[model_number][-1],\\n duration_z[model_number][0]-duration_z[model_number][-1],\\n duration_t[model_number][-1]-duration_t[model_number][0],\\n reion_completed[model_number]))\\n\\n print(\\\"Plotting the reionization history.\\\")\\n reionplot.plot_history(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"t_bigbang_allmodels\\\"],\\n master_mass_frac,\\n model_tags, output_dir, \\\"history\\\",\\n output_format)\\n\\n\\n\\n if reion_plots[\\\"nion\\\"]:\\n\\n master_nion = collective.collect_hist_across_tasks(rank, comm, \\n reion_data[\\\"nion_allmodels\\\"])\\n\\n if rank == 0:\\n print(\\\"Plotting the ionizing emissivity.\\\")\\n reionplot.plot_nion(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"t_bigbang_allmodels\\\"],\\n master_nion,\\n reion_data[\\\"nion_factor_allmodels\\\"], \\n model_tags, output_dir, \\\"nion\\\", output_format)\\n\\n if reion_plots[\\\"ps_fixed_XHI\\\"]:\\n k, P21, PHII = determine_ps_fixed_XHI(rank, size, comm,\\n reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n master_mass_frac, \\n reion_data[\\\"XHII_fbase_allmodels\\\"],\\n reion_data[\\\"XHII_precision_allmodels\\\"],\\n reion_data[\\\"density_fbase_allmodels\\\"],\\n reion_data[\\\"density_precision_allmodels\\\"],\\n reion_data[\\\"GridSize_allmodels\\\"],\\n reion_data[\\\"boxsize_allmodels\\\"],\\n reion_data[\\\"first_snap_allmodels\\\"],\\n reion_plots[\\\"fixed_XHI_values\\\"])\\n\\n if rank == 0:\\n print(\\\"Plotting PS at fixed neutral fraction.\\\")\\n reionplot.plot_ps_fixed_XHI(k, P21, PHII,\\n reion_plots[\\\"fixed_XHI_values\\\"],\\n model_tags, output_dir, \\\"ps_fixed_XHI\\\",\\n output_format)\\n\\n if reion_plots[\\\"contours\\\"] and rank == 0:\\n # tau is used for multiple plots. So check if we need to calculate it.\\n try:\\n tau_allmodels\\n except NameError:\\n tau_allmodels = calc_tau(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"helium_allmodels\\\"],\\n master_mass_frac)\\n\\n # For the contours, only plot the optical depth at the highest z.\\n tau_highz = []\\n for model_number in range(len(tau_allmodels)):\\n tau_highz.append(tau_allmodels[model_number][0])\\n\\n duration_z, duration_t, reion_completed = \\\\\\n calc_duration(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"],\\n master_mass_frac, reion_plots[\\\"duration_definition\\\"])\\n\\n print(\\\"Plotting contours of constant tau.\\\")\\n reionplot.plot_tau_contours(tau_highz, reion_completed,\\n reion_plots[\\\"alpha_beta_limits\\\"],\\n output_dir, \\\"tau_contours\\\", output_format)\\n\\n print(\\\"Plotting contours of constant reionization duration.\\\")\\n reionplot.plot_duration_contours(duration_t, reion_completed,\\n reion_plots[\\\"alpha_beta_limits\\\"],\\n output_dir, \\\"duration_contours\\\",\\n output_format)\\n\\n if reion_plots[\\\"optical_depth\\\"] and rank == 0:\\n # tau is used for multiple plots. So check if we need to calculate it.\\n try:\\n tau_allmodels\\n except NameError:\\n tau_allmodels = calc_tau(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"helium_allmodels\\\"],\\n master_mass_frac)\\n\\n print(\\\"Plotting the optical depth.\\\")\\n reionplot.plot_tau(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"], \\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"t_bigbang_allmodels\\\"],\\n tau_allmodels,\\n model_tags, output_dir, \\\"optical_depth\\\",\\n output_format)\\n\\n if reion_plots[\\\"optical_depth\\\"] and reion_plots[\\\"history\\\"] and rank == 0:\\n print(\\\"Plotting the combined optical depth/ionization history.\\\")\\n reionplot.plot_combined_history_tau(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"], \\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"t_bigbang_allmodels\\\"],\\n master_mass_frac, tau_allmodels, \\n model_tags, output_dir,\\n \\\"history_tau\\\", output_format)\\n\\n if reion_plots[\\\"optical_depth\\\"] and reion_plots[\\\"nion\\\"] and rank == 0:\\n print(\\\"Plotting the combined optical depth/ionizing emissivity.\\\")\\n reionplot.plot_combined_nion_tau(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"t_bigbang_allmodels\\\"],\\n master_nion,\\n reion_data[\\\"nion_factor_allmodels\\\"],\\n tau_allmodels, model_tags, output_dir,\\n \\\"nion_tau\\\", output_format)\\n\\n if reion_plots[\\\"ps_scales\\\"] or reion_plots[\\\"ps_scales_beta\\\"]:\\n print(\\\"Gathering the 21cm Power Spectra across processors\\\")\\n k, P21, PHII = gather_ps(rank, size, comm,\\n reion_data[\\\"k_allmodels\\\"],\\n reion_data[\\\"P21_allmodels\\\"],\\n reion_data[\\\"PHII_allmodels\\\"],\\n reion_data[\\\"first_snap_allmodels\\\"],\\n reion_data[\\\"last_snap_allmodels\\\"])\\n\\n if rank == 0:\\n print(\\\"Plotting the large scale power as a function of small \\\"\\n \\\"scale.\\\")\\n\\n if reion_plots[\\\"ps_scales_beta\\\"]:\\n calc_beta = True\\n else:\\n calc_beta = False \\n\\n # Now that we have all the PS on the master rank, calculate the\\n # amplitude at the specified scales.\\n scale_power_dict = calc_scale_power(k, P21, PHII,\\n reion_data[\\\"z_array_reion_allmodels\\\"], \\n reion_plots[\\\"small_scale_def\\\"],\\n reion_plots[\\\"large_scale_def\\\"],\\n reion_plots[\\\"small_scale_err\\\"],\\n reion_plots[\\\"large_scale_err\\\"],\\n calc_beta=calc_beta)\\n\\n k_small_scale = scale_power_dict[\\\"k_small_scale\\\"]\\n k_large_scale = scale_power_dict[\\\"k_large_scale\\\"]\\n\\n P21_small_scale = scale_power_dict[\\\"P21_small_scale\\\"]\\n P21_large_scale = scale_power_dict[\\\"P21_large_scale\\\"]\\n\\n PHII_small_scale = scale_power_dict[\\\"PHII_small_scale\\\"]\\n PHII_large_scale = scale_power_dict[\\\"PHII_large_scale\\\"]\\n\\n if reion_plots[\\\"ps_scales\\\"]:\\n reionplot.plot_ps_scales(P21_small_scale,\\n P21_large_scale, master_mass_frac, \\n reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_plots[\\\"fixed_XHI_values\\\"],\\n reion_plots[\\\"ps_scales_z\\\"],\\n reion_plots[\\\"small_scale_def\\\"],\\n reion_plots[\\\"large_scale_def\\\"],\\n reion_plots[\\\"small_scale_err\\\"],\\n reion_plots[\\\"large_scale_err\\\"],\\n model_tags, output_dir, \\\"ps_scales\\\",\\n output_format)\\n\\n if reion_plots[\\\"ps_scales_beta\\\"]:\\n\\n P21_beta = scale_power_dict[\\\"P21_beta\\\"]\\n P21_beta_error = scale_power_dict[\\\"P21_beta_error\\\"]\\n PHII_beta = scale_power_dict[\\\"PHII_beta\\\"]\\n\\n reionplot.plot_ps_beta(P21_beta, P21_beta_error,\\n reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"t_bigbang_allmodels\\\"],\\n reion_plots[\\\"small_scale_def\\\"],\\n reion_plots[\\\"large_scale_def\\\"],\\n model_tags, output_dir,\\n \\\"ps_scales_beta\\\", output_format)\\n\\n\\n\\n if reion_plots[\\\"slices_fixed_XHI\\\"] and rank == 0:\\n print(\\\"Plotting slices at fixed XHI fractions.\\\")\\n reionplot.plot_slices_XHI(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n master_mass_frac, \\n reion_data[\\\"XHII_fbase_allmodels\\\"],\\n reion_data[\\\"XHII_precision_allmodels\\\"],\\n reion_data[\\\"GridSize_allmodels\\\"],\\n reion_data[\\\"boxsize_allmodels\\\"],\\n reion_data[\\\"first_snap_allmodels\\\"],\\n reion_plots[\\\"fixed_XHI_values\\\"],\\n reion_plots[\\\"cut_slice\\\"],\\n reion_plots[\\\"cut_thickness\\\"],\\n model_tags, output_dir, \\\"slices_XHI\\\",\\n output_format)\\n\\n\\n if reion_plots[\\\"bubble_size\\\"] and rank == 0:\\n print(\\\"Determining bubble sizes at fixed XHI.\\\")\\n reionplot.determine_bubble_size(reion_data[\\\"z_array_reion_allmodels\\\"],\\n master_mass_frac,\\n reion_data[\\\"first_snap_allmodels\\\"],\\n reion_data[\\\"GridSize_allmodels\\\"],\\n reion_data[\\\"boxsize_allmodels\\\"],\\n reion_plots[\\\"fixed_XHI_values\\\"],\\n model_tags, output_dir)\\n\\n if reion_plots[\\\"zreion_dens_cross\\\"] and rank == 0:\\n print(\\\"Calculating the zreion-density cross correlation.\\\")\\n k, crosspspec, crosscorr, bias = \\\\\\n zreion_dens_cross(reion_data[\\\"density_fbase_allmodels\\\"],\\n reion_data[\\\"density_precision_allmodels\\\"],\\n reion_data[\\\"zreion_path_allmodels\\\"],\\n reion_data[\\\"GridSize_allmodels\\\"],\\n reion_data[\\\"boxsize_allmodels\\\"],\\n reion_data[\\\"last_snap_allmodels\\\"])\\n\\n reionplot.plot_zreion_dens_cross(k, crosscorr, bias, model_tags,\\n output_dir, \\\"zreion_dens_crosscorr\\\",\\n output_format)\\n\\n if reion_plots[\\\"dens_ion_contours\\\"] and rank == 0:\\n print(\\\"Plotting contours of density-ionization.\\\")\\n reionplot.plot_dens_reion_contours(master_mass_frac,\\n reion_data[\\\"XHII_fbase_allmodels\\\"],\\n reion_data[\\\"XHII_precision_allmodels\\\"],\\n reion_data[\\\"density_fbase_allmodels\\\"],\\n reion_data[\\\"density_precision_allmodels\\\"],\\n reion_data[\\\"GridSize_allmodels\\\"],\\n reion_data[\\\"first_snap_allmodels\\\"],\\n reion_plots[\\\"fixed_XHI_values\\\"],\\n model_tags, output_dir,\\n \\\"dens_ion_contours\\\", output_format)\\n\\n if reion_plots[\\\"dens_zreion_contours\\\"] and rank == 0:\\n print(\\\"Plotting contours of density-zreion.\\\")\\n reionplot.plot_dens_zreion_contours(reion_data[\\\"density_fbase_allmodels\\\"],\\n reion_data[\\\"density_precision_allmodels\\\"],\\n reion_data[\\\"zreion_path_allmodels\\\"],\\n reion_data[\\\"GridSize_allmodels\\\"],\\n reion_data[\\\"last_snap_allmodels\\\"],\\n model_tags, output_dir,\\n \\\"dens_zreion_contours\\\", output_format)\",\n \"def plot_uv(self):\\n self.current_plot = 'uv'\\n self.ax_zoomed = False\\n \\n uu = self.uv.d_uv_data['UU']*1e6\\n vv = self.uv.d_uv_data['VV']*1e6\\n xx = self.uv.d_array_geometry['STABXYZ'][:,0]\\n yy = self.uv.d_array_geometry['STABXYZ'][:,1]\\n pmax, pmin = np.max([uu, vv])*1.1, np.min([uu,vv])*1.1\\n\\n \\n fig = self.sp_fig\\n plt.subplot(121, aspect='equal')\\n ax = plt.plot(xx, yy, 'bo')\\n for i in range(len(xx)):\\n plt.text(xx[i], yy[i], self.uv.d_array_geometry['ANNAME'][i].strip('Stand').strip('Tile'))\\n\\n plt.title(\\\"Antenna positions\\\")\\n plt.xlabel(\\\"X [m]\\\")\\n plt.ylabel(\\\"Y [m]\\\")\\n \\n plt.subplot(122, aspect='equal')\\n ax = plt.plot(uu, vv, 'b.')\\n plt.title(\\\"UV data\\\")\\n plt.xlabel(\\\"UU [$\\\\\\\\mu s$]\\\")\\n plt.ylabel(\\\"VV [$\\\\\\\\mu s$]\\\")\\n plt.xlim(pmin, pmax)\\n plt.ylim(pmin, pmax)\\n return fig, ax\",\n \"def plot_lollipop(clinvar_path_count):\\n os.chdir(\\\"/Users/Files/nogit/generisk/lollipop/figure\\\")\\n app = '/Users/files/work/bin/lollipops'\\n for i in x.itertuples(False, None):\\n # uid, variants, gn\\n os.system(\\\"%s -domain-labels=fit -U %s -o %s.svg %s\\\" % (app, i[0], i[2], i[1]))\\n # os.system(\\\"rsvg-convert %s.svg -o %s_rsvg.png\\\"%(i[2],i[2]))\\n os.system(\\\"convert -density 500 -units pixelsperinch %s.svg %s.png\\\" % (i[2], i[2]))\",\n \"def plot_profiles(self, fig=0, title=''):\\n plot_input.plot_profiles(self, fig, title)\",\n \"def plot_dataset(\\n self,\\n out_dir: str = None,\\n therm_frac: int = 0.,\\n num_chains: int = None,\\n ridgeplots: bool = True,\\n profile: bool = False,\\n ):\\n tdict = {}\\n dataset = self.get_dataset(therm_frac)\\n for key, val in dataset.data_vars.items():\\n t0 = time.time()\\n if np.std(val.values.flatten()) < 1e-2:\\n continue\\n\\n if len(val.shape) == 2: # shape: (chain, draw)\\n val = val[:num_chains, :]\\n\\n if len(val.shape) == 3: # shape: (chain, leapfrogs, draw)\\n val = val[:num_chains, :, :]\\n\\n fig, ax = plt.subplots(constrained_layout=True, figsize=set_size())\\n _ = val.plot(ax=ax)\\n if out_dir is not None:\\n io.check_else_make_dir(out_dir)\\n out_file = os.path.join(out_dir, f'{key}_xrPlot.png')\\n fig.savefig(out_file, dpi=400, bbox_inches='tight')\\n plt.close('all')\\n plt.clf()\\n\\n if profile:\\n tdict[key] = time.time() - t0\\n io.log(f'time spent plotting {key}: {tdict[key]}')\\n\\n if out_dir is not None:\\n out_dir = os.path.join(out_dir, 'ridgeplots')\\n io.check_else_make_dir(out_dir)\\n\\n if ridgeplots:\\n make_ridgeplots(dataset, num_chains=num_chains, out_dir=out_dir)\\n\\n return tdict\",\n \"def plot_rose(ext_data, plot_label=None):\\n result = ext_data.copy(deep=False)\\n sectors = len(result)\\n fig = plt.figure(figsize=(12, 12))\\n ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=True)\\n ax.set_theta_zero_location('N')\\n ax.set_theta_direction(-1)\\n ax.set_thetagrids(np.arange(0, 360, 360.0/sectors))\\n sector_mid_points = []\\n widths = []\\n for i in result.index:\\n angular_pos_start = (np.pi / 180.0) * float(i.split('-')[0])\\n angular_pos_end = (np.pi / 180.0) * float(i.split('-')[-1])\\n if angular_pos_start < angular_pos_end:\\n sector_mid_points.append((angular_pos_start+angular_pos_end)/2.0)\\n widths.append(angular_pos_end-angular_pos_start - (np.pi / 180))\\n else:\\n sector_mid_points.append((np.pi + (angular_pos_start + angular_pos_end)/2.0) % 360)\\n widths.append(2*np.pi - angular_pos_start + angular_pos_end - (np.pi / 180))\\n max_contour = (ext_data.max() + ext_data.std())\\n contour_spacing = max_contour / 10\\n num_digits_to_round = 0\\n while contour_spacing*(10**num_digits_to_round) <= 1:\\n num_digits_to_round += 1\\n if 0.5 < contour_spacing < 1:\\n contour_spacing = 1\\n levels = np.arange(0, max_contour, round(contour_spacing, num_digits_to_round))\\n ax.set_rgrids(levels, labels=[str(i) for i in levels], angle=0)\\n ax.bar(sector_mid_points, result, width=widths, bottom=0.0, color=COLOR_PALETTE.primary,\\n edgecolor=[COLOR_PALETTE.primary_35 for i in range(len(result))], alpha=0.8)\\n ax.legend([plot_label])\\n plt.close()\\n return ax.get_figure()\",\n \"def plotBatch(inp,output='spectra_plot.pdf',comparisons=None,classify=False,normalize=False,normrange=[0.9,1.4],layout=[2,2],basecolors=['k','m'],legend=[],fontscale=0.7,classify_kwargs={},plot_kwargs={},**kwargs):\\n\\n# alt keyword check\\n for k in ['file','filename']: \\n if kwargs.get(k,'') != '': output = kwargs[k]\\n for k in ['legends','labels']: \\n if kwargs.get(k,'') != '': legend = kwargs[k]\\n\\n# force input into a list\\n if isinstance(inp,list): inputlist = copy.deepcopy(inp)\\n else: inputlist = [inp]\\n\\n# if input is a string of filenames, read in each file to a spectrum object\\n if isinstance(inputlist[0],str):\\n# try a glob search string \\n files = glob.glob(os.path.normpath(inputlist[0]))\\n if len(files) > 1 or (len(files) == 1 and inputlist[0].find('*') != -1):\\n inputlist = files\\n# try reading in files into Spectrum object\\n try:\\n splist = [splat.Spectrum(file = f) for f in inputlist]\\n except:\\n raise ValueError('\\\\nCould not read in list of files {} - make sure the full path is specified and the files are correctly formatted'.format(inputlist))\\n\\n# if filenames, read in each file to a spectrum object\\n elif isinstance(inputlist[0],splat.Spectrum):\\n splist = copy.deepcopy(inputlist)\\n else:\\n raise ValueError('\\\\nInput should be list of splat.Spectrum objects or filenames')\\n\\n# normalize if desired\\n if normalize==True:\\n tmp = [sp.normalize(normrange) for sp in splist]\\n\\n# comparison files are present\\n complist = []\\n if comparisons != None:\\n comp = copy.deepcopy(comparisons)\\n if not isinstance(comp,list): comp = [comp]\\n if isinstance(comp[0],str):\\n try:\\n complist = [splat.Spectrum(file = f) for f in comp]\\n except:\\n print('\\\\nCould not read in comparison files: ignoring comparisons')\\n if isinstance(comp[0],splat.Spectrum):\\n complist = comp\\n if len(complist) < len(splist):\\n while len(complist) < len(splist):\\n complist.append(complist[-1])\\n# normalize\\n if normalize==True:\\n tmp = [sp.normalize(normrange) for sp in complist]\\n\\n# set comparison files to be standards for spectral classification\\n# overrules input comparison sample\\n if classify == True:\\n complist = []\\n base_kwargs={\\n 'return_standard': True,\\n 'method': 'kirkpatrick',\\n }\\n base_kwargs.update(classify_kwargs)\\n for sp in splist:\\n complist.append(splat.classifyByStandard(sp,**base_kwargs))\\n\\n# prep for plotting\\n plotlist = []\\n clist = []\\n for i,sp in enumerate(splist):\\n if len(complist) == len(splist):\\n plotlist.append([sp,complist[i]])\\n clist.extend(basecolors)\\n else:\\n plotlist.append([sp])\\n clist.extend(basecolors[0])\\n\\n# manage legends\\n if len(legend) != 0:\\n if not isinstance(legend,list): legend = [legend]\\n if len(legend) < (len(splist)+len(complist)):\\n# guess: just left out the comparison legends \\n if len(complist) > 0 and len(legend) == len(splist):\\n legtmp = []\\n for i,l in enumerate(legend):\\n legtmp.extend([l,'{}'.format(complist[i].name)])\\n legend = legtmp\\n else:\\n# otherwise: pad the remaining legends with the last legend (pairs) \\n while len(legend) < (len(splist)+len(complist)):\\n if len(complist)>0:\\n legend.extend([legend[-2],legend[-1]])\\n else:\\n legend.extend([legend[-1]])\\n if len(legend) > (len(splist)+len(complist)):\\n legend = legend[0:(len(splist)+len(complist))]\\n else:\\n legend = []\\n for i,sp in enumerate(splist):\\n l = []\\n if 'name' in list(sp.__dict__.keys()): l.append(sp.name)\\n else: l.append(os.path.basename(sp.filename))\\n if len(complist)>0:\\n if 'name' in list(complist[i].__dict__.keys()): l.append(complist[i].name)\\n else: l.append(os.path.basename(complist[i].filename))\\n legend.extend(l)\\n\\n# generate plot\\n base_kwargs={\\n 'multiplot': True,\\n 'multipage': True,\\n 'legends': legend,\\n 'colors': clist,\\n 'layout': layout,\\n 'fontscale': fontscale,\\n 'output': output,\\n }\\n base_kwargs.update(plot_kwargs)\\n fig = plotSpectrum(plotlist,**base_kwargs)\\n\\n return fig\",\n \"def multiple(folder_name: str,\\r\\n min_plant_pixels: int = MIN_PLANT_SIZE,\\r\\n output_options = [['rows',\\r\\n 'centers',\\r\\n 'row_ids',\\r\\n 'distances'],\\r\\n \\r\\n ['rows',\\r\\n 'centers',\\r\\n 'row_ids',\\r\\n 'numbers'],\\r\\n \\r\\n ['dirt',\\r\\n 'ditches',\\r\\n 'rows',\\r\\n 'clusters',\\r\\n 'centers',\\r\\n 'row_ids',\\r\\n 'numbers',\\r\\n 'lines']\\r\\n ]) -> None:\\r\\n\\r\\n # Go to the specified folder\\r\\n ls = listdir(folder_name)\\r\\n ls = [join(folder_name, i) for i in ls]\\r\\n\\r\\n # Check if the folder exists\\r\\n if join(folder_name, 'Analysis') in ls:\\r\\n\\r\\n # If it does, rename the old folder\\r\\n new_name = join(folder_name, 'Analysis')\\r\\n while new_name in ls:\\r\\n new_name += '_old'\\r\\n \\r\\n rename(join(folder_name,'Analysis'), new_name)\\r\\n\\r\\n # Create new folders inside the given directory\\r\\n mkdir(join(folder_name, 'Analysis'))\\r\\n mkdir(join(folder_name, 'Analysis/Images'))\\r\\n mkdir(join(folder_name, 'Analysis/Data'))\\r\\n \\r\\n # Gather the images to be analysed\\r\\n co = 0\\r\\n pics = [j for j in ls if isfile(j)]\\r\\n le = len(pics)\\r\\n\\r\\n # Analyze each of the pictures\\r\\n for i in pics:\\r\\n\\r\\n # Make the field\\r\\n field = just_field(i, min_plant_pixels)\\r\\n\\r\\n # Measure the field and save results\\r\\n print('Saving data...\\\\n')\\r\\n ruler = Ruler(field)\\r\\n \\r\\n ruler.output_distances(\\r\\n join(folder_name,\\r\\n 'Analysis/Data/{}_Distances.csv'.format(basename(i).split('.')[0])\\r\\n ) \\r\\n )\\r\\n \\r\\n ruler.output_row_info(\\r\\n join(folder_name,\\r\\n 'Analysis/Data/{}_Rows.csv'.format(basename(i).split('.')[0])\\r\\n )\\r\\n )\\r\\n\\r\\n # Make and save visuals\\r\\n print('Saving pictures...\\\\n')\\r\\n for k in range(len(output_options)):\\r\\n output_options[k]\\r\\n img = field.make_visual(ruler, output_options[k])\\r\\n img.save(\\r\\n join(folder_name,\\r\\n 'Analysis/Images/{}_Visual_{}.png'.format(basename(i).split('.')[0], k + 1)))\\r\\n\\r\\n # Increment the progress meter\\r\\n co += 1\\r\\n print('Completed {}/{} images\\\\n\\\\n'.format(co, le))\",\n \"def main(fpath):\\n\\t# Load results data\\n\\twith open(fpath) as f:\\n\\t\\tlines = f.readlines()\\n\\n\\tresults = []\\n\\tfor line in lines:\\n\\t\\tif not line.startswith(\\\"//\\\"):\\n\\t\\t\\tresults.append(json.loads(line))\\n\\n\\t# Format relevent data\\n\\tresults = sorted(results, key=lambda k: k['data_lens'][\\\"mean\\\"])\\n\\t# x = [np.log(x[\\\"block_lens\\\"][\\\"mean\\\"]) for x in results]\\n\\tx = [x[\\\"data_lens\\\"][\\\"mean\\\"] for x in results]\\n\\ty = [x[\\\"mean\\\"] for x in results]\\n\\tyy = [x[\\\"block_lens\\\"][\\\"mean\\\"] for x in results]\\n\\n\\n\\t# Plot graphs\\n\\tplt.figure(figsize=(14,5))\\n\\tplt.subplot(1,2,1)\\n\\tplt.title('Ratio of Total Block Size to Primary Data Size Against Primary Data Size')\\n\\tplt.ylabel('Total Block Size / Primary Data Size')\\n\\t# plt.xlabel('log( Primary Data Size )')\\n\\tplt.xlabel('Primary Data Size (chars)')\\n\\tplt.plot(x, y)\\n\\n\\tplt.subplot(1,2,2)\\n\\tplt.title('Total Block Size Against Primary Data Size')\\n\\tplt.ylabel('Total Block Size (chars)')\\n\\tplt.xlabel('Primary Data Size (chars)')\\n\\tplt.plot(x, yy)\\n\\n\\n\\tplt.show()\",\n \"def plot_sector_ratio(sec_ratio, wdir, sec_ratio_dist, col_names, boom_dir_1=-1, boom_dir_2=-1):\\n radians = np.radians(utils._get_dir_sector_mid_pts(sec_ratio_dist.index))\\n fig = plt.figure(figsize=(10, 10))\\n ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=True)\\n ax.set_theta_zero_location('N')\\n ax.set_theta_direction(-1)\\n ax.set_thetagrids(utils._get_dir_sector_mid_pts(sec_ratio_dist.index))\\n ax.plot(np.append(radians, radians[0]), sec_ratio_dist['Mean_Sector_Ratio'].append(sec_ratio_dist.iloc[0]),\\n color=COLOR_PALETTE.primary, linewidth=4)\\n # Get max and min levels and set chart axes\\n max_level = sec_ratio_dist['Mean_Sector_Ratio'].max() + 0.05\\n min_level = sec_ratio_dist['Mean_Sector_Ratio'].min() - 0.1\\n ax.set_ylim(min_level, max_level)\\n # Add boom dimensions to chart, if required\\n width = np.pi / 108\\n radii = max_level\\n annotate = False\\n annotation_text = '* Plot generated using '\\n if boom_dir_1 >= 0:\\n boom_dir_1_rad = np.radians(boom_dir_1)\\n ax.bar(boom_dir_1_rad, radii, width=width, bottom=min_level, color=COLOR_PALETTE.fourth)\\n if boom_dir_2 == -1:\\n annotation_text += '{} (top mounted) divided by {} ({}° boom)'.format(col_names[1], col_names[0],\\n boom_dir_1)\\n annotate = True\\n if boom_dir_2 >= 0:\\n boom_dir_2_rad = np.radians(boom_dir_2)\\n ax.bar(boom_dir_2_rad, radii, width=width, bottom=min_level, color=COLOR_PALETTE.fifth)\\n if boom_dir_1 == -1:\\n annotation_text += '{} ({}° boom) divided by {} (top mounted)'.format(col_names[1], boom_dir_2,\\n col_names[0])\\n annotate = True\\n if boom_dir_2 >= 0 and boom_dir_1 >= 0:\\n annotation_text += '{} ({}° boom) divided by {} ({}° boom)'.format(col_names[1], boom_dir_2,\\n col_names[0], boom_dir_1)\\n annotate = True\\n if annotate:\\n ax.annotate(annotation_text, xy=(0.5, 0.035), xycoords='figure fraction', horizontalalignment='center')\\n ax.scatter(np.radians(wdir), sec_ratio, color=COLOR_PALETTE.secondary, alpha=0.3, s=1)\\n plt.close()\\n return ax.get_figure()\",\n \"def run_and_plot(self):\\n self.raw_processing()\\n self.data_averaging_and_cleaning()\\n\\n print(self.organized_names)\\n print(self.organized_film)\\n print(self.organized_plank)\\n\\n height = self.organized_film\\n bars = tuple(self.organized_names.copy())\\n y_pos = np.arange(len(bars))\\n\\n plt.bar(y_pos, height)\\n plt.xticks(y_pos, bars)\\n plt.xlabel('TH% in 100ul water/TH mixture')\\n plt.ylabel('CFU/mL count')\\n plt.title('Experiment 2.5 (Sucrose Concentration) 7 Aug 2018')\\n\\n plt.show()\\n\\n height2 = self.organized_plank\\n\\n plt.bar(y_pos, height2)\\n plt.xticks(y_pos, bars)\\n plt.xlabel('TH% in 100ul water/TH mixture')\\n plt.ylabel('Proportion of Biofilm CFUs to Planktonic CFUs')\\n plt.title('Experiment 2.5 (Sucrose Concentration) 7 Aug 2018')\\n\\n plt.show()\",\n \"def plot_data(\\n self,\\n out_dir: str = None,\\n flags: AttrDict = None,\\n therm_frac: float = 0.,\\n params: AttrDict = None,\\n ):\\n plot_data(self.data, out_dir, flags,\\n therm_frac=therm_frac, params=params)\",\n \"def main():\\n font = {'family' : 'normal',\\n 'weight' : 'normal',\\n 'size' : 18}\\n\\n matplotlib.rc('font', **font)\\n\\n ###Plot overviews\\n\\n# plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\\\"12co_combined_peak_full.png\\\",\\n# show_shells=False,title=r\\\"Combined $^{12}$CO Peak T$_{MB}$\\\",\\n# dist=orion_dist, vmin=None, vmax=None, scalebar_color='white',\\n# scalebar_pc=1.,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325)\\n \\n plot_overview(plotname=\\\"../paper/figs/12co_nroonly_peak_full_shells.png\\\", show_shells=True,\\n dist=orion_dist, vmin=None, vmax=None, scalebar_color='black', scale_factor = 1.,\\n title=r\\\"\\\", shells_highlight=best_shells, circle_style='dotted', circle_linewidth=1.5,\\n scalebar_pc=1. #,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325\\n )\\n\\n # plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\\\"12co_combined_mom0_cometary.png\\\",\\n # show_shells=False, title=r\\\"Combined Integrated $^{12}$CO\\\",\\n # dist=orion_dist, scalebar_color='white', pmax=93., mode='mom0',\\n # scale_factor=1./1000,\\n # scalebar_pc=0.2,recenter=True, ra=83.99191, dec=-5.6611303, radius=0.117325)\\n\\n # plot_overview(plotname=\\\"12co_nroonly_mom0_cometary.png\\\", show_shells=False,\\n # dist=orion_dist, scalebar_color='white', pmax=93., mode='mom0',\\n # scale_factor=1./1000, title=r\\\"NRO Integrated $^{12}$CO\\\",\\n # scalebar_pc=0.2,recenter=True, ra=83.99191, dec=-5.6611303, radius=0.117325)\\n\\n # plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\\\"12co_combined_peak_full_shells.png\\\",\\n # show_shells=True, shells_highlight=shells_score3, title=r\\\"Combined $^{12}$CO Peak T$_{MB}$\\\",\\n # dist=orion_dist, vmin=None, vmax=None, scalebar_color='white', circle_style='dotted',\\n # scalebar_pc=1.,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325)\\n\\n # return\\n\\n mips_l1641_file = '../catalogs/MIPS_L1641a_24um.fits'\\n mips_onc_file = '../catalogs/MIPS_ONC_24um.fits'\\n\\n irac1_l1641_file = '../catalogs/IRAC_L1641_ch1_merged_clean.fits'\\n irac1_onc_file = '../catalogs/IRAC_ONC_ch1_merged_clean.fits'\\n\\n irac2_l1641_file = '../catalogs/IRAC_L1641_ch2_merged_clean.fits'\\n irac2_onc_file = '../catalogs/IRAC_ONC_ch2_merged_clean.fits'\\n\\n irac4_l1641_file = '../catalogs/IRAC_L1641_ch4_merged_clean_northup.fits'\\n irac4_onc_file = '../catalogs/IRAC_ONC_ch4_merged_clean_northup.fits'\\n\\n planck_herschel_file = '../catalogs/planck_herschel.fits'\\n\\n region_file = '../shell_candidates/AllShells.reg'\\n vrange_file = '../shell_candidates/AllShells_vrange.txt'\\n shell_list = get_shells(region_file=region_file, velocity_file=vrange_file)\\n\\n obaf_file = 'stars_obaf.txt'\\n yso_file = \\\"../catalogs/spitzer_orion.fit\\\"\\n\\n obaf = ascii.read(obaf_file)\\n obaf_ra, obaf_dec, obaf_label = np.array(obaf['RA']), np.array(obaf['DEC']), np.array([sp.strip(\\\"b'\\\") for sp in obaf['SP_TYPE']])\\n yso = fits.open(yso_file)[1].data\\n yso_ra, yso_dec, yso_label = yso['RAJ2000'], yso['DEJ2000'], yso['Cl']\\n\\n # for nshell in range(19,43):\\n # shell = shell_list[nshell-1]\\n # ra, dec, radius = shell.ra.value, shell.dec.value, shell.radius.value\\n\\n # #Check whether shell is in each mips image coverage.\\n # l1641_xy = WCS(mips_l1641_hdu).all_world2pix(ra, dec, 0)\\n \\n # if (l1641_xy[0] >= 0) & (l1641_xy[0] <= mips_l1641_hdu.shape[1]) & \\\\\\n # (l1641_xy[1] >= 0) & (l1641_xy[1] <= mips_l1641_hdu.shape[0]):\\n # hdu = mips_l1641_hdu\\n # else:\\n # hdu = mips_onc_hdu\\n\\n # plot_stamp(map=hdu, ra=ra, dec=dec, radius=radius, circle_color='red',\\n # pad_factor=1.5, contour_map=None, contour_levels=5., source_ra=None, source_dec=None, source_lists=None, \\n # source_colors='cyan', plotname='{}shell{}_stamp.png'.format('MIPS',nshell), return_fig=False,\\n # stretch='linear', plot_simbad_sources=False, dist=orion_dist, cbar_label=r'counts',\\n # auto_scale=True, auto_scale_mode='min/max', auto_scale_pad_factor=1., vmin=0, vmax=3000)\\n\\n\\n #cube_file = '../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits'\\n cube_file = '../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits'\\n ir_l1641_hdu = fits.open(irac4_l1641_file)[0]\\n ir_onc_hdu = fits.open(irac4_onc_file)[0]\\n\\n spec_cube = SpectralCube.read(cube_file)\\n ra_grid = spec_cube.spatial_coordinate_map[1].to(u.deg).value\\n dec_grid = spec_cube.spatial_coordinate_map[0].to(u.deg).value\\n vel_grid = spec_cube.spectral_axis\\n pad_factor = 1.5\\n\\n #plot_overview(show_shells=True)\\n #plot_overview(plotname=\\\"12co_nro_peak.png\\\", show_shells=False)\\n #plot_overview(cube=\\\"/Volumes/Untitled/13co_pix_2.cm.fits\\\", plotname=\\\"13co_combined_peak.png\\\", show_shells=False)\\n #return\\n #channel_vmax = [12.9, 14]\\n for nshell in range(17,18):\\n shell = shell_list[nshell-1]\\n ra, dec, radius = shell.ra.value, shell.dec.value, shell.radius.value\\n\\n l1641_xy = WCS(ir_l1641_hdu).wcs_world2pix(ra, dec, 0)\\n #print(l1641_xy)\\n if (l1641_xy[0] >= 0) & (l1641_xy[0] <= ir_l1641_hdu.shape[1]) & \\\\\\n (l1641_xy[1] >= 0) & (l1641_xy[1] <= ir_l1641_hdu.shape[0]):\\n ir_hdu = ir_l1641_hdu\\n else:\\n ir_hdu = ir_onc_hdu\\n\\n #Extract sub_cube around shell.\\n subcube_mask = (abs(ra_grid - ra) < radius * pad_factor) &\\\\\\n (abs(dec_grid - dec) < radius * pad_factor)\\n sub_cube = spec_cube.with_mask(subcube_mask).minimal_subcube().spectral_slab(shell.vmin, shell.vmax)\\n\\n #Integrate between vmin and vmax.\\n mom0_hdu = sub_cube.moment0().hdu\\n\\n # mask_inshell = (abs(ra_grid - ra) < radius) &\\\\\\n # (abs(dec_grid - dec) < radius)\\n # subcube_inshell = spec_cube.with_mask(mask_inshell).minimal_subcube().spectral_slab(shell.vmin, shell.vmax)\\n # mom0_hdu_inshell = subcube_inshell.moment0().hdu\\n\\n #Calculate contour levels.\\n empty_channel = spec_cube.closest_spectral_channel(500*u.Unit('m/s'))\\n sigma = np.nanstd(spec_cube[empty_channel][subcube_mask]).value\\n #print(\\\"sigma: {}\\\".format(sigma))\\n delta_vel = (sub_cube.spectral_extrema[1] - sub_cube.spectral_extrema[0]).value\\n #print(\\\"delta_vel: {}\\\".format(delta_vel))\\n mom0_sigma = sigma * delta_vel\\n #print(mom0_sigma) \\n #contour_levels = np.linspace(5.*mom0_sigma, np.nanmax(mom0_hdu_inshell.data), 12)\\n contour_levels = np.linspace(28.*mom0_sigma, 45.*mom0_sigma, 6 )\\n\\n #Get source coordinates.\\n\\n\\n # plot_stamp(map=ir_hdu, ra=ra, dec=dec, radius=radius, circle_color='red',\\n # pad_factor=pad_factor, contour_map=mom0_hdu, contour_levels=contour_levels, contour_color='white',\\n # plotname='{}shell{}_{}{}to{}_stamp.png'.format('8µm', nshell, \\\"12CO\\\", shell.vmin.value, shell.vmax.value),\\n # return_fig=False,\\n # stretch='linear', plot_simbad_sources=False, dist=orion_dist,\\n # auto_scale=True, auto_scale_mode='median', auto_scale_pad_factor=0.8, auto_scale_nsigma=4.,\\n # cbar_label=\\\"Counts\\\", cmap='inferno',\\n # source_ra=[obaf_ra, yso_ra], source_dec=[obaf_dec, yso_dec],\\n # source_colors=['white', 'red'], source_markers=['*', 'None'], source_sizes=[300,50],\\n # source_labels=[obaf_label, yso_label], dpi=300\\n # )\\n\\n #cube_file = \\\"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\\\"\\n \\n \\n # plot_channels(cube=cube_file, ra=ra, dec=dec, radius=radius,\\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\\n # plotname='12co_channels_shell'+str(nshell)+'.png', chan_step=2, plot_simbad_sources=False,\\n # vmin=None, vmax=None, max_chans=12,\\n # #cbar_label=\\\"Counts\\\",\\n # source_ra=[obaf_ra, yso_ra], source_dec=[obaf_dec, yso_dec],\\n # source_colors=['white', 'red'], source_markers=['*', '+'], source_sizes=[200,15], dpi=300)\\n\\n # angle = 90*u.deg\\n # pv = plot_pv(cube=cube_file, ra_center=shell.ra, dec_center=shell.dec,\\n # vel=[shell.vmin - 1*u.km/u.s, shell.vmax + 1*u.km/u.s], length=shell.radius*4.,\\n # width=7.5*u.arcsec, angle=angle,\\n # pad_factor=1., plotname='12co_pv_shell'+str(nshell)+'_angle'+str(angle.value)+'.png',\\n # stretch='linear', auto_scale=True, dpi=900.)\\n \\n\\n\\n #simbad_brightstars(output='stars_obaf.txt', output_format='ascii', replace_ra='deg')\\n\\n\\n #movie(test=False, labels=False) \\n\\n #cube_file = '../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits'\\n # region_file = '../nro_maps/SouthShells.reg'\\n # N = 2 # Number of shell candidates to plot\\n # shell_list = get_shells(region_file=region_file)\\n\\n # cube_file = \\\"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\\\"\\n # #cube_file = \\\"../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits\\\"\\n\\n # for n in range(1,2):\\n # shell = shell_list[n]\\n # for deg in np.linspace(0, 180, 13):\\n # angle = deg*u.deg\\n # pv = plot_pv(cube=cube_file, ra_center=shell.ra, dec_center=shell.dec,\\n # vel=[4*u.km/u.s, 8*u.km/u.s], length=shell.radius*2.*4.,\\n # width=7.5*u.arcsec, angle=105*u.deg,\\n # pad_factor=1., plotname='12co_pv_shell'+str(n+1)+'_angle'+str(angle.value)+'morev.png', return_subplot=True,\\n # stretch='linear', auto_scale=True)\\n\\n # cube_file = \\\"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\\\"\\n # for n in range(N):\\n # shell = shell_list[n]\\n # plot_channels(cube=cube_file, ra=shell.ra.value, dec=shell.dec.value, radius=shell.radius.value,\\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\\n # plotname='12co_channels_shell'+str(n+1)+'.png', chan_step=2, plot_simbad_sources=True, simbad_color='blue')\\n\\n # cube_file = \\\"../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits\\\"\\n # for n in range(N):\\n # shell = shell_list[n]\\n # plot_channels(cube=cube_file, ra=shell.ra.value, dec=shell.dec.value, radius=shell.radius.value,\\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\\n # plotname='13co_channels_shell'+str(n+1)+'.png', chan_step=2, plot_simbad_sources=True, simbad_color='blue')\",\n \"def cloudy_hii_radial_hyd(props=['ne'],cols=['b'],model_name = '',**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n if p.add:\\n ax = plt.gca()\\n else:\\n fig,ax = plt.subplots(figsize=(8,6))\\n\\n for prop,col in zip(props,cols):\\n hyd = pd.read_table(p.d_cloudy_test + '%s.hyd' % model_name,skiprows=1,\\\\\\n names=['depth','Te','nH','ne','HI/H','HII/H','H2/H','H2+/H','H3+/H','H-/H'])\\n if '/' in prop:\\n try:\\n ax2.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'o',ms=5,color=col)\\n ax2.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'-',lw=1,color=col,label=prop)\\n except:\\n print('no twinx axis, starting a new one')\\n ax2 = ax.twinx()\\n ax2.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'o',ms=5,color=col)\\n ax2.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'-',lw=1,color=col,label=prop)\\n else:\\n ax.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'o',ms=5,color=col)\\n ax.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'-',lw=1,color=col,label=prop)\\n\\n ax.set_xlabel('Depth [pc]')\\n ax.set_ylabel('cm$^{-3}$')\\n ax.legend()\\n ax2.legend()\\n\\n if p.savefig:\\n if not os.path.isdir(p.d_plot + 'cloudy/'): os.mkdir(p.d_plot + 'cloudy/') \\n plt.savefig(p.d_plot + 'cloudy/%s_hyd.png' % (model_name), format='png', dpi=300, facecolor='w')\",\n \"def plot_alleles(folder):\\n\\n abs_alt,perc_alt = parse_geno_file(folder,False)\\n\\n strain_matcher = re.compile('(.*) \\\\(.*\\\\)') ## regex to get strain name from radio button click\\n strain_matcher2 = re.compile('(.*)-(.*)')\\n \\n fig, ax = plt.subplots()\\n l, = plt.plot(perc_alt['MC'],perc_alt[S],'bs')\\n ax.set_ylabel('Alternate Allele Percentage (MC)')\\n ax.set_xlabel('Alternate Allele Percentage (MC)')\\n \\n rax1 = plt.axes([0.92, 0.1, 0.08, 0.8])\\n radio1 = RadioButtons(rax1, ('MC (Sand)','CL (Sand)','CM (Sand)','CN (Sand)','TI (Sand)','DC (Sand)','MS (Sand)','CV (Sand)','PN (Rock)','AC (Rock)','LF (Rock)','MP (Rock)','MZ (Rock)','Sand-MC','Rock-MC','Sand-MZ','Rock-MZ','Rock-Sand'), active=0)\\n\\n rax2 = plt.axes([0.92, 0.9, 0.08, 0.1])\\n radio2 = RadioButtons(rax2, ('%', 'Abs'), active=0)\\n\\n #for strain in perc_alt.keys():\\n #print strain\\n \\n #ylabel = plt.axes([1,1,0.08,0.08])\\n\\n def update1(strain):\\n if strain not in [\\\"Rock-MZ\\\",\\\"Sand-MC\\\",\\\"Rock-MC\\\",\\\"Sand-MZ\\\",\\\"Rock-Sand\\\"]:\\n match = re.match(strain_matcher,strain)\\n strain = match.group(1)\\n global base\\n base = 'MC'\\n else:\\n match = re.match(strain_matcher2,strain)\\n strain = match.group(1)\\n #global base \\n base = match.group(2)\\n\\n #print D\\n if(D == \\\"%\\\"):\\n l.set_xdata(perc_alt[base])\\n l.set_ydata(perc_alt[strain])\\n ax.set_ylabel('Alternate Allele Percentage (%s)'%(strain))\\n ax.set_xlabel('Alternate Allele Percentage (%s)'%(base))\\n else:\\n l.set_xdata(abs_alt[base])\\n l.set_ydata(abs_alt[strain])\\n ax.set_ylabel('Alternate Allele Absolute (%s)'%(strain))\\n ax.set_xlabel('Alternate Allele Absolute (%s)'%(base))\\n\\n ax.relim()\\n ax.autoscale()\\n fig.canvas.draw_idle()\\n global S \\n #print S\\n S = strain\\n\\n\\n def update2(data):\\n if(data == '%'):\\n l.set_xdata(perc_alt[base])\\n l.set_ydata(perc_alt[S])\\n ax.relim()\\n ax.autoscale()\\n ax.set_ylabel('Alternate Allele Percentage (%s)'%(S))\\n ax.set_xlabel('Alternate Allele Percentage (%s)'%(base))\\n fig.canvas.draw_idle()\\n if(data == 'Abs'):\\n l.set_xdata(abs_alt[base])\\n l.set_ydata(abs_alt[S])\\n ax.relim()\\n ax.autoscale()\\n ax.set_ylabel('Alternate Allele Absolute (%s)'%(S))\\n ax.set_xlabel('Alternate Allele Absolute (%s)'%(base))\\n fig.canvas.draw_idle()\\n \\n global D\\n D = data\\n\\n radio1.on_clicked(update1)\\n radio2.on_clicked(update2)\\n plt.show()\",\n \"def createPrettyPlots(self, inputDir, outputDir, fnExtension = 'png'):\\n number_of_entries_per_row = 4\\n number_of_files_per_column = 2\\n imageWidth = 200 # 1600 org is four times as large\\n imageHeight = 150 # 1200\\n nTmessage(\\\"Updating index files for input directory: %s\\\" % inputDir)\\n if os.path.exists(outputDir):\\n# nTmessage(\\\"Removing output directory: %s\\\" % outputDir)\\n shutil.rmtree(outputDir)\\n # end if\\n# nTmessage(\\\"Creating output directory: %s\\\" % outputDir)\\n os.mkdir(outputDir)\\n# nTdebug(\\\"Doing copyCingHtmlJsAndCssToDirectory\\\")\\n copyCingHtmlJsAndCssToDirectory(outputDir) \\n# htmlDir = os.path.join(cingRoot, \\\"HTML\\\")\\n fnMatchPattern = '*.' + fnExtension\\n image_fn_list = glob(os.path.join(inputDir,fnMatchPattern)) \\n inputDirBase = os.path.basename(inputDir)\\n# nTdebug(\\\"Got relative part of inputDir: %s\\\" % inputDirBase) # e.g. plotTrend\\n image_code_list = []\\n for image_fn in image_fn_list:\\n _root, image_code, _ext = nTpath(image_fn)\\n image_code_list.append(image_code)\\n # end for \\n ## Get the number of files required for building an index\\n number_of_images_all_present = len(image_code_list)\\n number_of_images_per_file = number_of_entries_per_row * number_of_files_per_column\\n ## Number of files with indexes in google style\\n number_of_files = int(number_of_images_all_present / number_of_images_per_file)\\n if number_of_images_all_present % number_of_images_per_file:\\n number_of_files += 1\\n # end if\\n nTmessage(\\\"Creating %s pages for %s image codes\\\" % (number_of_files, number_of_images_all_present))\\n# nTmessage(\\\"Generating %s index html files\\\" % (number_of_files))\\n\\n file_name = os.path.join (self.base_dir, \\\"data\\\", self.results_base, \\\"indexPplot.html\\\")\\n file_content = open(file_name, 'r').read()\\n old_string = r\\\"<!-- INSERT NEW TITLE HERE -->\\\"\\n new_string = capitalizeFirst( inputDirBase )\\n file_content = string.replace(file_content, old_string, new_string)\\n old_string = r\\\"<!-- INSERT NEW FOOTER HERE -->\\\"\\n file_content = string.replace(file_content, old_string, self.htmlFooter)\\n old_string = r\\\"<!-- INSERT GOOGLE ANALYTICS TEMPLATE HERE -->\\\"\\n file_content = string.replace(file_content, old_string, GOOGLE_ANALYTICS_TEMPLATE)\\n old_string = r\\\"<!-- INSERT GOOGLE PLUS ONE TEMPLATE HERE -->\\\"\\n file_content = string.replace(file_content, old_string, GOOGLE_PLUS_ONE_TEMPLATE)\\n ## Count will track the number of entries done per index file\\n images_done_per_file = 0\\n ## Following variable will track all done sofar\\n images_done_all = 0\\n ## Tracking the number in the current row. Set for the rare case that there\\n ## are no entries at all. Otherwise it will be initialize on first pass.\\n num_in_row = 0\\n ## Tracking the index file number\\n file_id = 1\\n ## Text per row in an index file to insert\\n insert_text = ''\\n ## Repeat for all entries plus a dummy pass for writing the last index file\\n for image_code in image_code_list + [ None ]:\\n ## Finish this index file\\n ## The last index file will only be written once...\\n if images_done_per_file == number_of_images_per_file or images_done_all == number_of_images_all_present:\\n begin_image_count = number_of_images_per_file * (file_id - 1) + 1\\n end_image_count = min(number_of_images_per_file * file_id,\\n number_of_images_all_present)\\n# nTdebug(\\\"begin_image_count, end_image_count, number_of_images_all_present: %5d %5d %5d\\\" % (\\n# begin_image_count, end_image_count, number_of_images_all_present))\\n # image_code is just the base name of the file name.\\n new_string = \\\"Images: %s-%s of %s.\\\" % (\\n begin_image_count,\\n end_image_count,\\n number_of_images_all_present\\n )\\n old_string = r\\\"<!-- INSERT NEW RESULT STRING HERE -->\\\" \\n new_file_content = string.replace(file_content, old_string, new_string)\\n # Always end the row by adding dummy columns\\n if num_in_row != number_of_entries_per_row:\\n insert_text += (number_of_entries_per_row - num_in_row) * 2 * r\\\"<td> </td>\\\" + r\\\"</tr>\\\"\\n # end if\\n ## Create the new index file from the example one by replacing a string\\n ## with the new content.\\n old_string = r\\\"<!-- INSERT NEW ROWS HERE -->\\\"\\n new_file_content = string.replace(new_file_content, old_string, insert_text)\\n\\n first_string = '<a href=\\\"index_%s.html\\\">First < <</a>' % 1\\n final_string = '<a href=\\\"index_%s.html\\\">Last > ></a>' % number_of_files\\n prev_string = ''\\n if file_id > 1:\\n prev_string = '<a href=\\\"index_%s.html\\\">Previous <</a>' % ( file_id - 1)\\n # end if\\n next_string = ''\\n if file_id < number_of_files:\\n next_string = '<a href=\\\"index_%s.html\\\">> Next</a>' % ( file_id + 1)\\n # end if\\n first_link = max(1, file_id - number_of_files_per_column)\\n last_link = min(number_of_files, file_id + number_of_files_per_column - 1)\\n links_string = ''\\n for link in range(first_link, last_link + 1):\\n ## List link but don't include a link out for the current file_id\\n if link == file_id:\\n links_string += ' <B>%s</B>' % link\\n else:\\n links_string += ' <a href=\\\"index_%s.html\\\">%s</a>' % (\\n link, link)\\n # end if\\n # end for\\n old_string = r\\\"<!-- INSERT NEW LINKS HERE -->\\\"\\n new_string = 'Result pages: ' + ' '.join([first_string, prev_string, links_string, next_string, final_string])\\n new_file_content = string.replace(new_file_content, old_string, new_string)\\n ## Make the first index file name still index.html\\n new_file_name = os.path.join( outputDir, 'index_%s.html' % file_id)\\n if not file_id:\\n new_file_name = os.path.join( outputDir, '/index.html' )\\n # end if \\n writeTextToFile(new_file_name, new_file_content) \\n images_done_per_file = 0\\n num_in_row = 0\\n insert_text = \\\"\\\"\\n file_id += 1\\n # end for\\n ## Build on current index file\\n ## The last iteration will not execute this block because of this clause\\n if images_done_all < number_of_images_all_present:\\n images_done_all += 1\\n images_done_per_file += 1\\n ## Get the html code right by abusing the formatting chars.\\n ## as in sprintf etc.\\n imageRelUrl = os.path.join( '..', inputDirBase, image_code + '.' + fnExtension)\\n tmp_string = \\\"\\\"\\\"\\n<td> <a href=\\\"%(imageRelUrl)s\\\"> <img SRC=\\\"%(imageRelUrl)s\\\" border=\\\"0\\\" width=\\\"%(imageWidth)s\\\" height=\\\"%(imageHeight)s\\\"> </a> </td>\\\"\\\"\\\" % dict(\\n imageRelUrl=imageRelUrl, imageWidth=imageWidth, imageHeight=imageHeight)\\n num_in_row = images_done_per_file % number_of_entries_per_row\\n if num_in_row == 0:\\n num_in_row = number_of_entries_per_row\\n # end if\\n if num_in_row == 1:\\n # Start new row\\n tmp_string = \\\"\\\\n<tr>\\\" + tmp_string\\n elif (num_in_row == number_of_entries_per_row):\\n # End this row\\n tmp_string = tmp_string + \\\"\\\\n</tr>\\\"\\n # end if\\n insert_text += tmp_string\\n # end if\\n # end if\\n index_file_first = 'index_1.html'\\n index_file = os.path.join(outputDir, 'index.html')\\n ## Assume that a link that is already present is valid and will do the job\\n# nTdebug('Symlinking: %s %s' % (index_file_first, index_file))\\n symlink(index_file_first, index_file)\",\n \"def ex1_plots(instance, destination, prefix, save, animate):\\n \\n plts = ukf_plots(instance, destination, prefix, save, animate)\\n\\n truths = truth_parser(instance)\\n nan_array= nan_array_parser(instance, truths, instance.base_model)\\n #obs, obs_key = obs_parser(instance, True)\\n obs_key = obs_key_parser(instance, True)\\n preds = preds_parser(instance, True)\\n #forecasts = forecasts_parser(instance, True)\\n \\n ukf_params = instance.ukf_params\\n index2 = ukf_params[\\\"index2\\\"]\\n \\n \\\"remove agents not in model to avoid wierd plots\\\"\\n #obs *= nan_array\\n truths *= nan_array\\n preds *= nan_array\\n #forecasts*= nan_array\\n \\n \\\"indices for unobserved agents\\\"\\n not_index2 = np.array([i for i in np.arange(truths.shape[1]) if i not in index2])\\n plts.pair_frame(truths, preds, obs_key, 10, destination)\\n plts.error_hist(truths[::instance.sample_rate,index2], \\n preds[::instance.sample_rate,index2],\\\"Observed Errors\\\")\\n if len(not_index2)>0:\\n plts.error_hist(truths[::instance.sample_rate, not_index2], \\n preds[::instance.sample_rate, not_index2],\\\"Unobserved Errors\\\")\\n \\n #plts.path_plots(obs[::instance.sample_rate] , \\\"Observed\\\")\\n plts.path_plots(preds[::instance.sample_rate], \\\"Predicted\\\")\\n plts.path_plots(truths, \\\"True\\\")\\n #plts.path_plots(forecasts[::instance.sample_rate], \\\"Forecasts\\\")\\n\\n if animate:\\n #plts.trajectories(truths, \\\"plots/\\\")\\n plts.pair_frames(truths, preds, obs_key,\\n truths.shape[0], \\\"../../plots/\\\")\",\n \"def plot_files(n=15):\\n lod = read_files(n)\\n\\n for i in range(len(lod)):\\n plt.plot(range(len(lod[i])), lod[i])\\n\\n plt.show()\",\n \"def plot_training_progress(model_output_path):\\n try:\\n results = load_results(model_output_path)\\n except FileNotFoundError:\\n print('monitor.csv file is not found!')\\n\\n results['l_moving_avg_100'] = results['l'].rolling(window=100).mean()\\n results['r_moving_avg_100'] = results['r'].rolling(window=100).mean()\\n results['t_per_M'] = results['t'] / 1000\\n\\n fig, axs = plt.subplots()\\n results.plot(\\n ax=axs,\\n x='t_per_M', y='r_moving_avg_100',\\n title='Training Progress',\\n xlabel='Million Steps',\\n ylabel='Mean Reward'\\n )\\n return results\",\n \"def plot_Cmd_AngVel_EulerAng(data_fcs, data_vel, data_att, dest_folder=None):\\n \\n # Variables assignment\\n t_fcs = data_fcs[:,0]\\n delta_a = data_fcs[:,18]\\n delta_e = data_fcs[:,6]\\n delta_r = data_fcs[:,9]\\n delta_t = data_fcs[:,20]\\n \\n t_vel = data_vel[:,0]\\n p_rad = data_vel[:,4]\\n q_rad = data_vel[:,5]\\n r_rad = data_vel[:,6]\\n \\n t_att = data_att[:,0]\\n phi_rad = data_att[:,1]\\n the_rad = data_att[:,2]\\n psi_rad = data_att[:,3]\\n \\n fig = plt.figure(figsize=(12.3,15))\\n \\n \\n # Commands\\n ax1a = fig.add_subplot(3,1,1)\\n ax1a.plot(t_fcs, delta_a, ls='solid', color='r', label=r'$\\\\delta_a$')\\n ax1a.plot(t_fcs, delta_e, ls='solid', color='g', label=r'$\\\\delta_e$')\\n ax1a.plot(t_fcs, delta_r, ls='solid', color='b', label=r'$\\\\delta_r$')\\n \\n ax1a.set_title(\\\"Commands\\\") \\n ax1a.set_xlabel(r'$t$ (s)')\\n ax1a.set_ylabel(r'$\\\\delta_a$ , $\\\\delta_e$ , $\\\\delta_r$ (°)')\\n ax1a.set_ylim(ymin=-1+np.floor(min(list(delta_a)+list(delta_e)+list(delta_r))),\\n ymax=1+np.ceil(max(list(delta_a)+list(delta_e)+list(delta_r))))\\n \\n \\n ax1b = ax1a.twinx()\\n ax1b.plot(t_fcs, delta_t, ls='solid', color='0.65', label=r'$\\\\delta_t$')\\n \\n ax1b.set_ylabel(r'$\\\\delta_t$')\\n ax1b.set_ylim(ymax=1, ymin=-0.05)\\n \\n handlesa, labelsa = ax1a.get_legend_handles_labels()\\n handlesb, labelsb = ax1b.get_legend_handles_labels()\\n ax1a.legend(handlesa+handlesb, labelsa+labelsb, ncol=4, loc='best')\\n \\n\\n # Angular velocities\\n ax2 = fig.add_subplot(3,1,2)\\n \\n ax2.plot(t_vel, (180/np.pi)*p_rad, color='r', label=r'$p$')\\n ax2.plot(t_vel, (180/np.pi)*q_rad, color='g', label=r'$q$')\\n ax2.plot(t_vel, (180/np.pi)*r_rad, color='b', label=r'$r$')\\n \\n ax2.set_title(\\\"Angular velocities\\\") \\n ax2.set_xlabel(r'$t$ (s)')\\n ax2.set_ylabel(r'$p$ , $q$ , $r$ (°/s)')\\n \\n handles, labels = ax2.get_legend_handles_labels()\\n ax2.legend(handles, labels, ncol=3, loc='best')\\n \\n \\n # Euler angles\\n ax3a = fig.add_subplot(3,1,3)\\n \\n ax3a.plot(t_att, (180/np.pi)*phi_rad, color='r', label=r\\\"$\\\\phi$\\\")\\n ax3a.plot(t_att, (180/np.pi)*the_rad, color='g', label=r\\\"$\\\\theta$\\\")\\n \\n ax3a.set_title(\\\"Euler angles\\\") \\n ax3a.set_xlabel(r'$t$ (s)')\\n ax3a.set_ylabel(r'$\\\\phi$ , $\\\\theta$ (°)')\\n \\n \\n ax3b = ax3a.twinx()\\n ax3b.plot(t_att, (180/np.pi)*psi_rad, color='b', label=r\\\"$\\\\psi$\\\")\\n \\n ax3b.set_ylabel(r'$\\\\psi$ (°)')\\n \\n handlesa, labelsa = ax3a.get_legend_handles_labels()\\n handlesb, labelsb = ax3b.get_legend_handles_labels()\\n ax3b.legend(handlesa+handlesb, labelsa+labelsb, ncol=3, loc='best')\\n \\n plt.tight_layout()\\n \\n \\n # Export\\n if dest_folder != None:\\n plt.savefig(dest_folder+'plot_Cmd_AngVel_EulerAng.pdf')\",\n \"def do_jet_pt_plots(tree, output_dir, cut=''):\\n for logz, normx in product([True, False], [True, False]):\\n make_2d_plot(tree, 'httL1', HTT_L1_STR, NB_HTT, HTT_MIN, HTT_MAX, 'pt', PT_L1_STR, NB_PT, PT_MIN, PT_MAX,\\n os.path.join(output_dir, 'pt_httL1.pdf'), logz=logz, normx=normx,\\n cut=cut, title=TITLE, diagonal_line=True)\\n make_2d_plot(tree, 'httL1', HTT_L1_STR, NB_HTT, HTT_MIN, HTT_MAX, 'ptRef', PT_REF_STR, NB_PT, PT_MIN, PT_MAX,\\n os.path.join(output_dir, 'ptRef_httL1.pdf'), logz=logz, normx=normx,\\n cut=cut, title=TITLE, diagonal_line=True)\\n make_2d_plot(tree, 'httRef', HTT_REF_STR, NB_HTT, HTT_MIN, HTT_MAX, 'pt', PT_L1_STR, NB_PT, PT_MIN, PT_MAX,\\n os.path.join(output_dir, 'pt_httRef.pdf'), logz=logz, normx=normx,\\n cut=cut, title=TITLE, diagonal_line=True)\\n make_2d_plot(tree, 'httRef', HTT_REF_STR, NB_HTT, HTT_MIN, HTT_MAX, 'ptRef', PT_REF_STR, NB_PT, PT_MIN, PT_MAX,\\n os.path.join(output_dir, 'ptRef_httRef.pdf'), logz=logz, normx=normx,\\n cut=cut, title=TITLE, diagonal_line=True)\",\n \"def plot_balance_list_output(balance_list, path, nframes=4):\\n import matplotlib\\n font = {'size' : 15, 'weight': 'normal'}\\n matplotlib.rc('font', **font)\\n\\n nplots=len(balance_list)\\n ncols=2\\n nrows=int(np.ceil(nframes/ncols))\\n _, axes = plt.subplots(nrows, ncols, figsize=(25, 5*nrows))\\n for n in range(nframes):\\n i = int(np.floor(n / ncols))\\n j=n % ncols\\n r_p = []\\n for k in range(len(balance_list[n])-1):\\n r_p.append(np.abs(balance_list[n][k]-balance_list[n][k+1])/balance_list[n][k])\\n\\n axes[i,j].plot(balance_list[n], label='balance', color='b')\\n axes[i,j].set_title('Outer loop # '+ str(n))\\n # axes[i,j].set_yscale('log')\\n # axes[i,j].set_xscale('log')\\n axes[i,j].grid(True)\\n axes[i,j].set_ylabel('Balance norm')\\n # axes[i,j].legend()\\n axes[i,j].set_ylim([0, 10])\\n # ax_2=axes[i,j].twinx()\\n # ax_2.plot(r_p, 'g')\\n # ax_2.set_yscale('log')\\n # ax_2.set_ylabel('relative change')\\n\\n plt.savefig(path,transparent=True, dpi=400)\",\n \"def plot_overview(cube=nro_12co,\\n region_file='../shell_candidates/AllShells.reg', mode='peak', plotname='12co_peak_shells.png',\\n interactive=False, show_shells=True, shells_highlight=None, dist=orion_dist, vmin=None, vmax=None,\\n scalebar_color=\\\"white\\\", scalebar_pc = 1., scale_factor=1., pmin=0.25,\\n pmax=99.75, cbar_label=r\\\"Peak T$_{\\\\rm MB}$ [K]\\\",\\n circle_color='white', circle_linewidth=1, circle_style=\\\"solid\\\", return_fig=False, show=True,\\n title=r\\\"$^{12}$CO Peak T$_{MB}$\\\", recenter=False, ra=None, dec=None, radius=None):\\n try:\\n cube = SpectralCube.read(cube)\\n except ValueError:\\n pass\\n\\n if mode == \\\"peak\\\":\\n image = (cube.max(axis=0) * scale_factor).hdu\\n \\n\\n if mode == \\\"mom0\\\":\\n image = (cube.moment0() * scale_factor).hdu\\n\\n\\n\\n fig = FITSFigure(image)\\n if show:\\n fig.show_colorscale(cmap='viridis', vmin=vmin, vmax=vmax, pmin=pmin,\\n pmax=pmax, interpolation='none')\\n fig.tick_labels.set_yformat(\\\"dd:mm\\\")\\n fig.tick_labels.set_xformat(\\\"hh:mm\\\")\\n #fig.hide_yaxis_label()\\n #fig.hide_ytick_labels()\\n plt.title(title)\\n plt.xlabel(\\\"RA (J2000)\\\")\\n plt.ylabel(\\\"DEC (J2000)\\\")\\n\\n if show_shells:\\n shell_list = get_shells(region_file=region_file)\\n for i, shell in enumerate(shell_list):\\n if shells_highlight:\\n if i+1 in shells_highlight:\\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle='solid', edgecolor=circle_color,\\n facecolor='none', linewidth=3)\\n else:\\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle=circle_style, edgecolor=circle_color,\\n facecolor='none', linewidth=circle_linewidth)\\n else:\\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle=circle_style, edgecolor=circle_color,\\n facecolor='none', linewidth=circle_linewidth)\\n\\n #RECENTER\\n if recenter:\\n fig.recenter(ra, dec, radius)\\n\\n\\n #SCALEBAR\\n fig.add_scalebar(206265 * scalebar_pc / (dist.to(u.pc).value * 3600), color=scalebar_color)\\n fig.scalebar.set_label(\\\"{} pc\\\".format(scalebar_pc))\\n\\n fig.add_colorbar()\\n cb = fig.colorbar\\n cb.set_axis_label_text(cbar_label)\\n\\n if return_fig:\\n return fig\\n else:\\n fig.save(plotname, dpi=600)\",\n \"def basic_stats_and_plots():\\n \\n basename = sys.argv[1]\\n ops = (\\\"two_opt\\\", \\\"twoh_opt\\\", \\\"three_opt\\\", \\\"three_opt_broad\\\", \\\"swap\\\", \\\"swap_adj\\\")\\n opfs = {\\n \\\"two_opt\\\": tsp.two_opt,\\n \\\"twoh_opt\\\": tsp.twoh_opt,\\n \\\"three_opt\\\": tsp.three_opt,\\n \\\"three_opt_broad\\\": tsp.three_opt_broad,\\n \\\"swap\\\": tsp.swap_two,\\n \\\"swap_adj\\\": tsp.swap_adj\\n }\\n \\n lengths = range(6, 11)\\n for length in lengths:\\n stddev = []\\n gini = []\\n nneighbours = []\\n prop_unique = []\\n for op in ops:\\n filename = os.path.join(basename,\\n \\\"tsp_length_%d_%s\\\" % (length, op),\\n \\\"TP_row0.dat\\\")\\n print op, length\\n x = np.genfromtxt(filename)\\n # stats to get:\\n stddev.append(np.std(x))\\n gini.append(random_walks.gini_coeff(x))\\n nneighbours.append(np.sum(x > 0))\\n mu, sigma = rw_experiment_with_op(length, opfs[op])\\n prop_unique.append((mu, sigma))\\n\\n gini_barchart(length, gini, ops)\\n stddev_barchart(length, stddev, ops)\\n plot_gini_v_nneighbours(length, gini, nneighbours, ops)\\n plot_stddev_v_nneighbours(length, stddev, nneighbours, ops)\\n plot_gini_v_prop_unique(length, gini, prop_unique, ops)\\n plot_stddev_v_prop_unique(length, stddev, prop_unique, ops)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77768505","0.69358486","0.6893516","0.6873988","0.6526698","0.6287042","0.62730706","0.61070305","0.6070563","0.6070449","0.5956038","0.5923547","0.5919201","0.5887804","0.5874542","0.5859539","0.58339554","0.5830068","0.58292556","0.5784595","0.5765463","0.57374895","0.57303447","0.5716146","0.5670726","0.5642362","0.563532","0.5625996","0.5623595","0.561812","0.5617648","0.5607168","0.5605671","0.5597418","0.5585267","0.5579868","0.55750036","0.5573499","0.556152","0.5557731","0.5551387","0.5540348","0.5539002","0.5537704","0.5528813","0.5524984","0.55229145","0.55221224","0.55203414","0.5519005","0.55077","0.5498151","0.54953307","0.5492744","0.54900074","0.54884106","0.5487497","0.5486338","0.54678154","0.54622513","0.5450708","0.5447351","0.544547","0.5438171","0.5423321","0.5423225","0.5420166","0.54191387","0.54165024","0.54130524","0.5411816","0.54076314","0.54026645","0.54006475","0.5384616","0.5378671","0.5366795","0.5366687","0.536605","0.5362122","0.5353845","0.53527397","0.5352232","0.5344992","0.53316015","0.5323427","0.53174025","0.53162956","0.53091174","0.5307539","0.53050065","0.5302314","0.5298295","0.5294585","0.5289216","0.52870154","0.5285496","0.52832603","0.5279203","0.5272577","0.5270607"],"string":"[\n \"0.77768505\",\n \"0.69358486\",\n \"0.6893516\",\n \"0.6873988\",\n \"0.6526698\",\n \"0.6287042\",\n \"0.62730706\",\n \"0.61070305\",\n \"0.6070563\",\n \"0.6070449\",\n \"0.5956038\",\n \"0.5923547\",\n \"0.5919201\",\n \"0.5887804\",\n \"0.5874542\",\n \"0.5859539\",\n \"0.58339554\",\n \"0.5830068\",\n \"0.58292556\",\n \"0.5784595\",\n \"0.5765463\",\n \"0.57374895\",\n \"0.57303447\",\n \"0.5716146\",\n \"0.5670726\",\n \"0.5642362\",\n \"0.563532\",\n \"0.5625996\",\n \"0.5623595\",\n \"0.561812\",\n \"0.5617648\",\n \"0.5607168\",\n \"0.5605671\",\n \"0.5597418\",\n \"0.5585267\",\n \"0.5579868\",\n \"0.55750036\",\n \"0.5573499\",\n \"0.556152\",\n \"0.5557731\",\n \"0.5551387\",\n \"0.5540348\",\n \"0.5539002\",\n \"0.5537704\",\n \"0.5528813\",\n \"0.5524984\",\n \"0.55229145\",\n \"0.55221224\",\n \"0.55203414\",\n \"0.5519005\",\n \"0.55077\",\n \"0.5498151\",\n \"0.54953307\",\n \"0.5492744\",\n \"0.54900074\",\n \"0.54884106\",\n \"0.5487497\",\n \"0.5486338\",\n \"0.54678154\",\n \"0.54622513\",\n \"0.5450708\",\n \"0.5447351\",\n \"0.544547\",\n \"0.5438171\",\n \"0.5423321\",\n \"0.5423225\",\n \"0.5420166\",\n \"0.54191387\",\n \"0.54165024\",\n \"0.54130524\",\n \"0.5411816\",\n \"0.54076314\",\n \"0.54026645\",\n \"0.54006475\",\n \"0.5384616\",\n \"0.5378671\",\n \"0.5366795\",\n \"0.5366687\",\n \"0.536605\",\n \"0.5362122\",\n \"0.5353845\",\n \"0.53527397\",\n \"0.5352232\",\n \"0.5344992\",\n \"0.53316015\",\n \"0.5323427\",\n \"0.53174025\",\n \"0.53162956\",\n \"0.53091174\",\n \"0.5307539\",\n \"0.53050065\",\n \"0.5302314\",\n \"0.5298295\",\n \"0.5294585\",\n \"0.5289216\",\n \"0.52870154\",\n \"0.5285496\",\n \"0.52832603\",\n \"0.5279203\",\n \"0.5272577\",\n \"0.5270607\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":21291,"cells":{"query":{"kind":"string","value":"Plot vertical and radial profiles for specified output directories."},"document":{"kind":"string","value":"def plot_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2014/output',\n\t\t\t\tsteps=['step01','step02'],\n\t\t\t\t#labels='',\n\t\t\t\tshow=True,\n\t\t\t\txscale=1e3,\n\t\t\t\tyscale=1e-2):\n\tplt.figure()\n\t#path = '/Users/scott/Desktop/elastic'\n\n\t# Deep source\n\t#labels = ['no APMB', 'APMB']\n\t#if labels == '':\n\tlabels = steps\n\tdeep = {}\n\t#uzmax = 0.824873455364\n\t# NOT sure why hardcoded...\n\tuzmax = 1\n\tfor i,outdir in enumerate(steps):\n\t\tpointsFile = os.path.join(path, outdir, 'points.h5')\n\t\tprint(pointsFile)\n\t\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n\n\t\tX = x / xscale\n\t\tY1 = ux / yscale\n\n\t\tx_fem = X #/ xscale #double scaling!\n\t\tur_fem = Y1 #/ yscale\n\t\tuz_fem = uz / yscale\n\n\t\t#print(pointsFile)\n\t\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\n\n\t\t#normalize\n\t\tuz_fem = uz_fem / uzmax\n\t\tur_fem = ur_fem / uzmax\n\t\tx_fem = x_fem / 30.0\n\n\t\tl, = plt.plot(x_fem,uz_fem,'o-',ms=4,lw=4,label=labels[i])\n\t\tplt.plot(x_fem,ur_fem,'o--',ms=4,lw=4,color=l.get_color()) #mfc='none' transparent\n\t\tdeep[outdir] = uz_fem/uz_fem\n\n\t'''\n\t# Shallow Source\n\tshallow = {}\n\tuzmax = 0.949652827795\n\tfor i,outdir in enumerate(['step11','step12']):\n\t\tpointsFile = os.path.join(path, outdir, 'points.h5')\n\n\t\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n\n\t\tX = x / xscale\n\t\tY1 = ux / yscale\n\n\t\tx_fem = X #/ xscale #double scaling!\n\t\tur_fem = Y1 #/ yscale\n\t\tuz_fem = uz / yscale\n\n\t\t#print(pointsFile)\n\t\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\n\n\t#normalize\n\tuz_fem = uz_fem / uzmax\n\tur_fem = ur_fem / uzmax\n\tx_fem = x_fem / 20.0\n\n\t\tl, = plt.plot(x_fem,uz_fem,'.-', mfc='w', lw=4,label=labels[i])\n\t\tplt.plot(x_fem,ur_fem,'.--',lw=4, mfc='w',color=l.get_color()) #mfc='none' transparent\n\n\t\tshallow[outdir] = uz_fem/ur_fem\n\t'''\n\n\t# Annotate\n\tplt.axhline(color='k',lw=0.5)\n\t#plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n\t#plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n\tplt.legend()\n\tplt.grid()\n\t#plt.ylim(-0.5, 3.5)\n\t#plt.savefig('deep.png',bbox_inches='tight')\n\t#plt.savefig('shallow.png',bbox_inches='tight')\n\n\t# normalized\n\tplt.ylim(-0.5, 4)\n\tplt.xlim(0,10)\n\tplt.xlabel('Normalized Radial Distance [R / D]')\n\tplt.ylabel('Normalized Displacement [U / Uz_max]')\n\t#plt.savefig('normalized_deep.png',bbox_inches='tight')\n\tplt.savefig('normalized_shallow.png',bbox_inches='tight')\n\n\n\t# Plot ratios of uz versus NOTE: this plot is confusing,,, just keep ratio of uz_max to ur_max\n\t'''\n\tplt.figure()\n\tplt.plot(x_fem, deep['step01'], label='Deep no APMB')\n\tplt.plot(x_fem, deep['step02'], label='Deep w/ APMB')\n\tplt.plot(x_fem, shallow['step11'], label='Shallow no APMB')\n\tplt.plot(x_fem, shallow['step12'], label='Shallow w/ APMB')\n\tplt.xlabel('Distance [km]') #NOTE: maybe plot normailzed X-axis (R-d)\n\t#plt.xlabel('Normalized Distance [R/d]')\n\tplt.ylabel('Ratio [Uz/Ur]')\n\tplt.title('Ratio of vertical to radial displacement')\n\tplt.legend()\n\tplt.show()\n\t'''"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def plot_directory_profiles(path, outname=None, show=True, xscale=1, yscale=1,\n xval='x', adjustRadial=True):\n outdirs = np.sort(os.listdir(path))\n plt.figure()\n\n #labels=['homogeneous','1D layering', '3D tomography'] #xscale=1e-3, yscale=1e2\n for i,outdir in enumerate(outdirs):\n pointsFile = os.path.join(path, outdir, 'points.h5')\n #print(pointsFile)\n #x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile, output='cyl',adjustRadial=adjustRadial)\n #x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile)\n #Load data\n\n x,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n #Y = uz / yscale\n if xval == 'x':\n X = x / xscale\n Y1 = ux / yscale\n elif xval == 'r':\n X = np.hypot(x,y) / xscale\n ur_fem = np.hypot(ux,uy)\n Y1 = ur_fem / yscale\n if adjustRadial: #fix sign from hypot square root\n ur_fem = pu.radial2negative(Y1)\n\n x_fem = X #/ xscale #double scaling!\n ur_fem = Y1 #/ yscale\n uz_fem = uz / yscale\n\n #print(pointsFile)\n print(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max())\n\n l, = plt.plot(x_fem,uz_fem,'.-',lw=3,label=outdir)\n #l, = plt.plot(x_fem,uz_fem,'.-',lw=2,label=labels[i]) #for 3d heterogeneity example\n plt.plot(x_fem,ur_fem,'.--',lw=3, mfc='w',color=l.get_color()) #mfc='none' transparent\n\n # Annotate\n plt.axhline(color='k',lw=0.5)\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n plt.legend()\n\n #NOTE: custom annotations for 3d heterogeneity\n #plt.title('Elastic Heterogeneity Effects')\n #plt.legend([l1,l2,l3],['homogeneous','1D layering', '3D tomography'])\n\n if outname: plt.savefig(outname)\n if show: plt.show()","def plot(profiler, outdir):\n # go through the outputs of all morphisms\n for cur_name, cur_output in profiler.profile.items():\n cur_outdir = os.path.join(outdir, cur_name)\n if not os.path.exists(cur_outdir):\n os.makedirs(cur_outdir)\n\n ProfilePlotter.plot_morphism_output(cur_output, cur_outdir)","def plot_morphism_output(data, outdir):\n\n # show the distributions for each variable separately\n for col in data.columns:\n ProfilePlotter._plot_1d(data[col], outfile = os.path.join(outdir, col + \".pdf\"))\n\n # later, maybe also show 2d plots etc.","def plot_directory_numex(path, vals, param='density', outname=None, show=True,\n xscale=1e-3,yscale=1e2):\n #vals = arange(2300.0, 2800.0, 50.0)\n outdirs = np.sort(os.listdir(path))\n plt.figure()\n\n # Plot surface profiles for each parameter\n for val,outdir in zip(vals,outdirs):\n pointsFile = os.path.join(path, outdir, 'points.h5')\n print(pointsFile)\n x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile, output=True, adjustRadial=True)\n x_fem = x_fem / xscale\n ur_fem = ur_fem / yscale\n uz_fem = uz_fem / yscale\n l, = plt.plot(x_fem,uz_fem,'.-',label=str(val))\n plt.plot(x_fem,ur_fem,'.-',color=l.get_color())\n\n # Annotate\n plt.axhline(color='k') #zero displacement line\n plt.title(param)\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n plt.legend()\n\n if outname: plt.savefig(outname)\n if show: plt.show()","def plot_profile(outdir, xval='x', xscale=1, yscale=1, comp2los=False, adjustRadial=False,\n fig=True):\n #Load data\n path = os.path.join(outdir,'points.h5')\n x,y,z,ux,uy,uz = pu.extract_points(path)\n\n Y = uz / yscale\n if xval == 'x':\n X = x / xscale\n Y1 = ux / yscale\n elif xval == 'r':\n X = np.hypot(x,y) / xscale\n ur = np.hypot(ux,uy)\n Y1 = ur / yscale\n if adjustRadial: #fix sign from hypot square root\n ur = pu.radial2negative(Y1)\n\n if fig:\n plt.figure()\n # otherwise profile added to active plot\n\n #plt.plot(X,uy/yscale,'r.-',label='Uy') #should be zero along EW axis\n de = 90e3 / xscale #eastern data extent\n if comp2los != False:\n data_extents = (X<=de)\n if comp2los == 'west': #switch sign of radial profile\n #ux = -ux #move to comp2los function\n X = -X\n Y1 = -Y1\n de = -de\n data_extents = (X>=de)\n\n los = pu.comp2los(x,ux,uy,uz,track=comp2los)\n plt.plot(X, los/yscale, 'k-', lw=2, label='Ulos_' + comp2los)\n plt.fill_between(X,los/yscale, where=data_extents, color='gray',alpha=0.5)\n\n plt.plot(X, Y, 'b-', lw=2, label='Uz')\n plt.plot(X, Y1, 'b--',lw=2, mfc='None',label='U{0}'.format(xval))\n\n # Annotate\n plt.title(outdir)\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n plt.ylabel('Uz [{}]'.format(get_unit(yscale)))\n plt.axhline(color='k')\n plt.axvline(de,color='k', linestyle='dashed', label='EW data extent') #EW extent of InSAR coverage\n plt.legend(loc='best')\n plt.grid(True)\n plt.show()","def plot_one_directory(args, dirnames, figname):\n logdir = args.logdir\n num = len(ATTRIBUTES)\n fig, axes = subplots(num, figsize=(13,4*num))\n\n for (dd, cc) in zip(dirnames, COLORS):\n A = np.genfromtxt(join(logdir, dd, 'log.txt'), \n delimiter='\\t', \n dtype=None, \n names=True)\n x = A['Iterations']\n\n for (i,attr) in enumerate(ATTRIBUTES):\n axes[i].plot(x, A[attr], '-', lw=lw, color=cc, label=dd)\n axes[i].set_ylabel(attr, fontsize=ysize)\n axes[i].tick_params(axis='x', labelsize=tick_size)\n axes[i].tick_params(axis='y', labelsize=tick_size)\n axes[i].legend(loc='best', ncol=2, prop={'size':legend_size})\n\n axes[0].set_ylim([-10,10])\n axes[1].set_ylim([-10,10])\n axes[2].set_ylim([0,10])\n axes[3].set_ylim([0,10])\n\n plt.tight_layout()\n plt.savefig(figname)","def create_plots(self):\n if not os.path.exists(self.output_folder):\n os.makedirs(self.output_folder)\n self.sse_plot()\n self.avg_sse_plot()","def Plot(self):\n\n ### Create the path names ###\n folder_string = self.params.folder+\"/plots/\"\n u_string = self.params.folder+\"/plots/u.pdf\"\n p_string = self.params.folder+\"/plots/p.pdf\"\n\n ### Check if folder exists ###\n if not os.path.exists(folder_string): os.makedirs(folder_string)\n\n ### Plot the x component of velocity ###\n plot(self.u_next[0],title=\"Velocity in the x Direction\")\n plt.savefig(u_string)\n plt.figure()\n\n ### Plot the pressure ###\n plot(self.p_next,title=\"Pressure\")\n plt.savefig(p_string)\n plt.show()","def run_plots(self):\n # load the files\n self.pre_dark_file = os.path.join(self.input_dir, 'step_lastframe.fits')\n self.post_dark_file = os.path.join(self.input_dir, 'step_dark_current.fits')\n self.jump_file = os.path.join(self.input_dir, 'step_jump.fits')\n self.rate_file = os.path.join(self.input_dir, 'step_rate.fits')\n self.ramp_file = glob.glob(os.path.join(self.input_dir, '*.fits'))[0]\n\n # plots\n self.plot_jump_flags_image()\n self.plot_groupdq_flags(pixel=[884, 550])\n self.plot_ramps_pre_post_correction(pixel=[884, 550])","def plot_it(self, ui=None, res_dir=None):\r\n print_it(\"plotting results\")\r\n plt_profile(self.sun, PltOpts.DD.value, res_dir, SubDir.profiles.value)\r\n plt_profile(self.sun, PltOpts.DDD.value, res_dir, SubDir.profiles.value)\r\n plt_profile(self.planet, PltOpts.DD.value, res_dir,\r\n SubDir.profiles.value)\r\n plt_profile(self.planet, PltOpts.DDD.value, res_dir,\r\n SubDir.profiles.value)\r\n plt_profile_approx(res_dir, SubDir.profiles.value)\r\n plt_contact(self.sun, self.planet, PltOpts.DD.value, res_dir,\r\n SubDir.contacts.value)\r\n plt_contact(self.sun, self.planet, PltOpts.DDD.value, res_dir,\r\n SubDir.contacts.value)\r\n\r\n plt_3d(self.sun.x_axis, self.sun.y_axis, self.sun.press,\r\n self.sun.x_label, self.sun.y_label, 'pressure in MPa',\r\n 'contact_pressure_sun', res_dir, SubDir.pressures.value,\r\n 'contact_pressure_sun')\r\n plt_2d_scatt_line(self.sun.x_axis, self.pv, self.sun.x_axis, self.pv,\r\n self.sun.x_label,\r\n 'pv_rel in {}'.format(Unit.pvrel.value), 'pv_rel',\r\n res_dir, SubDir.energy.value, 'pv_rel')\r\n plt_2d_scatt_line(self.sun.x_axis, self.sun.e_akin, self.sun.x_axis,\r\n self.sun.e_akin, self.sun.x_label,\r\n 'e_akin in {}'.format(Unit.eakin.value), 'e_akin',\r\n res_dir, SubDir.energy.value, 'sun.e_akin')\r\n plt_2d_scatt_line(self.planet.x_axis, self.planet.e_akin,\r\n self.planet.x_axis, self.planet.e_akin,\r\n self.planet.x_label,\r\n 'e_akin in {}'.format(Unit.eakin.value), 'e_akin',\r\n res_dir,\r\n SubDir.energy.value, 'planet.e_akin')\r\n plt_energy_ring_on_ring(self, res_dir, SubDir.energy.value,\r\n 'e-akin-vs-pv-rel')","def main():\n\n\timport numpy as np\n\timport matplotlib as mpl\n\n\t# Parse arguments\n\targs = cli.parse_args()\n\n\t# Check all files exist\n\tfor filepath in args.files:\n\t\tif not os.path.isfile(filepath):\n\t\t\t_exit('file {} does not exist'.format(filepath))\n\n\t# Use TK interactive backend as it should work on all installations\n\tmpl.use('tkagg')\n\n\t# Turn on interactive plotting (pyplot import must come after call to use())\n\timport matplotlib.pyplot as plt\n\tplt.ion()\n\n\t# Get torsion angle arrays for all input files\n\tarrays = []\n\tfor filepath in args.files:\n\t\twith open(filepath) as fobj:\n\t\t\tchain = list(parse_pdb_chain(fobj))\n\t\t\tarrays.append(torsion_array(chain))\n\n\tangles = np.concatenate(arrays, axis=0)\n\n\t# Make the plot\n\tif args.plottype == 'hexbin':\n\t\thb = ramachandran_hexbin(angles, log=args.log, degrees=not args.radians)\n\t\tif args.cbar:\n\t\t\tplt.colorbar(hb)\n\n\telif args.plottype == 'scatter':\n\t\tramachandran_scatter(angles, degrees=not args.radians)\n\n\telif args.plottype == 'kde':\n\t\t_assert_seaborn_available('kde')\n\t\tramachandran_kdeplot(angles, shade=True, degrees=not args.radians)\n\n\telif args.plottype == 'joint':\n\t\t_assert_seaborn_available('joint')\n\t\tramachandran_jointplot(angles, kind='kde', degrees=not args.radians)\n\n\telse:\n\t\traise ValueError(args.plottype)\n\n\t# Plot title\n\tif len(args.files) == 1:\n\t\tfilename = os.path.basename(args.files[0])\n\telse:\n\t\tfilename = '{} files'.format(len(args.files))\n\n\tplt.gcf().suptitle('{} ({} residues)'.format(filename, angles.shape[0]))\n\n\t# Show the plot, blocking until closed\n\tplt.show(block=True)","def plot_potential_profile(rims_object):\r\n if not os.path.exists(rims_object.path_for_output):\r\n os.makedirs(rims_object.path_for_output)\r\n number_of_profiles = rims_object.potential_profile_mat.shape[0]\r\n x = [dx * pow(10, 4) for dx in rims_object.x_space_vec]\r\n fig, axs = plt.subplots(number_of_profiles)\r\n plt.suptitle('RIMS: Ratchet potential profiles', fontsize=14, fontweight='bold')\r\n\r\n for i_profile in range(number_of_profiles):\r\n y = [dy for dy in rims_object.potential_profile_mat[i_profile]]\r\n axs[i_profile].plot(x, y, color=YELLOW, label=\"V(x) potential profile\")\r\n axs[i_profile].tick_params(axis='y', labelcolor=YELLOW)\r\n ax2 = axs[i_profile].twinx()\r\n y = [dy * pow(10, -4) for dy in rims_object.electric_field_mat[i_profile]]\r\n ax2.plot(x, y, color=PURPLE, label=r\"E(x) electric field = -$\\nabla $V\")\r\n ax2.tick_params(axis='y', labelcolor=PURPLE)\r\n text_kwargs = dict(fontsize=10, color=YELLOW, fontweight='bold')\r\n fig.text(0.1, 0.91, 'V(x) potential profile [v]', text_kwargs)\r\n text_kwargs = dict(fontsize=10, color=PURPLE, fontweight='bold')\r\n fig.text(0.5, 0.91, r\"E(x) electric field = -$\\nabla $V [v/$\\mu $m]\", text_kwargs)\r\n axs[number_of_profiles-1].set_xlabel(r\"X [$\\mu $m]\")\r\n\r\n if number_of_profiles < 4:\r\n fig.tight_layout()\r\n plt.savefig(rims_object.path_for_output + 'Ratchet potential profiles.jpeg')\r\n plt.close()\r\n write_to_log(rims_object, \"potential profile plot saved\")\r\n return","def generate_plots(path):\n videos = glob(path + '/*.mkv')\n print(path, len(videos), videos)\n\n if len(videos) == 0:\n return\n else:\n videos = videos[0]\n\n metadata_list = glob(path + '/metadata.txt')\n #print(path, len(metadata_list), metadata_list)\n\n if len(metadata_list) == 0:\n return \n\n P = Preprocessor()\n P.import_video(str(videos))\n P.read_metadata(path)\n P.preprocess()\n Im = P.frames_processed\n if len(Im) == 0:\n print(len(Im))\n return\n\n z_start = P.z_start\n z_end = P.z_end\n\n mean, cov = analyze_image(Im)\n\n window_size = 10\n mean_smoothed = smoothing.mean_moving_average(mean, window_size)\n cov_smoothed = smoothing.cov_moving_average(cov, window_size)\n\n c = CubicFitRotated()\n c.fit(mean=mean_smoothed, cov=cov_smoothed, z_start=z_start, z_end=z_end)\n\n try:\n os.mkdir(path + '/analysis')\n path += '/analysis'\n except OSError:\n pass\n\n\n plots.plot_mean(mean, z_start, z_end).savefig(path + '/beam_center.png')\n plots.plot_beta(cov, z_start, z_end).savefig(path + '/sigma_squared.png')\n\n export.export_mean(mean = mean, filename = path + '/center.csv', z_start = z_start, z_end = z_end)\n export.export_cov(cov = cov, filename = path + '/cov.csv', z_start = z_start, z_end = z_end)\n\n plt.close('all')","def plot(self):\n\t\tplot_chain(self.database_path, self.temp_folder)\n\t\tplot_density(self.database_path, self.temp_folder, self.cal_params)","def plot_visualization(path_results, x_data, y_data, variant_mode, nb_classes, signal_test, args):\n\n\t#path_tsne = path_results + \"/Visualization/train/\" + str(args.step) + \"_2d.csv\"\n\t#data_frame = pd.read_csv(path_tsne)\n\t\n\tpath_maping = path_results + \"/Maping/\" + str(args.subject).split(\".txt\")[0] + \"/\"\n\tfilename = path_maping + \"maping_\" + str(args.step) + \"_\" + str(args.subject).split(\".txt\")[0] + \"_stick\" + str(args.stick) + \".png\"\n\n\tprint(\"path_save maping\", path_maping)\n\n\tif not os.path.exists(path_maping):\n\t\tos.makedirs(path_maping)\n\n\t#print(\"path_tsne\", path_tsne)\n\n\tlabel_maping = np.array([10])\n\n\tx_data = np.concatenate((x_data,signal_test),axis=0)\n\ty_data = np.concatenate((y_data,label_maping),axis=0)\n\n\tprint(\"x_data concatenate\",x_data.shape)\n\tprint(\"y_data concatenate\",y_data.shape)\n\n\tdata_frame = tsne_2d(x_data, y_data)\n\n\t\n\t\n\tgroups = data_frame.groupby('label')\n\n\tcluster_names, cluster_colors = get_target_names_dr(nb_classes, args.mode, args, variant_mode)\n\n\tfig = plt.figure(figsize=(20, 10))\n\tax = fig.add_subplot(111)\n\tax.margins(0.05) # Optional, just adds 5% padding to the autoscaling\n\tfor name, group in groups:\n\t\t\n\t\tif cluster_names[name] == str(args.subject):\n\t\t\tax.scatter(group.x, group.y, marker='D', s=150, edgecolors = 'face',label=cluster_names[name], color=cluster_colors[name])\n\t\telse:\n\t\t\tax.scatter(group.x, group.y, marker='o', label=cluster_names[name], color=cluster_colors[name])\n\n\tax.legend(numpoints=1) #show legend with only 1 point\n\tplt.savefig(filename) #save the plot","def plot_dat_file(dat_paths: [str]):\n import pandas as pd\n import matplotlib.pyplot as plt\n\n fig, ax = plt.subplots(1, 3, sharey=\"all\", sharex=\"col\", figsize=(8, 6))\n for i, dat_path in enumerate(dat_paths):\n if i == i:\n skipfoot = 11 + 9\n else:\n skipfoot = 11\n dat_file = pd.read_csv(\n dat_path,\n skiprows=3,\n skipfooter=skipfoot,\n header=None,\n delim_whitespace=True,\n engine=\"python\",\n )\n depth = dat_file.values[:, 0]\n vp = dat_file.values[:, 1]\n vs = dat_file.values[:, 3]\n dens = dat_file.values[:, 5]\n\n ax[0].plot(vp, depth, label=f\"nr {i}\")\n\n ax[1].plot(vs, depth)\n ax[2].plot(dens, depth)\n ax[0].set_ylim(ax[0].get_ylim()[::-1])\n ax[0].legend()\n plt.show()","def plot_directory_surface_rmse(path, vals, param='Vp'):\n\n unw = '/home/scott/data/insar/cvz/t2282/geo/geo_stack282_8rlks.unw'\n incidence = '/home/scott/data/insar/cvz/t2282/aux_files/geo_incidence_8rlks.unw'\n dem = '/home/scott/data/dems/cgiar/uturuncu_1000_1000.tif'\n #surface = '/home/scott/research/models/pylith/3d/uturuncu_layered/output/step01/surface.h5'\n #geosurface = '/home/scott/research/models/pylith/scripts/geo_fem_Uz.tif'\n\n plt.figure()\n outdirs = np.sort(os.listdir(path))\n\n # Calculate rmse\n rmse = np.zeros_like(vals)\n for i,outdir in enumerate(outdirs):\n surface = os.path.join(path,outdir,'surface.h5')\n los,fem_los,residual = pu.los2pylith(surface, dem, unw, incidence)\n rmse[i] = rms_flat(residual[np.isfinite(residual)])\n\n plt.plot(vals,rmse,'b.-')\n\n # Annotate\n #plt.title(param)\n plt.xlabel('{} [km]'.format(param))\n plt.ylabel('RMSE [cm]')\n plt.legend()\n plt.show()","def plot_results(dir_path):\n results, labels, dx = get_results_labels(dir_path)\n\n colors = plt.cm.get_cmap('tab10', len(labels)+1)\n fig = plt.figure(figsize=(16, 9))\n for i, (label, result) in enumerate(zip(labels, results)):\n plt.plot(np.arange(result.shape[1]) * dx, np.mean(result, 0),\n color=colors(i), linewidth=2, label=label)\n plt.fill_between(np.arange(len(result[0])) * dx,\n np.mean(result, 0) - np.std(result, 0),\n np.mean(result, 0) + np.std(result, 0),\n alpha=0.25, color=colors(i))\n plt.title('Training Performance of Different Algorithms', fontsize=25)\n plt.ylabel('Cumulative return', fontsize=20)\n plt.xlabel('Steps', fontsize=20)\n plt.xlim([0, results[0].shape[1] * dx])\n plt.tick_params(labelsize=15)\n plt.ticklabel_format(axis='both', style='sci', scilimits=(-2, 2))\n plt.legend(fontsize=20)\n plt.grid(linestyle=':')\n plt.show()\n\n return fig","def plot(cp_profile, *args, destination=\"browser\",\n show_profiles=True, show_observations=True, show_residuals=False, show_rugs=False,\n aggregate_profiles=None, selected_variables=None,\n color=None, size=2, alpha=0.4,\n color_pdps=None, size_pdps=None, alpha_pdps=None,\n color_points=None, size_points=None, alpha_points=None,\n color_residuals=None, size_residuals=None, alpha_residuals=None,\n height=500, width=600,\n plot_title='', yaxis_title='y',\n print_observations=True,\n **kwargs):\n\n params = dict()\n params.update(kwargs)\n params[\"variables\"] = _calculate_plot_variables(cp_profile, selected_variables)\n params['color'] = \"_label_\" if args else color\n params['show_profiles'] = show_profiles\n params['show_observations'] = show_observations\n params['show_rugs'] = show_rugs\n params['show_residuals'] = show_residuals and (cp_profile.new_observation_true is not None)\n params['add_table'] = print_observations\n params['height'] = height\n params['width'] = width\n params['plot_title'] = plot_title\n params['size_ices'] = size\n params['alpha_ices'] = alpha\n params = _params_update(params,\n color_pdps=color_pdps, size_pdps=size_pdps, alpha_pdps=alpha_pdps,\n size_points=size_points, alpha_points=alpha_points, color_points=color_points,\n size_residuals=size_residuals, alpha_residuals=alpha_residuals,\n color_residuals=color_residuals,\n yaxis_title=yaxis_title)\n\n if aggregate_profiles in {'mean', 'median', None}:\n params['aggregate_profiles'] = aggregate_profiles\n else:\n logging.warning(\"Incorrect function for profile aggregation: {}. Parameter ignored.\"\n \"Available values are: 'mean' and 'median'\".format(aggregate_profiles))\n params['aggregate_profiles'] = None\n\n all_profiles = [cp_profile] + list(args)\n\n plot_id = str(next(_PLOT_NUMBER))\n plot_path, params_path, obs_path, profile_path = _get_data_paths(plot_id)\n\n with open(params_path, 'w') as f:\n f.write(\"params = \" + json.dumps(params, indent=2) + \";\")\n\n save_observations(all_profiles, obs_path)\n save_profiles(all_profiles, profile_path)\n\n with app.app_context():\n data = render_template(\"plot_template.html\", i=plot_id, params=params)\n\n with open(plot_path, 'w') as f:\n f.write(data)\n\n destination = _detect_plot_destination(destination)\n if destination == \"notebook\":\n from IPython.display import IFrame, display\n display(IFrame(plot_path, width=int(width * 1.1), height=int(height * 1.1)))\n else:\n # open plot in a browser\n if sys.platform == \"darwin\": # check if on OSX\n plot_path = \"file://\" + os.path.abspath(plot_path)\n webbrowser.open(plot_path)","def combine_plot(qa_out_path,brain_path):\n \n #Get the scan volume of the brain.\n brain_ref = nib.load(brain_path)\n brain_ref_shape = brain_ref.shape[0:3]\n \n plots_list = ['Rotate_Z_axis_000000.png','Rotate_Z_axis_000001.png','Rotate_Z_axis_000002.png',\n 'Rotate_Y_axis_000000.png','Rotate_Y_axis_000001.png','Rotate_Y_axis_000002.png',\n 'Rotate_X_axis_000000.png','Rotate_X_axis_000001.png','Rotate_X_axis_000002.png']\n y_labels = [\"Rotate with Z axis\",\"Rotate with Y axis\",\"Rotate with X axis\"]\n x_labels = [\"angle=0\",\"angle=120\",\"angle=240\"]\n \n #Temporary list to store the image nparray:\n im_arr=[] \n \n fig= plt.figure()\n plt.title(f'QA_tractography. Scan volume = {brain_ref_shape} \\n\\n', fontsize=60,fontweight='bold')\n plt.xticks([])\n plt.yticks([])\n plt.axis(\"off\")\n\n j = 0\n for i in range(9):\n #Load in the nine images into a nparray one by one.\n im_arr = np.array(Image.open(qa_out_path + \"/\" + plots_list[i]))\n #Change the background of the image into black:\n im_arr = np.where(im_arr<=0.01, 255, im_arr) \n ax = fig.add_subplot(3,3,i+1)\n ax.imshow(im_arr,interpolation=\"none\",alpha=0.9)\n \n #Set the X labels and Y labels\n if i<3:\n ax.set_title(x_labels[i],fontsize=60,fontweight='bold')\n if i % 3 == 0:\n ax.set_ylabel(y_labels[j],fontsize=60,fontweight='bold')\n j = j + 1\n plt.xticks([])\n plt.yticks([])\n \n fig.set_size_inches(40, 40, forward = True)\n fig.savefig(qa_out_path + \"/\" + 'qa_tractography.png', format='png')\n\n #Delete the Nine images which used to generate the qa_tractography.png \n for plot in plots_list:\n if os.path.exists(qa_out_path + \"/\" + plot):\n os.remove(qa_out_path + \"/\" + plot)\n else:\n print('No such file generated from streamlines window. Please check if the streamline.trk files is generated from the pipeline correctly or not')","def matplotlib_plot(self, output_dir: Union[str, Path]):\n keys2 = set.union(*[set(self.get_keys2(k)) for k in self.get_keys()])\n for key2 in keys2:\n keys = [k for k in self.get_keys() if key2 in self.get_keys2(k)]\n plt = self._plot_stats(keys, key2)\n p = Path(output_dir) / f\"{key2}.png\"\n p.parent.mkdir(parents=True, exist_ok=True)\n plt.savefig(p)","def plot_parcles_run(k, v):\n\n L.info(f'Received Input: {v}')\n\n L.info(f\"Plotting results from: {v['filepath']}\")\n\n plotpath = Path(__file__).parent.parent / 'plots'\n filename = v['id'] + '.png'\n plotfile = str(plotpath / filename) \n\n plotTrajectoriesFile(v['filepath'], mode='2d', show_plt=False)\n f = plt.gcf()\n f.savefig(plotfile)\n\n L.info(f'Saved plot to: {plotfile}')","def plot_all_LLRs(self, outdir):\n\t\t#Iterate over all parameter groups\n\t\tfor group in self.group_names:\n\t\t\tself.plot_group_LLR(groupname=group, outdir=outdir)","def plot_track_rigidbody(params, datadir, pp=4, zoom=None):\n h = params['h']\n\n # get dirs\n xypath = sorted(glob.glob(datadir + 'xyv/'))[0]\n # list files\n xyfiles = sorted(glob.glob(xypath + '*.txt'))\n\n plt.clf()\n ax1 = plt.subplot(5, 1, 1)\n ax2 = plt.subplot(5, 1, 2)\n ax3 = plt.subplot(5, 1, 3)\n ax4 = plt.subplot(5, 1, 4)\n ax5 = plt.subplot(5, 1, 5)\n doall = range(0, len(xyfiles))\n for i in doall:\n iterind = (xyfiles[i].split('_')[-1]).split('.')[0]\n t = float(iterind) * h\n\n x, y, theta, phi, psi = np.loadtxt(xyfiles[i], delimiter=',', usecols=(0, 1, 2, 3, 4), unpack=True)\n # vX,vY,vtheta,vphi,vpsi = np.loadtxt(xyfiles[i],delimiter=',', usecols=(5,6,7,8,9), unpack=True)\n\n ax1.plot(t, x[pp], 'k.')\n ax2.plot(t, y[pp], 'r.')\n ax3.plot(t, theta[pp], 'r.')\n ax4.plot(t, phi[pp], 'r.')\n ax5.plot(t, psi[pp], 'g.')\n\n title = 'Tracking Single Gyro'\n ax1.set_title(title)\n ax5.set_xlabel('time')\n ax1.set_ylabel('X')\n ax2.set_ylabel('Y')\n ax3.set_ylabel(r'$\\theta$')\n ax4.set_ylabel(r'$\\phi$')\n ax5.set_ylabel(r'$\\psi$')\n\n ax1.set_xlim([-h, t])\n ax2.set_xlim([-h, t])\n ax3.set_xlim([-h, t])\n ax4.set_xlim([-h, t])\n ax5.set_xlim([-h, t])\n\n ax1.set_xticks([])\n ax2.set_xticks([])\n ax3.set_xticks([])\n ax4.set_xticks([])\n\n outname = datadir + 'Track.png'\n plt.savefig(outname)\n\n if zoom != None:\n ax1.set_xlim([-h, zoom])\n ax2.set_xlim([-h, zoom])\n ax3.set_xlim([-h, zoom])\n ax4.set_xlim([-h, zoom])\n ax5.set_xlim([-h, zoom])\n\n outname = datadir + 'Track_zoom.png'\n plt.savefig(outname)","def plot_pdf(pop_name, pop_val, pop_file, full_pop_file, outdir='.'):\n try:\n plt.style.use(\n \"https://gist.githubusercontent.com/avivajpeyi/4d9839b1ceb7d3651cbb469bc6b0d69b/raw/4ee4a870126653d542572372ff3eee4e89abcab0/publication.mplstyle\")\n except Exception:\n pass\n\n plt.close('all')\n all = pd.read_csv(full_pop_file, sep=\" \")\n all['cos_theta_1'] = all['cos_tilt_1']\n all = process_samples(all)\n sub = pd.read_csv(pop_file, sep=\" \")\n sub = process_samples(sub)\n sub['cos_theta_1'] = sub['cos_tilt_1']\n\n fig, axes = plt.subplots(1, 2, figsize=(10, 5))\n for ax, l in zip(axes, [\"cos_theta_1\", \"cos_theta_12\"]):\n ax.hist(all[l], density=True, histtype='step', color=\"tab:blue\", label=\"ALL\", lw=2, alpha=0.8)\n ax.scatter(all[l], [0 for _ in all[l]], color=\"tab:blue\",marker=\"+\")\n ax.hist(sub[l], density=True, histtype='step', color=\"tab:purple\", label=\"HIGH SNR\", lw=2, alpha=0.6)\n ax.scatter(sub[l], [0 for _ in sub[l]], color=\"tab:purple\", marker=\"+\")\n\n x = np.linspace(-1, 1, 100)\n y1 = TruncatedNormal(mu=1, sigma=pop_val[0], minimum=-1, maximum=1).prob(x)\n y2 = TruncatedNormal(mu=1, sigma=pop_val[1], minimum=-1, maximum=1).prob(x)\n axes[1].plot(x, y2, color='tab:gray', zorder=-10, lw=3, label=\"TRUE\")\n axes[0].plot(x, y1, color='tab:gray', zorder=-10, lw=3)\n\n for i in range(len(axes)):\n if (i == 0):\n axes[i].set_xlabel(r\"$\\cos\\ \\theta_1$\")\n axes[i].set_ylabel(\"PDF\")\n else:\n axes[i].set_xlabel(r\"$\\cos\\ \\theta_{12}$\")\n axes[i].set_yticklabels([])\n axes[i].legend()\n axes[i].grid(False)\n axes[i].set_xlim(-1, 1)\n\n plt.suptitle(f\"POP {pop_name}\")\n plt.tight_layout()\n plt.savefig(f\"{outdir}/pop_trues_{pop_name}.png\")","def plot_dir(main):\n try:\n wd = str(main.lineEdit_8.text())\n if wd == '':\n main.msg(\"Error \"+errorPath+\"plot_dir: Must choose directory first\")\n return\n for fi in os.listdir(wd):\n dataPath = os.path.join(wd, fi)\n main.msg(\"Plotting \"+str(fi))\n img = mpimg.imread(str(dataPath))\n imgObj = Img.Img(img, title=str(fi), filePath=str(dataPath))\n main.imgObjList.append(imgObj)\n func.update(main)\n slider.slider_update(main)\n except:\n main.msg(\"Error \"+errorPath+\"plot_dir: Make sure all files are images (tiff, jpeg, etc.)\")","def plot(path, subjects):\n transformToXYZmm = np.array([[-3.125, 0, 0, 81.250], [0, 3.125, 0, -115.625], [0, 0, 6, -54.000], [0, 0, 0, 1.000]])\n data = data_load.load_data(path, subjects)\n dimx = int(data[0][\"meta\"][\"dimx\"][0])\n dimy = int(data[0][\"meta\"][\"dimy\"][0])\n dimz = int(data[0][\"meta\"][\"dimz\"][0])\n coordToCol = data[0][\"meta\"][\"coordToCol\"][0][0]\n images = {}\n max_val = 0\n voxels = np.load(\"data/general_selected_500_1.npy\")\n directory = os.listdir(\"data/input/\")\n bar = pyprind.ProgBar(len(directory), title='Info extraction and Image Building')\n bar2 = pyprind.ProgBar(len(images.keys()), title='Saving Pictures')\n for file in directory:\n file_name = \"data/input/{}\".format(file)\n fh = open(file_name)\n activation_values = np.asarray(list(map(lambda x: float(x), filter(lambda x: x != '', fh.read().split(\",\")))))\n fh.close()\n plot_matrix = np.zeros((dimx, dimy, dimz))\n for x in range(dimx):\n for y in range(dimy):\n for z in range(dimz):\n indice = coordToCol[x][y][z]\n if indice != 0:\n if indice in list(voxels):\n voxel_indice = list(voxels).index(indice)\n value = activation_values[voxel_indice]\n if abs(value) > max_val:\n max_val = abs(value)\n plot_matrix[x][y][z] = value\n image = nib.Nifti1Image(plot_matrix, transformToXYZmm)\n images[file_name] = image\n bar.update(force_flush=True)\n print(bar)\n for image in images:\n plotting.plot_glass_brain(images[image], display_mode='ortho', vmax=max_val, plot_abs=False, threshold=None, colorbar=True, output_file=\"{}-wom1.png\".format(image))\n bar2.update(force_flush=True)\n print(bar2)","def plot_folder(folder, title, stochastic=True):\n results = open_folder(folder, stochastic=stochastic)\n assert len(results) > 0, 'Cannot find any results'\n ce_values = np.concatenate(\n [np.expand_dims(r.item()['train_xent'][:-1], 1) for r in results],\n axis=1)\n steps = np.concatenate(\n [np.expand_dims(r.item()['step'][:-1], 1) for r in results], axis=1)\n alpha_eff_values = np.concatenate(\n [\n np.expand_dims(r.item()['lr'] / (1.0 - r.item()['momentum']), 1)\n for r in results\n ],\n axis=1)\n condition = ['Manual', 'SMD']\n plot_report_figure_combined(\n steps,\n ce_values,\n alpha_eff_values,\n condition,\n title,\n 'Loss',\n 'Eff. Learning Rate',\n os.path.join(\n folder, 'combined_{}.pdf'.format('stoc' if stochastic else 'det')),\n include_legend=True)","def plot_PDs(output_path,M_max,max_dim,normalized=False,output_name=None):\n plots_folder = os.path.join(output_path,'plots')\n if output_name is None: \n aux = ['PDs']\n input_file = os.path.join(output_path,'outputs_PDS.csv')\n else:\n aux = [output_name,'PDs']\n input_file = os.path.join(output_path,'%s_PDS.csv' % output_name)\n if normalized is True:\n aux.append('normalized')\n plot_file_name = '-'.join(aux)+'.png'\n plot_file_name = os.path.join(plots_folder,plot_file_name)\n\n \n data = pd.read_csv(input_file,index_col = 0)\n \n\n fig_size_aux = 15/(3-max_dim)\n plt.figure(figsize=(fig_size_aux,5))\n if(normalized):\n for i in range(1,max_dim+2):\n plt.subplot(1,max_dim+1,i, aspect='equal')\n plt.plot(data[data.dimH==i-1].birth.values/np.float(M_max),data[data.dimH==i-1].death.values/np.float(M_max),'bo',alpha=.3,label='dim %i'%(i-1))\n plt.xlim((0,1)); plt.ylim((0,1))\n frame = plt.legend(loc=4,frameon=True,title='normalized')\n frame = frame.get_frame()\n frame.set_edgecolor('black')\n plt.xlabel('birth'); plt.ylabel('death')\n plt.plot([0, 1], [0, 1], ls=\"--\", c=\".3\")\n plt.suptitle('Persistence Diagrams')\n plt.savefig(plot_file_name)\n print 'Saved PDs plots in %s'%plot_file_name\n else:\n for i in range(1,max_dim+2):\n plt.subplot(1,max_dim+1,i, aspect='equal')\n plt.plot(data[data.dimH==i-1].birth.values,data[data.dimH==i-1].death.values,'bo',alpha=.3,label='dim %i'%(i-1))\n plt.xlim((0,M_max)); plt.ylim((0,M_max))\n frame = plt.legend(loc=4,frameon=True)\n frame = frame.get_frame()\n frame.set_edgecolor('black')\n plt.xlabel('birth'); plt.ylabel('death')\n plt.plot([0, M_max], [0, M_max], ls=\"--\", c=\".3\")\n plt.suptitle('Persistence Diagrams')\n plt.savefig(plot_file_name)\n print 'Saved PDs plots in %s'%plot_file_name\n return()","def plot_results(param_names, param_options, results, params):\n\n\t# circuit/run_num where run_num is one before the existing one\n\tdirectory = params.circuit\n\tif not os.path.isdir(directory):\n\t\tos.mkdir(directory)\n\truns = immediate_subdir(directory)\n\tlatest_run = 0\n\tif runs:\n\t\tnatural_sort(runs)\n\t\tlatest_run = get_trailing_num(runs[-1])\n\tdirectory = os.path.join(directory, \"run\" + str(latest_run+1))\n\n\tprint(directory)\n\tif not os.path.isdir(directory):\n\t\tos.mkdir(directory)\n\n\twith Chdir(directory):\n\n\t\texport_results_to_csv(param_names, results, params)\n\n\t\tx = results.keys()\n\t\ty = []\n\t\tnext_figure = True\n\n\t\tp = 0\n\t\tplt.figure()\n\t\twhile p < len(param_names):\n\t\t\tprint(param_names[p])\n\n\t\t\tif param_options[p]:\n\t\t\t\tnf = True\n\t\t\t\tfor option in param_options[p].split():\n\t\t\t\t\t# stopping has veto power (must all be True to pass)\n\t\t\t\t\tnf = nf and plot_options(option)\n\t\t\t\tnext_figure = nf\n\n\t\t\tif not next_figure:\n\t\t\t\t# y becomes list of lists (for use with stackable plots)\n\t\t\t\ty.append([result[p] for result in results.values()])\n\t\t\t\tp += 1\n\t\t\t\tcontinue\n\t\t\telif not y:\n\t\t\t\ty = [result[p] for result in results.values()]\n\n\t\t\tlx = x[-1]\n\t\t\tly = y[-1]\n\t\t\tplot_method(x,y)\n\t\t\tplt.xlabel('iteration')\n\t\t\tplt.xlim(xmin=0)\n\t\t\t\n\t\t\tplt.ylabel(param_names[p])\n\n\t\t\t# annotate the last value\n\t\t\tannotate_last(lx,ly)\n\n\t\t\tif next_figure:\n\t\t\t\tplt.savefig(param_names[p])\n\t\t\t\tplt.figure()\n\n\t\t\tp += 1\n\t\t# in case the last figure hasn't been shuffled onto file yet\n\t\tif not next_figure:\n\t\t\tplot_method(x,y)\n\t\t\tplt.savefig(param_names[-1])","def generateTrajectoryPlots(dir_path, traj_list, plot_name='scecliptic', plot_vg=True, plot_sol=True, \\\n plot_density=True, plot_showers=False):\n\n\n\n ### Plot Sun-centered geocentric ecliptic plots ###\n\n lambda_list = []\n beta_list = []\n vg_list = []\n sol_list = []\n\n shower_no_list = []\n shower_obj_dict = {}\n\n hypo_count = 0\n jd_min = np.inf\n jd_max = 0\n for traj in traj_list:\n\n # Reject all hyperbolic orbits\n if traj.orbit.e > 1:\n hypo_count += 1\n continue\n\n # Compute Sun-centered longitude\n lambda_list.append(traj.orbit.L_g - traj.orbit.la_sun)\n\n beta_list.append(traj.orbit.B_g)\n vg_list.append(traj.orbit.v_g/1000)\n sol_list.append(np.degrees(traj.orbit.la_sun))\n\n # Track first and last observation\n jd_min = min(jd_min, traj.jdt_ref)\n jd_max = max(jd_max, traj.jdt_ref)\n\n\n\n if plot_showers:\n\n # Perform shower association and track the list of all showers\n shower_obj = associateShowerTraj(traj)\n\n # If the trajectory was associated, sort it to the appropriate shower\n if shower_obj is not None:\n if shower_obj.IAU_no not in shower_no_list:\n shower_no_list.append(shower_obj.IAU_no)\n shower_obj_dict[shower_obj.IAU_no] = [shower_obj]\n else:\n shower_obj_dict[shower_obj.IAU_no].append(shower_obj)\n\n\n\n # Compute mean shower radiant for all associated showers\n shower_obj_list = []\n if plot_showers and shower_obj_dict:\n for shower_no in shower_obj_dict:\n\n # Check if there are enough shower members for plotting\n if len(shower_obj_dict[shower_no]) < MIN_SHOWER_MEMBERS:\n continue\n\n la_sun_mean = meanAngle([sh.la_sun for sh in shower_obj_dict[shower_no]])\n L_g_mean = meanAngle([sh.L_g for sh in shower_obj_dict[shower_no]])\n B_g_mean = np.mean([sh.B_g for sh in shower_obj_dict[shower_no]])\n v_g_mean = np.mean([sh.v_g for sh in shower_obj_dict[shower_no]])\n\n # Init a new shower object\n shower_obj_mean = MeteorShower(la_sun_mean, L_g_mean, B_g_mean, v_g_mean, shower_no)\n\n shower_obj_list.append(shower_obj_mean)\n\n\n\n print(\"Hyperbolic percentage: {:.2f}%\".format(100*hypo_count/len(traj_list)))\n\n # Compute the range of solar longitudes\n sol_min = np.degrees(jd2SolLonSteyaert(jd_min))\n sol_max = np.degrees(jd2SolLonSteyaert(jd_max))\n\n\n\n # Plot SCE vs Vg\n if plot_vg:\n plotSCE(lambda_list, beta_list, vg_list, (sol_min, sol_max), \n \"Sun-centered geocentric ecliptic coordinates\", \"$V_g$ (km/s)\", dir_path, plot_name + \"_vg.png\", \\\n shower_obj_list=shower_obj_list, plot_showers=plot_showers)\n\n\n # Plot SCE vs Sol\n if plot_sol:\n plotSCE(lambda_list, beta_list, sol_list, (sol_min, sol_max), \\\n \"Sun-centered geocentric ecliptic coordinates\", \"Solar longitude (deg)\", dir_path, \\\n plot_name + \"_sol.png\", shower_obj_list=shower_obj_list, plot_showers=plot_showers)\n \n\n \n # Plot SCE orbit density\n if plot_density:\n plotSCE(lambda_list, beta_list, None, (sol_min, sol_max), \n \"Sun-centered geocentric ecliptic coordinates\", \"Count\", dir_path, plot_name + \"_density.png\", \\\n density_plot=True, shower_obj_list=shower_obj_list, plot_showers=plot_showers)","def plot_directory_surface(path,figsize=(17,11), comp=2, nrow=1, norm=None,\n cbar='each', cloc='top', outname=None, labels='1', show=True):\n outdirs = np.sort(os.listdir(path))\n nplots = len(outdirs)\n ncol = np.ceil(nplots/nrow).astype(np.int)\n fig = plt.figure(figsize=figsize)\n\n grid = ImageGrid(fig, 111, # similar to subplot(111)\n nrows_ncols = (nrow, ncol),\n direction=\"row\",\n axes_pad = 0.25,\n add_all=True,\n label_mode = labels, #'all', 'L', '1'\n share_all = True,\n cbar_location=cloc, #top,right\n cbar_mode=cbar, #each,single,None\n cbar_size=0.1,#\"7%\",\n cbar_pad=0.0#,\"1%\",\n )\n\n #NOTE: if cbar='single',cloc='right', a way to automatically normalize by grid[0]\n #if normalize:\n # verts,data,tris = load_h5(os.path.join(path,'step01/surface.h5'))\n # if comp==3: #radial displacements\n # z = np.hypot(data[:,:,0], data[:,:,1]).flatten()\n # else:\n # z = data[:,:,comp].flatten()\n # norm = Normalize(vmin=np.nanmin(z), vmax=np.nanmax(z))\n #else:\n # norm=None\n\n for i,outdir in enumerate(outdirs):\n ax = grid[i]\n print(outdir)\n im = plotSurface(os.path.join(path,outdir,'surface.h5'), comp=comp, ax=ax,\n points=False, tris=False, profile=False, annotate=False, norm=norm,\n xscale=1e-3, yscale=1e-3)\n\n # colorbar settings, not sure what's up with set_xticks...\n ax.cax.colorbar(im)\n #cmin = np.nanmin(data)\n #cmax = np.nanmax(data)\n #ax.cax.set_xticks([cmin,0,cmax])\n\n # label upper left\n ax.text(0.05,0.95,outdir,\n weight='bold',\n ha='left',\n va='top',\n bbox=dict(facecolor='white'),\n transform=ax.transAxes)\n #ax.set_ylabel(outdir)\n #ax.tick_params(labelbottom=0,labeltop=0,labelleft=0,labelright=0,\n # bottom=0,top=0,left=0,right=0)\n\n #if cbar=='single':\n # grid[0].cax.colorbar(im)\n\n # Annotate Plot\n # don't show grid frames without data...\n Nextra = grid.ngrids - nplots\n if Nextra > 0:\n for ax in grid[-Nextra:]:\n #print(ax)\n ax.set_visible(False)\n ax.cax.set_visible(False)\n fig.suptitle(path, fontsize=14, fontweight='bold')\n if outname: plt.savefig(outname)\n if show: plt.show()","def plot_pipeline(differences_dir, plots_dir_intonation, num_quantiles = 31):\n perf_list = ['54363310_1939750539', '540791114_1793842568']\n difference_path_list = [os.path.join(differences_dir, perf_list[i] + \".npy\") for i in range(len(perf_list))]\n comparisons_list = [np.load(path) for _, path in enumerate(difference_path_list)]\n num_samples = 10000\n # quantile indices\n q_indices = (np.linspace(0, 1, num_quantiles)*(num_samples-1)).astype(np.int32)\n plt.style.use('ggplot')\n labels = ['perf. A', 'perf. B']\n colors = ['blue', 'red']\n linestyles = ['dotted', 'dashed']\n grid = plt.GridSpec(2, 2)\n ax1 = plt.subplot(grid[1, 0])\n ax2 = plt.subplot(grid[1, 1])\n ax4 = plt.subplot(grid[0, :])\n ax4.plot(comparisons_list[0], color=colors[0], label=labels[0], linestyle=linestyles[0])\n ax4.plot(comparisons_list[1], color=colors[1], label=labels[1], linestyle=linestyles[1])\n ax4.set_title(\"Difference between MIDI and pYIN, two performances\")\n ax4.set_ylabel(\"Cents\")\n ax4.set_xlabel(\"Frames\")\n ax4.axhline(y=200, linestyle=\"solid\", linewidth=0.7, c=\"black\", zorder=2, label=\"thresh.\")\n ax4.axhline(y=-200, linestyle=\"solid\", linewidth=0.7, c=\"black\", zorder=2)\n ax4.legend(loc=\"upper right\")\n ax1.set_title(\"10k random sample of distances\")\n ax1.set_ylabel(r\"$|$Cents$|$\")\n ax1.set_xlabel(\"Frames sorted by distance\")\n ax2.set_title(\"Sample quantiles\")\n ax2.set_xlabel(\"Quantile indices\")\n # run analysis song by song\n for i, arr in enumerate(comparisons_list):\n # random sample so all arrays have the same size\n samples = np.random.choice(arr, num_samples, replace=True)\n # sort\n samples = np.sort(np.abs(samples))\n # discard the high values (might be due to misalignment, etc...)\n samples = samples[samples <= 200]\n samples = np.random.choice(samples, num_samples, replace=True)\n samples = np.sort(np.abs(samples))\n ax1.plot(samples, color=colors[i], linestyle=linestyles[i], label=labels[i])\n # get the quantiles\n samples = samples[q_indices]\n ax2.plot(samples, color=colors[i], linestyle=linestyles[i], label=labels[i])\n ax1.legend()\n ax2.legend()\n plt.tight_layout()\n plt.savefig(os.path.join(plots_dir_intonation, \"data processing pipeline.eps\"), format=\"eps\")\n plt.show()","def plot(model, results, filename):\n\n # c = model.compartments.get_one(id='c')\n #\n # rna_1 = model.species_types.get_one(id='rna_1').species.get_one(compartment=c)\n # rna_2 = model.species_types.get_one(id='rna_2').species.get_one(compartment=c)\n # rna_3 = model.species_types.get_one(id='rna_3').species.get_one(compartment=c)\n #\n pops = results.get('populations')\n time = pops.index\n pop_rna_1 = pops['rna_1[c]']\n pop_rna_2 = pops['rna_2[c]']\n pop_rna_3 = pops['rna_3[c]']\n\n pop_atp = pops['atp[c]']\n pop_gtp = pops['gtp[c]']\n pop_utp = pops['ctp[c]']\n pop_ctp = pops['utp[c]']\n\n pop_amp = pops['amp[c]']\n pop_gmp = pops['gmp[c]']\n pop_ump = pops['cmp[c]']\n pop_cmp = pops['ump[c]']\n\n print(pop_rna_1, pop_atp, pop_gtp, pop_utp, pop_ctp)\n\n fig1, axes1 = pyplot.subplots(nrows=3, ncols=1)\n\n axes1[0].plot(time / 3600, pop_rna_1)\n axes1[0].plot(time / 3600, pop_rna_2)\n axes1[0].plot(time / 3600, pop_rna_3)\n axes1[0].set_xlim((time[0] / 3600, time[-1] / 3600))\n axes1[0].set_ylim((0., 10.0))\n axes1[0].legend(loc='upper right')\n\n axes1[1].plot(time / 3600, pop_atp)\n axes1[1].plot(time / 3600, pop_gtp)\n axes1[1].plot(time / 3600, pop_utp)\n axes1[1].plot(time / 3600, pop_ctp)\n axes1[1].set_xlim((time[0] / 3600, time[-1] / 3600))\n # axes1[1].set_ylim((0., 10.0))\n axes1[1].legend(loc='upper right')\n\n axes1[2].plot(time / 3600, pop_amp)\n axes1[2].plot(time / 3600, pop_gmp)\n axes1[2].plot(time / 3600, pop_ump)\n axes1[2].plot(time / 3600, pop_cmp)\n axes1[2].set_xlim((time[0] / 3600, time[-1] / 3600))\n # axes1[2].set_ylim((0., 10.0))\n axes1[2].legend(loc='upper right')\n\n fig1.savefig(filename.format('species'))\n pyplot.close(fig1)","def app_SN_combined_moisture_series(self, dfs, phase_dirs, sizer_val, styler_val):\n\n print('Currently plotting plot_SN_combined_moisture_series')\n\n for df, direc in zip(dfs, phase_dirs):\n # this iterates one or multiple times\n self.plotter.plot_SN_combined_moisture_series(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['01_combined_plots'],\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\n styler=self.formatter.styler[styler_val]\n )\n self.plotter.plot_SN_combined_moisture_series(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['01_combined_plots'],\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\n styler=self.formatter.styler[styler_val],\n xaxis_type='datetime'\n )\n\n print('Done\\n')","def plot_visco_profiles(pointsh5, skip=slice(None,None,1), xscale=1e3, yscale=1e-2, tscale=3.1536e7, adjustRadial=False, benchmark=[], title=None):\n\tplt.figure()\n\n\tcoords,data,number,times = pu.load_h5_visco(pointsh5)\n\n\t#x = 1e3*np.loadtxt(points,usecols=[0]) # output_points2.txt\n\t#y = np.zeros_like(x)\n\tx = coords[:,0]\n\ty = np.zeros_like(x)\n\n\t# NOTE: plot elastic solution by passing dictionary as showelastic\n\t# Plot analytic elastic solution (t=0)\n\t#print(benchmark)\n\tif len(benchmark)>=1:\n\t\tur = zeros_like(x)\n\t\tuz = np.zeros_like(x)\n\t\tfor b in benchmark:\n\t\t\turi,uzi = m.calc_mogi_dp(x,y,**params)\n\t\t\tur += uri\n\t\t\tuz += uzi\n\t\tplt.plot(x*xscale,uz*yscale,'ko',label='benchmark')\n\n\t# Convert units\n\t#ur = np.hypot(data[:,:,0], data[:,:,1]) #assume progiles are along EW profile\n\tur = data[:,:,0]\n\tuz = data[:,:,2]\n\tx = x / xscale\n\tur = ur / yscale #cm\n\tuz = uz / yscale #cm\n\ttimes = times / tscale\n\t#times = times / 8.64e4 #days\n\t#times = times / 31536000 #years\n\n\t#plots = np.arange(0,times.size,skip)\n\t#print(plots.size)\n\t#way to cycle through markers if plotting many lines\n\t#marker = itertools.cycle(['o','^','s','D']) #plot(marker=marker.next() iterates list)\n\t#way to use gradually changing colors from a colormap\n\t#color = plt.cm.jet(1.0*i/plots.size)\n\tindplots = np.arange(times.size-1)\n\tprint(indplots)\n\tindplots = indplots[skip]\n\tprint(indplots)\n\tfor i in indplots:\n\t\tline, = plt.plot(x, uz[i], color=plt.cm.jet(1.0*i/indplots[-1]), label='{:.1f}'.format(times[i]))\n\t\tplt.plot(x, ur[i], ls='dashed', color=line.get_color())\n\t#print uz[i]\n\t#print uz[i-1]\n\n\tif title:\n\t\tplt.title(title)\n\telse:\n\t\tplt.title(pointsh5)\n\n\tplt.axhline(color='k',linestyle='dashed')\n\tplt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n\tplt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n\tplt.show()\n\tplt.legend(title='{}'.format(get_unit(tscale)))\n\tplt.grid()","def multi_plot(self, plottitle, gof_fileroot, indir, outdir,\n legends, num_stations):\n # Pick components and labels\n xtick_loc = XTICK_LOC_0_01\n xtick_label = XTICK_LABEL_0_01\n\n # Initialize data arrays\n periods = [[] for _ in range(len(gof_fileroot))]\n bias = [[] for _ in range(len(gof_fileroot))]\n m90 = [[] for _ in range(len(gof_fileroot))]\n p90 = [[] for _ in range(len(gof_fileroot))]\n sigma = [[] for _ in range(len(gof_fileroot))]\n sigma0 = [[] for _ in range(len(gof_fileroot))]\n\n bias_l = [[] for _ in range(len(gof_fileroot))]\n bias_h = [[] for _ in range(len(gof_fileroot))]\n conf_l = [[] for _ in range(len(gof_fileroot))]\n conf_h = [[] for _ in range(len(gof_fileroot))]\n\n # Read data from all input files\n for compnum in xrange(0, len(gof_fileroot)):\n filenamebase = os.path.join(indir, gof_fileroot[compnum])\n #print(\"Reading component files %s.*\" % (filenamebase))\n periods[compnum], bias[compnum] = self.read_data(\"%s.bias\" %\n (filenamebase),\n 0.01)\n periods[compnum], m90[compnum] = self.read_data(\"%s.m90\" %\n (filenamebase),\n 0.01)\n periods[compnum], p90[compnum] = self.read_data(\"%s.p90\" %\n (filenamebase),\n 0.01)\n periods[compnum], sigma[compnum] = self.read_data(\"%s.sigma\" %\n (filenamebase),\n 0.01)\n periods[compnum], sigma0[compnum] = self.read_data(\"%s.sigma0\" %\n (filenamebase),\n 0.01)\n\n # Compute bias and conf interval lower/upper bounds\n for i in xrange(0, len(bias[compnum])):\n bias_l[compnum].append(bias[compnum][i] - sigma0[compnum][i])\n bias_h[compnum].append(bias[compnum][i] + sigma0[compnum][i])\n conf_l[compnum].append(m90[compnum][i])\n conf_h[compnum].append(p90[compnum][i])\n\n num_periods = len(periods[0])\n for comp in periods:\n if len(comp) != num_periods:\n print(\"Number of data points unequal across components\")\n return\n\n # Construct baseline\n baseline = [0.0 for _ in periods[0]]\n\n # Find max, min values\n min_x = min([min(comp) for comp in periods])\n max_x = max([max(comp) for comp in periods])\n min_y = MIN_Y_AXIS\n max_y = MAX_Y_AXIS\n\n # Start plots\n num_plots = len(gof_fileroot)\n # Make 1 column of \"num_plots\" rows\n fig, axs = pylab.plt.subplots(num_plots, 1)\n # Set plot dims\n fig.set_size_inches(6, 10)\n\n #subplots_adjust(left=0.125)\n #subplots_adjust(right=0.9)\n #subplots_adjust(top=0.85)\n fig.subplots_adjust(hspace=0.4)\n fig.subplots_adjust(wspace=0.5)\n\n # Add subplots in a list\n subfigs = []\n for idx in range(0, num_plots):\n subfigs.append(axs[idx])\n\n # Now walk through each subfig\n for (subfig, subplot_title, cur_period,\n cur_bias, cur_bias_h, cur_bias_l,\n cur_conf_h, cur_conf_l) in zip(subfigs,\n legends,\n periods,\n bias,\n bias_h,\n bias_l,\n conf_h,\n conf_l):\n subfig.set_xlim(min_x, max_x)\n subfig.set_ylim(min_y, max_y)\n subfig.set_title(\"%s\" % subplot_title, size=10)\n subfig.plot(cur_period, cur_bias, color='red', label='_nolegend_')\n subfig.fill_between(cur_period, cur_bias_h,\n cur_bias_l, color='cyan',\n label='_nolegend_')\n subfig.fill_between(cur_period, cur_conf_h,\n cur_conf_l, color='yellow',\n label='_nolegend_')\n subfig.plot(cur_period, baseline, color='grey',\n label='_nolegend_')\n # Only put xlabel on bottom plot\n if legends.index(subplot_title) == len(gof_fileroot) - 1:\n subfig.set_xlabel(\"Period (sec)\", size=8)\n subfig.set_ylabel(\"ln (data/model)\", size=8)\n subfig.set_xscale('log')\n # Old way to do it\n # subfig.set_xticks(xtick_loc, xtick_label)\n subfig.set_xticks(xtick_loc)\n subfig.set_xticklabels(xtick_label)\n subfig.tick_params(labelsize=8)\n subfig.minorticks_on()\n\n fig.suptitle('%s\\nNumber of stations: %d' % (plottitle, num_stations),\n size=12)\n # Figure out output filename\n outfile = gof_fileroot[0]\n outfile = outfile[:outfile.rfind(\"-\")]\n outfile = os.path.join(outdir, \"gof-%s.png\" % (outfile))\n print(\"==> Created GoF plot: %s\" % (outfile))\n fig.savefig(outfile, format=\"png\",\n transparent=False, dpi=plot_config.dpi)\n pylab.close()","def plot_profiles(snap, profs, dust_species_to_plot, debug=False):\n print('Plotting profiles...')\n\n units = {\n 'position': 'au',\n 'gas_velocity_radial_analytical': 'dimensionless',\n 'dust_velocity_radial_analytical': 'dimensionless',\n 'velocity_radial_numerical': 'dimensionless',\n }\n p = profs['gas'][0]\n\n if debug:\n num_dust = snap.num_dust_species\n ax = p.plot(x='radius', y=['velocity_pressure', 'velocity_visc'], units=units)\n y = ['gas_velocity_radial']\n y += [f'dust_velocity_radial_{idx+1:03}' for idx in range(num_dust)]\n ax = p.plot(x='radius', y=y, units=units)\n ax.legend().remove()\n\n fig, ax = plt.subplots()\n\n # Plot \"analytical\" radial drift velocity / velocity pressure component\n p.plot(\n x='radius',\n y='gas_velocity_radial_analytical',\n units=units,\n color='black',\n label='',\n ax=ax,\n )\n y = [f'dust_velocity_radial_analytical_{idx+1:03}' for idx in dust_species_to_plot]\n p.plot(x='radius', y=y, units=units, label='', ax=ax)\n colors = [line.get_color() for line in ax.lines[1:]]\n\n # Plot \"numerical\" radial drift velocity / velocity pressure component\n p.plot(\n x='radius',\n y='velocity_radial_numerical',\n units=units,\n color='black',\n linestyle='',\n marker='o',\n markersize=4,\n fillstyle='none',\n label='gas',\n std='shading',\n ax=ax,\n )\n profs_to_plot = [\n prof for idx, prof in enumerate(profs['dust']) if idx in dust_species_to_plot\n ]\n for species, prof, color in zip(dust_species_to_plot, profs_to_plot, colors):\n label = f'{snap.properties[\"grain_size\"][species].to(\"cm\"):.1f~P}'\n prof.plot(\n x='radius',\n y='velocity_radial_numerical',\n units=units,\n color=color,\n linestyle='',\n marker='o',\n markersize=4,\n fillstyle='none',\n label=label,\n std='shading',\n ax=ax,\n )\n\n ax.set_ylabel(r'$v_R / |v_P|$')\n ax.grid()\n\n textstr = f't = {snap.properties[\"time\"].to(\"years\").m:.0f} years'\n bbox = dict(boxstyle='round', facecolor='white', edgecolor='grey', alpha=0.8)\n ax.text(\n 0.97,\n 0.97,\n textstr,\n transform=ax.transAxes,\n horizontalalignment='right',\n verticalalignment='top',\n bbox=bbox,\n )\n ax.legend(framealpha=0.8, edgecolor='grey')\n\n return ax","def main():\n parser = argparse.ArgumentParser(description=\n ('Plot and save data from DS9 projections. If only labels are '\n 'given, it will just plot existing dat files.'\n 'Other regions/objects in file are ignored.'))\n\n parser.add_argument('infile', help='Input DS9 region file (fk5 coords)')\n parser.add_argument('datroot', help='Stem for output profile data')\n\n parser.add_argument('-p', '--pltroot', help='Stem for output plots')\n parser.add_argument('-f', '--files', help=('Files (.fits) to be processed,'\n ' one for each energy band'),\n nargs='*')\n\n parser.add_argument('-l', '--labels', help='Band labels for plots/files',\n nargs='+')\n parser.add_argument('-v', '--verbose', action='store_true',\n help='verbose mode')\n parser.add_argument('-s', '--subplot', action='store_true',\n help='Generate subplot plots')\n\n # Parse arguments\n args = parser.parse_args()\n regions_file = args.infile\n pltroot, datroot = args.pltroot, args.datroot\n bands, labels = args.files, args.labels # NOTE bands = args.files...\n verbose, subplot = args.verbose, args.subplot\n\n # Check arguments for sanity\n # If -p is supplied, output plots\n # If -b is supplied, output data\n if bands is None:\n if not pltroot:\n parser.error('Nothing to be done! Need bands or pltroot.')\n else:\n print 'No bands supplied, generating plots only'\n else:\n if len(bands) != len(labels):\n raise ValueError(('Non-zero number of bands '\n 'does not match number of labels!'))\n elif not pltroot:\n print 'No pltroot supplied, generating data only'\n\n # Parse projections\n rspecs = get_projection_params(regions_file)\n if verbose:\n print 'Projections parsed from region file'\n\n # Generate data files, if desired\n if bands is not None:\n regparse.check_dir(datroot, verbose) # only create if saving data\n generate_dat_files(rspecs, datroot, bands, labels)\n\n # Generate plots, if desired\n if pltroot:\n regparse.check_dir(pltroot, verbose)\n generate_plots(rspecs, datroot, pltroot, labels, verbose, subplot)\n\n if verbose:\n print 'Done!'","def plot_physical_profiles(self, fig=2):\n # Select the physical parameters\n phys_parms = ['temperature', 'salinity', 'theta', 'N']\n \n # Plot these parameters\n self.plot_profiles(phys_parms, fig)","def compare_hist_2(results_dir_root):\n plot_style = [\n {'color': 'k', 'marker': 'none', 'lw': 1.5},\n {'color': 'r', 'marker': 'none', 'lw': 1.5}\n ]\n unwrap_levels = ['r08']\n\n fig, axes = plt.subplots(figsize=(8, 10), nrows=5, ncols=2, sharex=True,\n sharey=False)\n fig.subplots_adjust(left=0.1, bottom=0.08, right=0.98, top=0.98,\n hspace=0.05, wspace=0.15)\n\n print(axes.shape)\n\n results_dirs = [results_dir_root + '_0h', results_dir_root + '_4h']\n\n fig.text(0.5, 0.02, r'Baseline length (m)', ha='center')\n fig.text(0.01, 0.5, r'Baseline count per bin', va='center',\n rotation='vertical')\n\n # Loop over models\n for i in range(7, 8):\n models = ['ska1_v5', 'model%02i' % (i + 1)]\n # Loop over 0h or 4h\n for j in range(1):\n idx = 0\n ax = axes[i, j]\n for model in models:\n # Load saved psf results.\n filename = join(results_dirs[j], '%s_uv_hist.p' % model)\n print('-- Loading: %s' % filename)\n hist = pickle.load(open(filename, 'rb'))\n # Plot comparison of PSF profiles.\n for tel in hist:\n if tel == 'ska1_v5' or any(s in tel for s in unwrap_levels):\n style = plot_style[idx % len(plot_style)]\n x = hist[tel]['log']['hist_x']\n y = hist[tel]['log']['hist_n']\n cut_idx = np.argmax(x > 5e3)\n x = x[:cut_idx]\n y = y[:cut_idx]\n ax.plot(x, y, color=style['color'],\n linestyle='-',\n label=tel + ' max')\n idx += 1\n length_str = 'snapshot' if j == 0 else '4 hours'\n ax.text(0.02, 0.95, ('SKA1 v5 vs. Model %i\\n' % (i + 1)) + length_str,\n weight='bold',\n ha='left', va='top', transform=ax.transAxes,\n fontsize='small')\n # ax.legend(loc='best', fontsize='small', ncol=1)\n # ax.set_xlabel('Baseline length (m)')\n # ax.set_ylabel('Number of baselines per bin')\n ax.set_xlim(10, 1e4)\n if j == 1:\n ax.set_ylim(1.5e3)\n if j == 0:\n ax.set_ylim(5)\n ax.set_yscale('log')\n ax.set_xscale('log')\n # if i == 4:\n # ax.set_xlabel('Baseline length (m)')\n # ax.set_ylabel('Baseline count per bin')\n ax.grid()\n plt.show(True)\n fig.savefig(join('compare_hist_%s.png' %\n ('_'.join(unwrap_levels))))\n plt.close(fig)","def plot_folder(path):\r\n plt.figure(figsize=(20, 10))\r\n for filename in glob.glob(path + '/*.pspec'):\r\n x, y= np.loadtxt(fname=filename, delimiter='\\t',dtype=int, usecols = (1,2),\r\n skiprows=100, unpack = True)\r\n plt.plot(x, y)\r\n return plt.show()","def make_plots(self):\n n_rounds = self.run.n_rounds\n\n log.info('Making %d frames', n_rounds)\n args = [self._get_for_parallel(i) for i in range(n_rounds)]\n self.lbv.map(_plot_helper, args)","def plot_skyplot(\n self,\n figure_name: str=\"plot_skyplot_{system}.{FIGURE_FORMAT}\",\n ) -> List[pathlib.PosixPath]:\n figure_paths = list()\n \n # Convert azimuth to range 0-360 degree\n azimuth = self.dset.site_pos.azimuth\n idx = azimuth < 0\n azimuth[idx] = 2 * np.pi + azimuth[idx]\n \n # Convert zenith distance from radian to degree\n zenith_distance = np.rad2deg(self.dset.site_pos.zenith_distance)\n \n # Generate x- and y-axis data per system\n for sys in sorted(self.dset.unique(\"system\")):\n x_arrays = []\n y_arrays = []\n labels = []\n \n figure_path = self.figure_dir / figure_name.replace(\"{system}\", sys).replace(\"{FIGURE_FORMAT}\", FIGURE_FORMAT)\n figure_paths.append(figure_path)\n \n for sat in sorted(self.dset.unique(\"satellite\")):\n if not sat.startswith(sys):\n continue\n idx = self.dset.filter(satellite= sat)\n x_arrays.append(azimuth[idx])\n y_arrays.append(zenith_distance[idx])\n labels.append(sat)\n \n # Plot with polar projection\n # TODO: y-axis labels are overwritten after second array plot. Why? What to do?\n plot(\n x_arrays=x_arrays,\n y_arrays=y_arrays,\n xlabel=\"\",\n ylabel=\"\",\n y_unit=\"\",\n labels=labels,\n figure_path=figure_path,\n opt_args={\n \"colormap\": \"hsv\",\n \"figsize\": (7, 7.5),\n \"legend\": True,\n \"legend_ncol\": 6,\n \"legend_location\": \"bottom\",\n \"plot_to\": \"file\",\n \"plot_type\": \"scatter\",\n \"projection\": \"polar\",\n \"title\": f\"Skyplot for {enums.gnss_id_to_name[sys]}\\n Azimuth [deg] / Elevation[deg]\",\n \"xlim\": [0, 2 * np.pi],\n \"ylim\": [0, 90],\n \"yticks\": (range(0, 90, 30)), # sets 3 concentric circles\n \"yticklabels\": (map(str, range(90, 0, -30))), # reverse labels from zenith distance to elevation\n },\n )\n \n return figure_paths","def main(self, args):\n for plot in args.plots:\n if plot == 'no_plot':\n break\n print \"plotting\", plot\n\n fig = self.plot_figure(plot)\n\n fformat = '{plot}_{index}.{ext}'\n fname = fformat.format(plot=plot, index=self.index, ext='png')\n fpath = os.path.join(plot_dir, fname)\n fig.savefig(fpath)\n\n if args.distributions == 'all':\n distributions = ['Uf', 'Wf', 'uf_abs',\n 'vorticity', 'vertical_shear']\n else:\n distributions = args.distributions\n for dist in distributions:\n range = self.properties[dist]['range']\n name = self.properties[dist]['name']\n print \"plotting distribution\", dist, name\n fig = self.plot_distribution(getattr(self, dist), range, name)\n\n fformat = 'distribution_{q}_{index}.{ext}'\n fname = fformat.format(q=dist, index=self.index, ext='png')\n fpath = os.path.join(plot_dir, fname)\n fig.savefig(fpath)\n\n if args.funcs:\n for func in args.funcs:\n print \"multiprocessing\", func\n f = getattr(self, 'plot_' + func)\n f()","def plotSpectrums2D(path_fsrcnn, path_liif, path_msrn, path_esrgan, path_bicubic, out_path):\n radial_FSRCNN = []\n radial_LIIF = []\n radial_MSRN = []\n radial_ESRGAN = []\n radial_BICUBIC = []\n\n for FSRCNN_path, LIIF_path, MSRN_path, ESRGAN_path, bicubic_path in zip(sorted(glob.glob(path_fsrcnn)), sorted(glob.glob(path_liif)), sorted(glob.glob(path_msrn)), sorted(glob.glob(path_esrgan)), sorted(glob.glob(path_bicubic))):\n print(FSRCNN_path)\n radialProfile_FSRCNN = spectrum2D(FSRCNN_path)\n print(len(radialProfile_FSRCNN))\n radial_FSRCNN.append(radialProfile_FSRCNN)\n print(LIIF_path)\n radialProfile_LIIF = spectrum2D(LIIF_path)\n radial_LIIF.append(radialProfile_LIIF)\n print(MSRN_path)\n radialProfile_msrn = spectrum2D(MSRN_path)\n radial_MSRN.append(radialProfile_msrn)\n print(ESRGAN_path)\n radialProfile_esrgan = spectrum2D(ESRGAN_path)\n radial_ESRGAN.append(radialProfile_esrgan)\n print(bicubic_path)\n radialProfile_bicubic = spectrum2D(bicubic_path)\n radial_BICUBIC.append(radialProfile_bicubic)\n\n image_name = FSRCNN_path.split('/')[-1]\n if not os.path.exists(out_path):\n os.makedirs(out_path)\n\n plt.figure()\n plt.plot(radialProfile_FSRCNN, label='FSRCNN')\n plt.plot(radialProfile_LIIF, label='LIIF')\n plt.plot(radialProfile_msrn, label='MSRN')\n plt.plot(radialProfile_esrgan, label='ESRGAN')\n plt.plot(radialProfile_bicubic, label='BICUBIC')\n plt.legend()\n plt.title(image_name)\n plt.yscale('log')\n plt.savefig(out_path + image_name)\n\n mean_FSRCNN = tolerant_mean(radial_FSRCNN)\n mean_LIIF = tolerant_mean(radial_LIIF)\n mean_MSRN = tolerant_mean(radial_MSRN)\n mean_ESRGAN = tolerant_mean(radial_ESRGAN)\n mean_BICUBIC = tolerant_mean(radial_BICUBIC)\n plt.figure()\n plt.plot(mean_FSRCNN, label='FSRCNN')\n plt.plot(mean_LIIF, label='LIIF')\n plt.plot(mean_MSRN, label='MSRN')\n plt.plot(mean_ESRGAN, label='ESRGAN')\n plt.plot(mean_BICUBIC, label='BICUBIC')\n plt.legend()\n plt.title('MEAN')\n plt.yscale('log')\n plt.savefig(out_path + 'mean')\n #return radialProfile_FSRCNN.shape, radialProfile_LIIF.shape, radialProfile_msrn.shape","def plot_profiles(self, parameters, fig=1):\n # Make sure the parameters are a list\n if isinstance(parameters, str) or isinstance(parameters, unicode):\n parameters = [parameters]\n \n # Decide how many subplots to create\n nrows = int(len(parameters) / 3)\n if len(parameters) % 3 > 0:\n nrows += 1\n \n # Initialize a figure for plotting\n width = 8\n height = 4 * nrows\n plt.figure(fig, figsize=(width, height))\n plt.clf()\n \n # Plot each parameter\n for parm in parameters:\n ax = plt.subplot(nrows, 3, parameters.index(parm)+1)\n self.plot_parameter(parm)\n \n plt.tight_layout()\n \n plt.show()","def PlotProfile():\n (metadata, data) = Parse('/tmp/sdcard-scalability.txt')\n gp = Gnuplot.Gnuplot(persist=1)\n gp('set data style impulses')\n gp('set xtics 1')\n gp('set pointsize 2')\n gp.clear()\n gp.xlabel('writer process')\n gp.ylabel('duration in second')\n gp.title(metadata.AsTitle())\n\n dataset = data[0]\n x = numpy.array(dataset.time, dtype='int_')\n d = Gnuplot.Data(x, dataset.data,\n title=dataset.name,\n with_='linespoints')\n gp.replot(d)\n gp.hardcopy('/tmp/%s-%s-%f.png' %\n (metadata.name, metadata.kernel, metadata.duration),\n terminal='png')","def stm_profile_plot(flat_file, points, scan_dir=0, cmap=None, vmin=None, vmax=None, xy_ticks=4, z_ticks=4):\n nm = 10 ** -9 # Define the nanometer to meter conversion.\n\n fig, ax = plt.subplots() # Create an instance of a pyplot figure and axis.\n\n # Set the minimum of the scan data to zero.\n figure_data = (flat_file[scan_dir].data - np.amin(flat_file[scan_dir].data)) / nm\n\n if cmap is None: # If no color scheme is given use hot as default.\n cmap = 'hot'\n\n if vmin is None: # If no z-axis minimum is given use minimum of the image data.\n vmin = np.amin(figure_data)\n if vmax is None: # If no z-axis maxmimum is given use 125% of the maximum in the image data.\n vmax = 1.25 * np.amax(figure_data)\n\n # Add image plot to the axis and define it so that the color map can be generated.\n cax = ax.imshow(figure_data, origin='lower', cmap=cmap, vmin=vmin, vmax=vmax)\n\n # Convert nanometer values into pixel numbers.\n for point in range(len(points)):\n points[point][0] = nm2pnt(points[point][0], flat_file, axis='x')\n points[point][1] = nm2pnt(points[point][1], flat_file, axis='y')\n\n # Plot the line profile points on the axis.\n ax.plot(points[:, 0], points[:, 1], 'bo-')\n\n xy_units = flat_file[scan_dir].info['unitxy'] # Get xy units.\n\n x_res = flat_file[scan_dir].info['xres'] # Get number of x-axis pixels.\n y_res = flat_file[scan_dir].info['yres'] # Get number of y-axis pixels.\n\n x_max = flat_file[scan_dir].info['xreal'] # Get x-axis image size.\n y_max = flat_file[scan_dir].info['yreal'] # get y-axis image size.\n\n # Set the x-axis ticks from number given.\n ax.set_xticks([x for x in np.arange(0, x_res + 1, x_res / xy_ticks)])\n # Set the x-axis tick labels from image size.\n ax.set_xticklabels([str(np.round(x, 1)) for x in np.arange(0, x_max + 1, x_max / xy_ticks)])\n\n # Set the y-axis ticks from number given\n ax.set_yticks([y for y in np.arange(0, y_res + 1, y_res / xy_ticks)])\n # Set the y-axis tick labels from image size.\n ax.set_yticklabels([str(np.round(y, 1)) for y in np.arange(0, y_max + 1, y_max / xy_ticks)])\n\n # Set the x- and y-axis labels.\n ax.set_xlabel(xy_units, size=16, weight='bold')\n ax.set_ylabel(xy_units, size=16, weight='bold')\n\n # Define the limits of the plot.\n ax.set_xlim([0, x_res])\n ax.set_ylim([0, y_res])\n\n # St the plot title with the image setpoint parameters.\n ax.set_title('Set-Points: {voltage} V, {current} pA'.format(voltage=flat_file[scan_dir].info['vgap'],\n current=np.round(\n flat_file[scan_dir].info['current']*10**12)))\n\n # Define list containing the z-axis ticks from number given.\n cbar_ticks = [z for z in np.arange(vmin, vmax * 1.01, vmax / z_ticks)]\n # Define the z-axis tick labels.\n cbar_ticklabels = [str(np.round(z, 1)) for z in np.arange(vmin, vmax + 1, vmax / z_ticks)]\n # Create color bar.\n cbar = fig.colorbar(cax, ticks=cbar_ticks)\n # Set the color bar tick labels.\n cbar.ax.set_yticklabels(cbar_ticklabels, size=16)\n # Set color bar label.\n cbar.set_label('Height [' + xy_units + ']', size=18, weight='bold')\n\n plt.show()","def generate_plots(self, env):\n print(' Generating diagnostic plots for : {0}'.format(self.__class__.__name__))\n\n # chdir into the working directory\n os.chdir(env['WORKDIR'])\n\n for nclPlotFile in self._ncl:\n # copy the NCL command to the workdir\n shutil.copy2('{0}/{1}'.format(env['NCLPATH'],nclPlotFile), '{0}/{1}'.format(env['WORKDIR'], nclPlotFile))\n\n nclFile = '{0}/{1}'.format(env['WORKDIR'],nclPlotFile)\n rc, err_msg = cesmEnvLib.checkFile(nclFile, 'read')\n if rc:\n try:\n print(' calling NCL plot routine {0}'.format(nclPlotFile))\n subprocess.check_call(['ncl', '{0}'.format(nclFile)], env=env)\n except subprocess.CalledProcessError as e:\n print('WARNING: {0} call to {1} failed with error:'.format(self.name(), nclFile))\n print(' {0}'.format(e.cmd))\n print(' rc = {0}'.format(e.returncode))\n else:\n print('{0}... continuing with additional plots.'.format(err_msg))","def app_SN_combined_temperature_series(self, dfs, phase_dirs, sizer_val, styler_val): # need to implement other options\n\n print('Currently plotting plot_SN_combined_temperature_series')\n\n for df, direc in zip(dfs, phase_dirs):\n # this iterates one or multiple times\n self.plotter.plot_SN_combined_temperature_series(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['01_combined_plots'],\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\n styler=self.formatter.styler[styler_val]\n )\n self.plotter.plot_SN_combined_temperature_series(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['01_combined_plots'],\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\n styler=self.formatter.styler[styler_val],\n xaxis_type='datetime'\n )\n\n print('Done\\n')","def make_plots(srcdir, outdir, include_subdir=False, level=3):\n srcfiles = get_ordered_srcfiles(srcdir, include_subdir)\n nodelist = get_f_nodelist(srcfiles)\n for n in nodelist:\n print(os.path.basename(n.name))\n for m in n.dependencies:\n print(' ' + os.path.basename(m.name))\n print('')\n\n if not os.path.isdir(outdir):\n raise Exception('output directory does not exist')\n\n for n in nodelist:\n filename = os.path.join(outdir, os.path.basename(n.name) + '.png')\n print('Creating ' + filename)\n graph = pydot.Dot(graph_type='digraph')\n node_dict = {}\n ilev = 0\n add_pydot_nodes(graph, node_dict, n, ilev, level)\n edge_set = set()\n ilev = 1\n add_pydot_edges(graph, node_dict, edge_set, n, ilev, level)\n graph.write_png(filename)\n\n return","def plots():\n out = interactive_output(generate_plots, {'gsize':gridSlider, 'ra':RABox, 'ra':RASlider, 'dec':DECBox, 'dec':DECSlider, 'ang':radBox, 'ang':radSlider, 'style':hexDrop})\n return display(widgrid, out)","def plotPaperFigures(folder='results/'):\n #model Example\n _AiryDisc(amplitude=1e6, center_x=10.0, center_y=10.0, radius=0.5, focus=0.4, size=21)\n _CCDkernel(CCDx=10, CCDy=10, width_x=0.35, width_y=0.4, size=21)\n plotModelExample()\n\n #simulation figures\n theta1 = (2.e5, 9.9, 10.03, 0.41, 0.51, 10., 10., 0.291, 0.335)\n try:\n _plotDifferenceIndividualVsJoined(individuals='simulatedResults/RunI*.pkl',\n joined='results/simulated800nmJoint.pkl',\n title='Simulated Data: CCD PSF Recovery', truthx=theta1[7], truthy=theta1[8],\n requirementE=None, requirementFWHM=None, requirementR2=None)\n _plotModelResiduals(id='RunI1', folder='simulatedResults/', out='Residual1.pdf', individual=True)\n except:\n print 'No simulated data to plot...'\n\n #real data\n _plotDifferenceIndividualVsJoined(individuals=folder+'I800nm?.pkl', joined=folder+'J800nm.pkl', title='800nm',\n FWHMlims=(7.3, 11.8))\n\n _plotModelResiduals(id='I800nm2', folder=folder, out='ResidualData.pdf', individual=True)\n _plotModelResiduals(id='RunI2', folder='simulatedResults/', out='Residual2.pdf', individual=True)\n\n #_plotModelResiduals(id='G600nm0', folder=folder, out='ResidualG600.pdf', individual=True)\n #_plotModelResiduals(id='G700nm0', folder=folder, out='ResidualG700.pdf', individual=True)\n _plotModelResiduals(id='G800nm0', folder=folder, out='ResidualG800.pdf', individual=True)\n #_plotModelResiduals(id='G890nm0', folder=folder, out='ResidualG890.pdf', individual=True)\n\n #wavelength dependency\n plotLambdaDependency()\n\n #brighter fatter\n plotBrighterFatter()","def generate_plots(rspecs, datroot, pltroot, labels,\n verbose=False, subplot=False):\n\n if subplot:\n n = len(labels)\n plt.figure(figsize=(4*n,4))\n else:\n plt.figure(figsize=(6,4))\n\n if verbose:\n print 'Generating {} plots...'.format(len(rspecs))\n print 'First plot will hang a little longer'\n\n # Make a plot for each region\n for i in xrange(len(rspecs)):\n # Plot line/points for each label\n for flab, j in zip(labels, xrange(n)):\n dat_fname = '{0}_{1:02d}_band_{2}.dat'.format(datroot, i+1, flab)\n a = np.loadtxt(dat_fname)\n if subplot:\n plt.subplot(1, n, j+1) # j indexes labels\n plt.plot(a[:,0], a[:,1], '-o') # Use default color cycle\n plt.title('Region {:g}, band {}'.format(i+1, flab))\n fplot('Radial dist. (?)', 'Intensity? (?)')\n else:\n plt.plot(a[:,0], a[:,1], '-o') # Use default color cycle\n # Format overall plot\n if not subplot:\n fplot('Radial dist. (?)', 'Intensity? (?)')\n plt.title('Region %g' % (i+1))\n plt.legend(labels, loc='best')\n plt.tight_layout()\n plt.savefig('{0}_{1:02d}.png'.format(pltroot, i+1), dpi=150)\n plt.clf()\n if verbose:\n print 'Saved: {0}_{1:02d}.png'.format(pltroot, i+1)","def plot_results(path: Path, output_dir: Path, skip: int = 100) -> Path:\n with xr.open_dataset(path) as ds:\n lons = ds.lon.values\n lats = ds.lat.values\n status = ds.status.values\n stranded_flag = get_stranded_flag_from_status(ds)\n\n _ = plt.figure(figsize=(10, 10))\n ax = plt.axes(projection=ccrs.PlateCarree(central_longitude=180))\n ax.set_extent(\n [-210, -140, 45, 75],\n crs=ccrs.PlateCarree()\n )\n nparticles = len(lons)\n if nparticles > skip:\n iter_particles = np.arange(0, nparticles, skip)\n else:\n iter_particles = np.arange(0, nparticles)\n\n for particle in iter_particles:\n # Create mask for stranded or not moving particles\n mask = np.logical_and(\n status[particle, :] <= 1,\n status[particle, :] >= 0\n )\n # Cannot save figure if you plot something that is completely masked\n # Cartopy will raise an error on save\n if not np.any(mask):\n continue\n ax.plot(\n lons[particle, mask],\n lats[particle, mask],\n color='g',\n transform=ccrs.PlateCarree()\n )\n\n # Starting position\n ax.scatter(\n ds.lon[particle, 0],\n ds.lat[particle, 0],\n c='b',\n transform=ccrs.PlateCarree()\n )\n stranded_ix = ds.status[particle, :] == stranded_flag\n\n # Stranded particles\n if np.any(stranded_ix):\n ax.scatter(\n ds.lon[particle, stranded_ix],\n ds.lat[particle, stranded_ix],\n c='r',\n transform=ccrs.PlateCarree()\n )\n\n ax.coastlines()\n ax.add_feature(cartopy.feature.LAND.with_scale('110m'))\n ax.gridlines(draw_labels=True)\n\n fname = path.name.replace('.nc', '.png')\n outpath = output_dir / fname\n\n plt.tight_layout()\n plt.savefig(outpath)\n plt.close()\n\n return outpath","def plot_path_statistics( self, path_file=\"tse_ensemble.json\" ):\n from matplotlib import pyplot as plt\n with open(path_file,'r') as infile:\n data = json.load(infile)\n try:\n paths = data[\"transition_paths\"]\n except KeyError:\n paths = [data]\n total_product_indicator = np.zeros(len(paths[0][\"symbols\"]))\n total_reactant_indicator = np.zeros(len(paths[0][\"symbols\"]))\n self.nuc_mc.min_size_product = paths[0][\"min_size_product\"]\n self.nuc_mc.max_size_reactant = paths[0][\"max_size_reactant\"]\n for path in paths:\n product_indicator = []\n reactant_indicator = []\n reactant_indicator, product_indicator = self.get_basin_indicators(path)\n\n total_product_indicator += np.cumsum(product_indicator)/float( len(product_indicator) )\n total_reactant_indicator += np.cumsum(reactant_indicator)/float( len(reactant_indicator) )\n\n total_reactant_indicator /= float( len(paths) )\n total_product_indicator /= float( len(paths) )\n\n fig = plt.figure()\n ax = fig.add_subplot(1,1,1)\n ax.plot( total_product_indicator, label=\"Product\" )\n ax.plot( total_reactant_indicator, label=\"Reactant\" )\n ax.set_xlabel( \"MC sweeps\" )\n ax.set_ylabel( \"Indicator\" )\n ax.spines[\"right\"].set_visible(False)\n ax.spines[\"top\"].set_visible(False)\n ax.legend( frameon=False, loc=\"best\" )\n return fig","def main():\n import argparse\n import os\n parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n parser.add_argument('--dirs', help='List of log directories', nargs='*', default=['./log'])\n parser.add_argument('--num_timesteps', type=int, default=int(10e6))\n parser.add_argument('--xaxis', help='Varible on X-axis', default=X_TIMESTEPS)\n parser.add_argument('--task_name', help='Title of plot', default='Breakout')\n args = parser.parse_args()\n args.dirs = [os.path.abspath(folder) for folder in args.dirs]\n plot_results(args.dirs, args.num_timesteps, args.xaxis, args.task_name)\n plt.show()","def save_plots(self):\n pdir = os.path.splitext(self.filename)[0] + '_plots'\n if not os.path.exists(pdir):\n os.mkdir(pdir)\n\n for ii in range(self.uv.n_ant):\n fig, ax = self.plot_single_baseline_dual_pol(ii+1, ii+1)\n print \"Saving ant %i\"%ii\n plt.savefig(os.path.join(pdir, 'ant-%i.png'%ii))\n plt.clf()","def app_SN_combined_temperature_gradient(self, dfs, phase_dirs, sizer_val, styler_val): # need to implement other options\n\n print('Currently plotting plot_SN_combined_temperature_gradient')\n\n for df, direc in zip(dfs, phase_dirs):\n # this iterates one or multiple times\n self.plotter.plot_SN_combined_temperature_gradient(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['01_combined_plots'],\n sizer=self.formatter.sizer[sizer_val]['3x1_partial_width'],\n styler=self.formatter.styler[styler_val],\n xscale=self.xscale_var.get()\n )\n\n print('Done\\n')","def Diagnostic_plot3(self):\n\n floc = glob.glob('/home/mxs191/Desktop/MathewSchofield/TRG/DetTest/DetTest1_results/Info2Save/*.csv')\n fig = plt.figure()\n plt.rc('font', size=18)\n #fig, ax = generalPlot(xaxis=r'$\\nu / \\mu$Hz', yaxis=r'$P_{\\rm det}$')\n gs = gridspec.GridSpec(1, 2, width_ratios=(4,1))\n ax = fig.add_subplot(gs[0])\n\n for idx, i in enumerate(floc):\n\n d = pd.read_csv(i)\n\n if idx == 0:\n fullpdet = d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']]\n else:\n fullpdet = pd.concat([ fullpdet,\\\n d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']] ])\n\n plt.scatter(d['f0'], d['Pdet_Kepler'], color='b',\\\n label=r\"$\\rm Kepler - 4\\ yrs$\" if idx == 0 else '')\n plt.scatter(d['f0'], d['Pdet_TESS365'], color='orange',\\\n label=r'$\\rm TESS - 1\\ yr$' if idx == 0 else '')\n plt.scatter(d['f0'], d['Pdet_TESS27'], color='g',\\\n label=r'$\\rm TESS - 27\\ days$' if idx == 0 else '')\n\n plt.axhline(fullpdet['Pdet_Kepler'].median(), color='b')\n plt.axhline(fullpdet['Pdet_TESS365'].median(), color='orange')\n plt.axhline(fullpdet['Pdet_TESS27'].median(), color='g')\n ax.legend(loc='lower right')\n plt.ylim([0,1])\n ax.set_ylabel(r'$P_{\\rm det}$')\n ax.set_xlabel(r'$\\nu / \\mu \\rm Hz$')\n\n bx = fig.add_subplot(gs[1])\n import seaborn as sns\n bw = 0.4\n sns.kdeplot(fullpdet['Pdet_Kepler'].values, shade=True, vertical=True, \\\n ax=bx, color='b', bw=bw)\n sns.kdeplot(fullpdet['Pdet_TESS365'].values, shade=True, vertical=True, \\\n ax=bx, color='orange', bw=bw)\n sns.kdeplot(fullpdet['Pdet_TESS27'].values, shade=True, vertical=True, \\\n ax=bx, color='g', bw=bw)\n bx.set_ylim([0.0,1.0])\n bx.set_xticks([])\n bx.set_yticks([])\n bx.set_xlabel(r'$\\rm Density$')\n plt.tight_layout()\n\n plt.show()\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\n 'DetTest_Diagnostic_plot3.pdf')\n sys.exit()","def plotPerLumiSection(options):\n name = options['name'] + '_perLS'\n f = openRootFileR(name)\n histname = plotName(options['title']+'_perLS', timestamp=False)\n filename = plotName(options['title']+'_perLS', timestamp=True)\n filepath = plotPath(options['title']+'_perLS', timestamp=True)\n print '<<< Save plot:', filepath\n hist = f.Get(histname)\n canvas = TCanvas()\n canvas.SetLogy(options['logy'])\n gStyle.SetOptStat(options['optstat'])\n hist.Draw()\n gPad.Update()\n hist.GetXaxis().SetTitle('Lumisection')\n hist.GetYaxis().SetTitle(options['ytitle'])\n hist.GetYaxis().SetTitleOffset(1.2)\n for axis in [hist.GetXaxis(), hist.GetYaxis()]:\n axis.SetTitleFont(133)\n axis.SetTitleSize(16)\n axis.SetLabelFont(133)\n axis.SetLabelSize(12)\n axis.CenterTitle()\n drawSignature(filename)\n gPad.Modified()\n gPad.Update()\n #canvas.Print(filepath)\n #canvas.Close()\n #closeRootFile(f, name)\n return [canvas, hist, f]","def plot_results(infer_images, inference_predicted_class, inference_predictions, class_names=['plants', 'water']):\n plt.style.use(['dark_background', 'bmh'])\n rc('figure', figsize=(8, 8), max_open_warning=False)\n rc('axes', facecolor='none')\n plt.figure(figsize=(15, 15))\n\n for i, (infer_img, _) in enumerate(infer_images.take(10)):\n ax = plt.subplot(5, 2, i + 1)\n plt.imshow(infer_img.numpy()/255)\n\n # Find the predicted class from predictions\n m = \"Predicted: {}, {:.2f}%\".format(\n class_names[inference_predicted_class[i]], inference_predictions[i]*100)\n plt.title(m)\n plt.axis(\"off\")\n plt.show()","def plot_visual_abstract():\n # Which generations to plot\n GENERATIONS = [100, 230, 350]\n\n # LunarLander CMA-ES\n experiment_path = glob(\"experiments/wann_LunarLander-v2_CMAES*\")\n assert len(experiment_path) == 1, \"There should be only one CMA-ES experiment with LunarLander-v2\"\n experiment_path = experiment_path[0]\n\n pivector_paths = glob(os.path.join(experiment_path, \"pivectors\", \"*\"))\n\n tsnes = []\n rewards = []\n for generation in GENERATIONS:\n # Find pivector files for specific generation, load them and store points\n generation_paths = [path for path in pivector_paths if \"gen_{}_\".format(generation) in path]\n\n population = [np.load(path) for path in generation_paths]\n population_tsnes = np.array([x[\"tsne\"] for x in population])\n population_rewards = np.array([x[\"average_episodic_reward\"] for x in population])\n tsnes.append(population_tsnes)\n rewards.append(population_rewards)\n\n figure, axs = pyplot.subplots(\n figsize=[2.5 * 3, 2.5],\n nrows=1,\n ncols=len(GENERATIONS),\n sharex=\"all\",\n sharey=\"all\"\n )\n\n min_reward = min(x.min() for x in rewards)\n max_reward = max(x.max() for x in rewards)\n scatter = None\n\n for idx in range(len(GENERATIONS)):\n population_tsne = tsnes[idx]\n population_rewards = rewards[idx]\n generation = GENERATIONS[idx]\n ax = axs[idx]\n\n scatter = ax.scatter(\n population_tsne[:, 0],\n population_tsne[:, 1],\n c=population_rewards,\n vmin=min_reward,\n vmax=max_reward,\n cmap=\"plasma\"\n )\n ax.set_title(\"Generation {}\".format(generation))\n ax.set_xticks([])\n ax.set_yticks([])\n ax.axis(\"off\")\n\n # Making room for colorbar\n # Stackoverflow #13784201\n figure.subplots_adjust(right=1.0)\n cbar = figure.colorbar(scatter)\n cbar.set_ticks([])\n cbar.ax.set_ylabel(\"Reward $\\\\rightarrow$\", rotation=90, fontsize=\"large\")\n\n figure.tight_layout()\n figure.savefig(\"figures/visual_abstract.pdf\", bbox_inches=\"tight\", pad_inches=0.05)","def plotting(self,job,input_zip,output_file,df,my_dpi):\n if len(job.Y2headers)>0:\n X1=df.loc[:,job.X1header].values\n X2=df.loc[:,job.X2header].values\n Y1=df.loc[:,job.Y1headers].values\n if (job.name.startswith(\"Morphine\") or job.name.startswith(\"Sarin\")) and os.path.exists(job.experimentalData):\n df2=pd.read_csv(job.experimentalData)\n Y2=np.array(df2.loc[:,job.Y2headers].values)\n X1=np.array(df2.loc[:,job.X1header].values[:Y2.shape[0]])\n Y1=np.array(df.loc[:,job.Y1headers].values[:Y2.shape[0]])\n X2=np.array(df.loc[:,job.X2header].values[:Y2.shape[0]])\n else:\n Y2=df.loc[:,job.Y2headers].values\n fig,ax = plt.subplots()\n fig.set_size_inches(w=job.imageWidth/my_dpi+3.1,h=job.imageHeight/my_dpi+1)\n \n if not os.path.exists(job.outputDir):\n os.mkdir(job.outputDir)\n \n if job.X1LowerBound and job.X1UpperBound:\n ax.set_xlim(job.X1LowerBound,job.X1UpperBound)\n elif job.X1LowerBound:\n ax.set_xlim(left=job.X1LowerBound)\n elif job.X1UpperBound:\n ax.set_xlim(right=job.X1UpperBound)\n\n if job.Y1LowerBound and job.Y1UpperBound:\n ax.set_ylim(job.Y1LowerBound,job.Y1UpperBound)\n elif job.Y1LowerBound:\n ax.set_ylim(bottom=job.Y1LowerBound)\n elif job.Y1UpperBound:\n ax.set_ylim(top=job.Y1UpperBound) \n \n ax.get_yaxis().set_major_locator(MaxNLocator(nbins=18,min_n_ticks=8))\n ax.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\n ax.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\n ax.set_xlabel(job.X1header,fontsize=job.fontSize)\n \n if job.Y1Label!=None:\n ax.set_ylabel(job.Y1Label,color=\"g\",fontsize=job.fontSize)\n else:\n ax.set_ylabel(job.Y1headers[0],color=\"g\",fontsize=job.fontSize)\n p1=ax.plot(X1,Y1,color=\"g\")\n\n ax2=ax.twinx()\n \n if job.Y2LowerBound and job.Y2UpperBound:\n ax2.set_ylim(job.Y2LowerBound,job.Y2UpperBound)\n elif job.Y2LowerBound:\n ax2.set_ylim(bottom=job.Y2LowerBound)\n elif job.Y2UpperBound:\n ax2.set_ylim(top=job.Y2UpperBound)\n \n ax2.get_yaxis().set_major_locator(MaxNLocator(nbins=18,min_n_ticks=8))\n ax2.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\n ax2.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\n ax2.set_xlabel(job.X1header,fontsize=job.fontSize)\n \n if job.Y2Label!=None:\n ax2.set_ylabel(job.Y2Label,color=\"b\",fontsize=job.fontSize)\n else:\n ax2.set_ylabel(job.Y2headers[0],color=\"b\",fontsize=job.fontSize)\n \n p2=ax2.plot(X2,Y2,color=\"b\")\n title=job.name+\"_\"\n title+=job.Y2headers[0]\n title = title + \"vs_\" + job.X1header\n \n if job.X2header != None and not job.X1header.lower() == job.X2header.lower():\n title = title + \"_\" + job.X2header\n # Override the constructed title if desired\n \n if job.titleOverride != None and not len(job.titleOverride)==0 and not job.titleOverride.lower() == \"None\".lower():\n title = job.titleOverride\n if job.log>=1:\n logging.info(\"Creating Graph:\"+title)\n \n if job.titleOverride !=\"None\":\n plt.title(title,fontsize=job.fontSize)\n \n if job.showGridLines:\n plt.grid(b=True, which='major', color='r', linestyle='--')\n \n if not job.removeAllLegends:\n p=p1+p2\n labs=[job.Y1headers[0],job.Y2headers[0]]\n ax.legend(p,labs)\n \n if \"(\" and \")\" in job.outputFilename:\n job.outputFilename=job.outputFilename.split(\"(\")[0]+\".jpg\"\n plt.savefig(os.path.join(job.outputDir,job.outputFilename),dpi=my_dpi)\n plt.close(\"all\")\n\n elif len(job.Y2headers)==0:\n X1=df.loc[:,job.X1header]\n Y1=df.loc[:,job.Y1headers]\n fig,ax = plt.subplots()\n fig.set_size_inches(w=job.imageWidth/my_dpi+3.1,h=job.imageHeight/my_dpi+1)\n \n if not os.path.exists(job.outputDir):\n os.mkdir(job.outputDir)\n \n if job.X1LowerBound and job.X1UpperBound:\n ax.set_xlim(job.X1LowerBound,job.X1UpperBound)\n elif job.X1LowerBound:\n ax.set_xlim(left=job.X1LowerBound)\n elif job.X1UpperBound:\n ax.set_xlim(right=job.X1UpperBound)\n\n if job.Y1LowerBound and job.Y1UpperBound:\n ax.set_ylim(job.Y1LowerBound,job.Y1UpperBound)\n elif job.Y1LowerBound:\n ax.set_ylim(bottom=job.Y1LowerBound)\n elif job.Y1UpperBound:\n ax.set_ylim(top=job.Y1UpperBound) \n \n ax.get_yaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=8))\n ax.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\n ax.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\n ax.set_xlabel(job.X1header,fontsize=job.fontSize)\n ax.set_ylabel(job.Y1headers[0],fontsize=job.fontSize)\n p=ax.plot(X1,Y1)\n title=job.name+\"_\"\n title = title + \"vs_\" + job.X1header\n \n if job.X2header != None and not job.X1header.lower() == job.X2header.lower():\n title = title + \"_\" + job.X2header\n \n # Override the constructed title if desired\n if job.titleOverride != None and not len(job.titleOverride)==0 and not job.titleOverride.lower() == \"None\".lower():\n title = job.titleOverride\n if job.log>=1:\n logging.info(\"Creating Graph:\"+title)\n \n if job.titleOverride !=\"None\":\n plt.title(title,fontsize=job.fontSize)\n \n if job.showGridLines:\n plt.grid(b=True, which='major', color='r', linestyle='--')\n \n if not job.removeAllLegends:\n labs=job.Y1headers\n plt.legend(p,labs)\n \n if \"(\" and \")\" in job.outputFilename:\n job.outputFilename=job.outputFilename.split(\"(\")[0]+\".jpg\"\n plt.savefig(os.path.join(job.outputDir,job.outputFilename),dpi=my_dpi)\n plt.close(\"all\")\n \n else:\n X1=df.loc[:,job.X1header]\n Y1=df.loc[:,job.Y1headers]\n fig,ax = plt.subplots()\n fig.set_size_inches(w=job.imageWidth/my_dpi+3.1,h=job.imageHeight/my_dpi+1)\n \n if not os.path.exists(job.outputDir):\n os.mkdir(job.outputDir)\n \n if job.X1LowerBound and job.X1UpperBound:\n ax.set_xlim(job.X1LowerBound,job.X1UpperBound)\n elif job.X1LowerBound:\n ax.set_xlim(left=job.X1LowerBound)\n elif job.X1UpperBound:\n ax.set_xlim(right=job.X1UpperBound)\n\n if job.Y1LowerBound and job.Y1UpperBound:\n ax.set_ylim(job.Y1LowerBound,job.Y1UpperBound)\n elif job.Y1LowerBound:\n ax.set_ylim(bottom=job.Y1LowerBound)\n elif job.Y1UpperBound:\n ax.set_ylim(top=job.Y1UpperBound) \n \n ax.get_yaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=8))\n ax.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\n ax.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\n ax.set_xlabel(job.X1header,fontsize=job.fontSize)\n ax.set_ylabel(job.Y1headers[0],fontsize=job.fontSize)\n p1=ax.plot(X1,Y1)\n title=job.name+\"_\"\n title = title + \"vs_\" + job.X1header\n \n if job.X2header != None and not job.X1header.lower() == job.X2header.lower():\n title = title + \"_\" + job.X2header\n \n # Override the constructed title if desired\n if job.titleOverride != None and not len(job.titleOverride)==0 and not job.titleOverride.lower() == \"None\".lower():\n title = job.titleOverride\n if job.log>=1:\n logging.info(\"Creating Graph:\"+title)\n \n if job.titleOverride !=\"None\":\n plt.title(title,fontsize=job.fontSize)\n \n if job.showGridLines:\n plt.grid(b=True, which='major', color='r', linestyle='--')\n \n if not job.removeAllLegends:\n labs=job.Y1headers\n ax.legend(p1, labs)\n \n if \"(\" and \")\" in job.outputFilename:\n job.outputFilename=job.outputFilename.split(\"(\")[0]+\".jpg\"\n plt.savefig(os.path.join(job.outputDir,job.outputFilename),dpi=my_dpi)\n plt.close(\"all\")","def generate_plots(self, headers: [str], barplot_name: str, barplot_data: [int],\n lineplot_name: str, multi_data: [[int]]):\n self.export_data(barplot_name, headers, barplot_data)\n title = 'Total IRTs (' + str(C.MAX_ITERATIONS) + ' Steps)'\n self.barplot(barplot_name, y_label='Total IRT', img_title=title)\n self.lineplot(lineplot_name, headers, multi_data, img_title='IRT Paths')","def plot_rates(save_dir, formation_rate, merger_rate, detection_rate, redshifts, chirp_masses, show_plot = False, mu0=0.035, muz=-0.23, sigma0=0.39, sigmaz=0., alpha=0):\n # sum things up across binaries\n total_formation_rate = np.sum(formation_rate, axis=0)\n total_merger_rate = np.sum(merger_rate, axis=0)\n total_detection_rate = np.sum(detection_rate, axis=0)\n \n # and across redshifts\n cumulative_detection_rate = np.cumsum(total_detection_rate)\n detection_rate_by_binary = np.sum(detection_rate, axis=1)\n\n ###########################\n #Start plotting\n\n # set some constants for the plots\n plt.rc('font', family='serif')\n fs = 20\n lw = 3\n\n fig, axes = plt.subplots(2, 2, figsize=(20, 20))\n\n axes[0,0].plot(redshifts, total_formation_rate, lw=lw)\n axes[0,0].set_xlabel('Redshift', fontsize=fs)\n axes[0,0].set_ylabel(r'Formation rate $[\\rm \\frac{\\mathrm{d}N}{\\mathrm{d}Gpc^3 \\mathrm{d}yr}]$', fontsize=fs)\n\n axes[0,1].plot(redshifts, total_merger_rate, lw=lw)\n axes[0,1].set_xlabel('Redshift', fontsize=fs)\n axes[0,1].set_ylabel(r'Merger rate $[\\rm \\frac{\\mathrm{d}N}{\\mathrm{d}Gpc^3 \\mathrm{d}yr}]$', fontsize=fs)\n\n axes[1,0].plot(redshifts[:len(cumulative_detection_rate)], cumulative_detection_rate, lw=lw)\n axes[1,0].set_xlabel('Redshift', fontsize=fs)\n axes[1,0].set_ylabel(r'Cumulative detection rate $[\\rm \\frac{\\mathrm{d}N}{\\mathrm{d}yr}]$', fontsize=fs)\n\n axes[1,1].hist(chirp_masses, weights=detection_rate_by_binary, bins=25, range=(0, 50))\n axes[1,1].set_xlabel(r'Chirp mass, $\\mathcal{M}_c$', fontsize=fs)\n axes[1,1].set_ylabel(r'Mass distribution of detections $[\\rm \\frac{\\mathrm{d}N}{\\mathrm{d}\\mathcal{M}_c \\mathrm{d}yr}]$', fontsize=fs)\n\n #########################\n #Plotvalues\n\n # Add text upper left corner\n axes[0,0].text(0.05,0.8, \"mu0=%s \\nmuz=%s \\nsigma0=%s \\nsigmaz=%s \\nalpha=%s\"%(mu0,muz,sigma0,sigmaz,alpha), transform=axes[0,0].transAxes, size = fs) \n\n for ax in axes.flatten():\n ax.tick_params(labelsize=0.9*fs)\n\n # Save and show :)\n plt.savefig(save_dir +'Rate_Info'+\"mu0%s_muz%s_alpha%s_sigma0%s_sigmaz%s\"%(mu0,muz,alpha,sigma0, sigmaz)+'.png', bbox_inches='tight') \n if show_plot:\n plt.show()\n else:\n plt.close()","def radial_graph(self):\n \n if self['M_RADIAL']['intens'] != None:\n name = self['name']\n id = self._getGraphId()\n figname = 'RADIAL_%s.eps' % id\n sxlabel = 'Pixel Radius' ; sylabel = 'Intens' \n title = 'Radial profile, %s' % (name,)\n y = self['M_RADIAL']['intens']\n x = self['M_RADIAL']['radii']\n xy = ((x,y),)\n Plot(xy,figname,sxlabel,sylabel,title)\n self['figures']['radial'] = figname\n else : pass","def plot_tiltres(setup, mtilt, ytilt, yfit, slit=None, outfile=None, show_QA=False, out_dir=None):\n\n plt.rcdefaults()\n plt.rcParams['font.family']= 'times new roman'\n\n # Outfil\n method = inspect.stack()[0][3]\n if (outfile is None) and (not show_QA):\n outfile = qa.set_qa_filename(setup, method, slit=slit, out_dir=out_dir)\n\n # Setup\n plt.figure(figsize=(8, 4.0))\n plt.clf()\n ax = plt.gca()\n\n # Scatter plot\n res = (mtilt-ytilt) - yfit\n ax.scatter(mtilt, res)\n\n rms = np.std(res)\n ax.text(0.90, 0.90, 'Slit {:d}: RMS (pix) = {:0.5f}'.format(slit, rms),\n transform=ax.transAxes, size='large', ha='right', color='black')\n # Label\n ax.set_xlabel('Row')\n ax.set_ylabel('Residual (pix)')\n\n # Finish\n plt.tight_layout(pad=0.2, h_pad=0.0, w_pad=0.0)\n if show_QA:\n plt.show()\n else:\n plt.savefig(outfile, dpi=400)\n plt.close()\n\n plt.rcdefaults()\n\n return","def make_posterior_plots(self, combined=False):\n import matplotlib.pyplot as plt\n plt.rcParams['text.usetex'] = True\n\n if combined:\n outdir = os.path.join(self.outdir, 'CombinedPosteriors')\n maintitle = self.make_main_title(end='Posteriors')\n else:\n outdir = os.path.join(self.outdir, 'IndividualPosteriors')\n maintitle = self.make_main_title(end='Posterior')\n mkdir(outdir)\n\n for injkey in self.values.keys():\n for fhkey in self.values[injkey].keys():\n # Set up multi-plot if needed\n if combined:\n num_rows = self.get_num_rows(\n data=self.values[injkey][fhkey],\n omit_metric=False\n )\n plt.figure(figsize=(20, 5*num_rows+2))\n subplotnum = 1\n else:\n subplotnum = None\n # Loop through the systematics\n for systkey in self.values[injkey][fhkey].keys():\n fittitle = self.make_fit_title(\n fhkey=fhkey,\n trials=self.num_trials\n )\n systunits = self.values[injkey][fhkey][systkey]['units']\n if systkey == 'metric_val':\n xlabel = self.tex_axis_label(\n self.values[injkey][fhkey][systkey]['type']\n )\n else:\n xlabel = self.tex_axis_label(systkey)\n if not systunits == 'dimensionless':\n xlabel += r' (%s)'%self.tex_axis_label(systunits)\n # Specify the subplot, if necessary\n if combined:\n plt.subplot(num_rows, 4, subplotnum)\n self.make_1d_hist_plot(\n data=np.array(\n self.values[injkey][fhkey][systkey]['vals']\n ),\n xlabel=xlabel,\n title=maintitle+r'\\\\'+fittitle,\n ylabel='Number of Trials',\n subplotnum=subplotnum\n )\n # Add the details i.e. injected/fiducial lines and priors\n plt.ylim(0, 1.35*plt.ylim()[1])\n if not systkey == 'metric_val':\n self.add_inj_fid_lines(\n injkey=injkey,\n systkey=systkey,\n fhkey=fhkey\n )\n self.add_prior_region(\n injkey=injkey,\n systkey=systkey,\n fhkey=fhkey\n )\n plt.legend(\n loc='upper left',\n fontsize=12,\n framealpha=1.0\n )\n plt.subplots_adjust(\n left=0.10,\n right=0.90,\n top=0.85,\n bottom=0.11\n )\n # Advance the subplot number, if necessary\n if combined:\n subplotnum += 1\n # Else, save/close this plot\n else:\n self.save_plot(\n fhkey=fhkey,\n outdir=outdir,\n end='%s_posterior'%systkey\n )\n plt.close()\n # Save the whole canvas, if necessary\n if combined:\n plt.suptitle(maintitle+r'\\\\'+fittitle, fontsize=36)\n plt.tight_layout()\n plt.subplots_adjust(top=0.9)\n self.save_plot(\n fhkey=fhkey,\n outdir=outdir,\n end='posteriors'\n )\n plt.close()","def plot_analysis(opt):\n LOG.debug(\"Plotting GetLLM analysis.\")\n mdl_analysis = opt.subnode in mdl_subnodes\n\n ps.set_style(\"standard\", MANUAL_STYLE)\n xmin = min(opt.xplot_xmin, opt.yplot_xmin)\n xmax = max(opt.xplot_xmax, opt.yplot_xmax)\n\n gs = gridspec.GridSpec(2, 1, height_ratios=[1, 1])\n ax_x = plt.subplot(gs[0])\n ax_y = None\n ir_pos = None\n\n paths = opt.path.split(',')\n\n if opt.label == 'None':\n if mdl_analysis:\n labels = [\"mo_\" + opt.path.rsplit('/', 1)[-1], \"me_\" + opt.path.rsplit('/', 1)[-1]]\n else:\n labels = paths\n else:\n labels = opt.label.split(',')\n\n for idx, path in enumerate(paths):\n data_x, data_y = get_data(path, opt.mainnode, opt.subnode)\n plot_data(ax_x, data_x, labels, idx, opt.change_marker)\n\n if ir_pos is None:\n ir_pos = get_irpos(data_x, opt.accel)\n\n if data_y is not None:\n if ax_y is None:\n ax_x.axes.get_xaxis().set_visible(False)\n ax_y = plt.subplot(gs[1])\n plot_data(ax_y, data_y, labels, idx, opt.change_marker)\n\n ax_x.set_xlim(xmin, xmax)\n ax_x.set_ylim(opt.xplot_ymin, opt.xplot_ymax)\n set_yaxis_label(ax_x, 'x', opt.subnode)\n\n if ax_y is not None:\n ax_y.set_xlim(xmin, xmax)\n ax_y.set_ylim(opt.yplot_ymin, opt.yplot_ymax)\n set_yaxis_label(ax_y, 'y', opt.subnode)\n ps.set_xaxis_label(ax_y)\n if ir_pos:\n ps.show_ir(ir_pos, ax_y, mode='outside')\n ps.show_ir(ir_pos, ax_x, mode='lines')\n else:\n ax_x.axes.get_xaxis().set_visible(True)\n ps.set_xaxis_label(ax_x)\n if ir_pos:\n ps.show_ir(ir_pos, ax_x, mode='outside')\n\n if int(opt.legendh) > 12:\n show_legend(ax_x, int(opt.legendx), int(opt.legendy))\n return gs","def plot(self, **kwargs):\n\n # get colors\n colors = kwargs.get(\"colors\", GW_OBSERVATORY_COLORS)\n\n # get Result samples\n self._samples = {\n label: value.posterior\n for label, value in self.results.items()\n if isinstance(value, Result)\n }\n\n # get Grid posteriors\n self._grids = {\n label: [value, value.ln_evidence] # store grid and log evidence\n for label, value in self.results.items()\n if isinstance(value, Grid)\n }\n\n # apply offsets for slightly nicer plots axes\n self.parameter_offsets = {parameter: 0.0 for parameter in self.parameters}\n if len(self._grids) == 0 and len(self._samples) == 1:\n for label in self._samples:\n for parameter in self.parameters:\n srange = [\n np.min(self._samples[label][parameter]),\n np.max(self._samples[label][parameter]),\n ]\n label_suffix = \"\"\n\n # offset values\n median = np.median(self._samples[label][parameter])\n relwidth = np.abs((srange[1] - srange[0]) / median)\n\n if relwidth < 1e-4:\n offsetstr = f\"{median:.4e}\"\n a, b = offsetstr.split(\"e\")\n\n if np.abs(int(b)) < 3:\n offsetstr = f\"{median:.4f}\"\n offset = float(offsetstr)\n else:\n offset = float(offsetstr)\n offsetstr = a + rf\"\\!\\times\\!10^{{{int(b)}}}\"\n\n self.parameter_offsets[parameter] = offset\n\n self._samples[label][parameter] -= offset\n label_suffix = rf\" [${{\\scriptstyle {offsetstr}}}$]\"\n\n self.latex_labels[parameter] += label_suffix\n\n colordicts = []\n for j, res in enumerate([self._samples, self._grids]):\n colordicts.append({})\n for i, key in enumerate(res):\n if key in colors:\n colordicts[-1][key] = colors[key]\n elif key.lower() == \"joint\":\n # if using \"Joint\" as the multi-detector analysis key, set the color to black\n colordicts[-1][key] = \"k\"\n else:\n # use PESummary color cycle\n colordicts[-1][key] = list(colorcycle)[\n (j * 2 + i) % len(colorcycle)\n ]\n\n # store original keywords arguments\n origkwargs = kwargs.copy()\n\n # plot samples\n fig = None\n if len(self._samples) > 0:\n kwargs[\"colors\"] = list(colordicts[0].values())\n if self._num_parameters == 1:\n fig = self._1d_plot_samples(**kwargs)\n elif self._num_parameters == 2 and self.plottype != \"corner\":\n fig = self._2d_plot_samples(**kwargs)\n else:\n fig = self._nd_plot_samples(**kwargs)\n\n # restore keywords\n kwargs = origkwargs\n\n if len(self._grids) > 0:\n kwargs[\"colors\"] = list(colordicts[1].values())\n if fig is not None and \"fig\" not in kwargs:\n kwargs[\"fig\"] = fig\n if self._num_parameters == 1:\n fig = self._1d_plot_grid(**kwargs)\n elif self._num_parameters == 2 and self.plottype != \"corner\":\n fig = self._2d_plot_grid(**kwargs)\n else:\n fig = self._nd_plot_grid(**kwargs)\n\n # add further figure information\n if self._num_parameters == 1:\n ax = fig.gca()\n\n # set figure bounds if outside defaults\n if self.parameters[0] in DEFAULT_BOUNDS:\n _set_axes_limits(ax, self.parameters[0], axis=\"x\")\n\n # add injection values\n if self.injection_parameters is not None:\n if self.injection_parameters[self.parameters[0]] is not None:\n ax.axvline(\n (\n self.injection_parameters[self.parameters[0]]\n - self.parameter_offsets[self.parameters[0]]\n ),\n color=kwargs.get(\"injection_color\", \"k\"),\n linewidth=1,\n )\n elif self._num_parameters == 2:\n if \"triangle\" in self.plottype:\n a1, a2, a3 = fig[1:]\n order = [\"x\", \"y\"] if self.plottype == \"triangle\" else [\"y\", \"x\"]\n params = (\n self.parameters[:2]\n if self.plottype == \"triangle\"\n else self.parameters[1::-1]\n )\n\n # set figure bounds if outside defaults\n for param, axes, axis in zip(params, [[a1, a2], [a2, a3]], order):\n for ax in axes:\n _set_axes_limits(ax, param, axis=axis)\n\n self.fig = fig\n return self.fig","def plot_evaluation(values, info, measures = ['Dice','Jaccard', 'TPR', 'TNR', '1-GCE', 'VS', 'RI', 'ARI', 'MI', '1-VOI', 'ICC','1/(1+PBD)', 'KAP', 'AUC', '1/(1+HD)', '1/(1+AVD)', 'MHD' ], colourmap=None, outfile='polar_results.png'):\n _min = info['minimum']\n _max = info['maximum']\n if colourmap is None:\n colourmap = [[86./255.,180./255.,233./255.] for ii in range(values.shape[0])]\n else:\n # normalize colourmap values between 0 and 1\n colourmap = (colourmap-_min)/(_max-_min)\n # apply cividis, returns the RBG1 values for cividis, for dots\n colourmap = [[cm.cividis(ii)] for ii in colourmap] \n\n # elements of the circle\n N = len(measures)\n # evenly space measures around circle\n x_as = [n / float(N) * 2 * pi for n in range(N)] \n\n # Set color of axes\n plt.rc('axes', linewidth=0.5, edgecolor=\"#888888\")\n\n # Create polar plot\n fig = plt.figure(figsize = (11,9.5))\n gs = gridspec.GridSpec(1, 3, width_ratios=[17,2,1])\n ax = plt.subplot(gs[0], polar=True)\n \n # Set position of y-labels\n ax.set_rlabel_position(0)\n\n # Set color and linestyle of grid\n ax.xaxis.grid(True, color=\"#888888\", linestyle='solid', linewidth=0.5)\n ax.yaxis.grid(True, color=\"#888888\", linestyle='solid', linewidth=0.5)\n\n # Set yticks\n plt.yticks([0.2, 0.4, 0.6, 0.8, 1.0], [\"0.2\", \"0.4\", \"0.6\", \"0.8\", \"1.0\"], fontsize=15)\n pos=ax.get_rlabel_position()\n ax.set_rlabel_position(pos+0.4*360./float(len(measures)))\n\n # Plot data\n for ii in np.arange(values.shape[0]):\n xx = np.asarray(x_as) + np.random.randn(len(x_as))*np.diff(x_as)[0]/15.\n data_norm = None\n if info['logplot']:\n data_norm = matplotlib.colors.LogNorm(vmin=_min, vmax=_max)\n sc = ax.scatter(xx, values[ii,:], 23, color=colourmap[ii]*len(xx), norm=data_norm, zorder=3) \n\n # Fill area\n # close the circle\n median = list(np.median(values, axis=0))\n median += median[:1]\n upper = list(np.percentile(values, 75, axis=0))\n upper += upper[:1]\n lower = list(np.percentile(values, 25, axis=0))\n lower += lower[:1]\n x_as += x_as[:1]\n ax.plot(x_as, median, color=[86./255.,180./255.,233./255.], zorder=5)\n ax.fill_between(x_as, upper, lower, zorder=4, color=[86./255.,180./255.,233./255.], alpha=0.3)\n\n # Set number of radial axes and remove labels\n plt.xticks(x_as[:-1], [])\n\n # Set axes limits\n plt.ylim(0, 1)\n\n # Draw ytick labels to make sure they fit properly\n for i in range(N):\n angle_rad = i / float(N) * 2 * pi-0.05\n text_size = 21\n if i in {3,8}:\n ax.text(angle_rad, 1.15, measures[i]+\"\\n(m=%0.2f)\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\"center\")\n elif i in {0}:\n ax.text(angle_rad, 1.25, measures[i]+\"\\n(m=%0.2f)\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\"center\")\n elif i in {1,5,7}:\n ax.text(angle_rad, 1.29, measures[i]+\"\\n(m=%0.2f)\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\"center\")\n elif i in {4}:\n ax.text(angle_rad, 1.32, measures[i]+\"\\n(m=%0.2f)\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\"top\")\n elif i in {10}:\n ax.text(angle_rad, 1.26, measures[i]+\"\\n(m=%0.2f)\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\"center\")\n elif i in {6}:\n ax.text(angle_rad, 1.25, measures[i]+\"\\n(m=%0.2f)\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\"center\")\n elif i in {9}:\n ax.text(angle_rad, 1.18, measures[i]+\"\\n(m=%0.2f)\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\"center\")\n else:\n ax.text(angle_rad, 1.22, measures[i]+\"\\n(m=%0.2f)\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\"center\")\n\n # colorbar location on figure\n cbaxes = plt.subplot(gs[2])\n\n # log scaling option\n norm = None\n if info['logplot']:\n norm = matplotlib.colors.LogNorm(vmin=_min,vmax=_max)\n\n img = plt.imshow(np.array([[_min,_max]]), aspect='auto', cmap=\"cividis\", norm=norm)\n img.set_visible(False)\n\n # initialize colorbar\n cbar = plt.colorbar(cax = cbaxes)\n\n # ticks and label\n c_values = cbar.get_ticks().tolist()\n \n ticklabels = [\"\" for ii in c_values]\n if _min < np.min(c_values):\n c_values = [_min] + c_values\n ticklabels = [\"%0.1f %s\" %(np.min(c_values), info['unit'])] + ticklabels\n else:\n ticklabels[0] = \"%0.1f %s\" %(np.min(c_values), info['unit'])\n\n if _max > np.max(c_values):\n c_values = c_values + [_max]\n ticklabels = ticklabels + [\"%0.1f %s\" %(np.max(c_values), info['unit'])]\n else:\n ticklabels[-1] = \"%0.1f %s\" %(np.max(c_values), info['unit'])\n \n cbar.set_ticks(c_values)\n cbar.set_ticklabels(ticklabels)\n cbaxes.yaxis.set_minor_formatter(matplotlib.ticker.NullFormatter())\n cbar.ax.set_ylabel(info[\"label\"], labelpad=-20)\n \n # font sizes for colorbar\n cbar.ax.yaxis.label.set_size(19)\n cbar.ax.tick_params(labelsize=14)\n\n # Save and show polar plot \n plt.savefig(outfile)\n if info['display']:\n plt.show()\n plt.clf()\n plt.close('all')","def walkplot(cons):\n # Call always after cons.runn()!\n if not hasattr(cons, \"outplot\"):\n print(\"Consortium must run before analyzing the output of the run!\")\n return\n global plt\n if not plt:\n import matplotlib.pyplot as plt\n\n # keep original inputs\n original_metplots = dcp(cons.mets_to_plot)\n original_outplot = dcp(cons.outplot)\n cons.outplot = \"tmp.png\"\n mets = [k for k in cons.media]\n # loop over metabolites, plot them and let the user close the window\n for m in range(0, len(mets), 4):\n cons.mets_to_plot = [mets[m], mets[m + 1], mets[m + 2], mets[m + 3]]\n plot_comm(cons)\n plt.show()\n print(\"Image number\", m / 4)\n\n # clean temporary files, return to orginal parameters\n plt.close(\"all\")\n os.remove(cons.outplot)\n cons.mets_to_plot = original_metplots\n cons.outplot = original_outplot\n return","def app_SN_combined_moisture_gradient(self, dfs, phase_dirs, sizer_val, styler_val):\n\n print('Currently plotting plot_SN_combined_moisture_gradients')\n\n for df, direc in zip(dfs, phase_dirs):\n self.plotter.plot_SN_combined_moisture_gradients(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['01_combined_plots'],\n sizer=self.formatter.sizer[sizer_val]['3x1_partial_width'],\n styler=self.formatter.styler[styler_val],\n xscale=self.xscale_var.get()\n )\n\n print('Done\\n')","def app_SN_combined_series_moist_vs_temp(self, dfs, phase_dirs, sizer_val, styler_val):\n\n print('Currently plotting plot_SN_combined_series_moist_vs_temp')\n\n for df, direc in zip(dfs, phase_dirs):\n # this iterates one or multiple times\n self.plotter.plot_SN_combined_series_moist_vs_temp(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['08_time_series_moisture_vs_temperature'],\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\n styler=self.formatter.styler[styler_val],\n )\n self.plotter.plot_SN_combined_series_moist_vs_temp(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['08_time_series_moisture_vs_temperature'],\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\n styler=self.formatter.styler[styler_val],\n xaxis_type='datetime',\n )\n self.plotter.plot_SN_combined_series_moist_vs_temp(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['08_time_series_moisture_vs_temperature'],\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\n styler=self.formatter.styler[styler_val],\n normalized=True,\n )\n\n print('Done\\n')","def plot_reion_properties(rank, size, comm, reion_ini_files, gal_ini_files,\n model_tags, reion_plots, output_dir, output_format):\n\n # Check to see if the output directory exists.\n if rank == 0:\n if not os.path.exists(output_dir):\n os.makedirs(output_dir)\n print(\"Made output directory {0}\".format(output_dir))\n\n MC_dir = \"{0}/MC\".format(output_dir)\n os.makedirs(MC_dir)\n print(\"Made directory {0}\".format(MC_dir))\n\n # First calculate all the properties and statistics we need.\n reion_data = generate_data(rank, size, comm, reion_ini_files,\n gal_ini_files, reion_plots, output_dir,\n model_tags, output_format)\n\n # Gather all the fractions onto the master process.\n # This will be used for many different plots. \n master_mass_frac = collective.collect_hist_across_tasks(rank, comm, \n reion_data[\"mass_frac_allmodels\"]) \n master_mass_frac = comm.bcast(master_mass_frac, root = 0)\n\n # Then find out what we need and plot em!\n if reion_plots[\"history\"] and rank == 0:\n\n \n duration_z, duration_t, reion_completed = \\\n calc_duration(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"],\n master_mass_frac, reion_plots[\"duration_definition\"])\n\n for model_number in range(len(master_mass_frac)):\n print(\"Model {0}: Start {1:.2f} \\tMid {2:.2f}\\tEnd {3:.2f}\\t\"\n \"dz {4:.2f}\\tdt {5:.1f}Myr\\tReion Completed {6}\" \\\n .format(model_number, duration_z[model_number][0],\n duration_z[model_number][1], duration_z[model_number][-1],\n duration_z[model_number][0]-duration_z[model_number][-1],\n duration_t[model_number][-1]-duration_t[model_number][0],\n reion_completed[model_number]))\n\n print(\"Plotting the reionization history.\")\n reionplot.plot_history(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n reion_data[\"t_bigbang_allmodels\"],\n master_mass_frac,\n model_tags, output_dir, \"history\",\n output_format)\n\n\n\n if reion_plots[\"nion\"]:\n\n master_nion = collective.collect_hist_across_tasks(rank, comm, \n reion_data[\"nion_allmodels\"])\n\n if rank == 0:\n print(\"Plotting the ionizing emissivity.\")\n reionplot.plot_nion(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n reion_data[\"t_bigbang_allmodels\"],\n master_nion,\n reion_data[\"nion_factor_allmodels\"], \n model_tags, output_dir, \"nion\", output_format)\n\n if reion_plots[\"ps_fixed_XHI\"]:\n k, P21, PHII = determine_ps_fixed_XHI(rank, size, comm,\n reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n master_mass_frac, \n reion_data[\"XHII_fbase_allmodels\"],\n reion_data[\"XHII_precision_allmodels\"],\n reion_data[\"density_fbase_allmodels\"],\n reion_data[\"density_precision_allmodels\"],\n reion_data[\"GridSize_allmodels\"],\n reion_data[\"boxsize_allmodels\"],\n reion_data[\"first_snap_allmodels\"],\n reion_plots[\"fixed_XHI_values\"])\n\n if rank == 0:\n print(\"Plotting PS at fixed neutral fraction.\")\n reionplot.plot_ps_fixed_XHI(k, P21, PHII,\n reion_plots[\"fixed_XHI_values\"],\n model_tags, output_dir, \"ps_fixed_XHI\",\n output_format)\n\n if reion_plots[\"contours\"] and rank == 0:\n # tau is used for multiple plots. So check if we need to calculate it.\n try:\n tau_allmodels\n except NameError:\n tau_allmodels = calc_tau(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n reion_data[\"helium_allmodels\"],\n master_mass_frac)\n\n # For the contours, only plot the optical depth at the highest z.\n tau_highz = []\n for model_number in range(len(tau_allmodels)):\n tau_highz.append(tau_allmodels[model_number][0])\n\n duration_z, duration_t, reion_completed = \\\n calc_duration(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"],\n master_mass_frac, reion_plots[\"duration_definition\"])\n\n print(\"Plotting contours of constant tau.\")\n reionplot.plot_tau_contours(tau_highz, reion_completed,\n reion_plots[\"alpha_beta_limits\"],\n output_dir, \"tau_contours\", output_format)\n\n print(\"Plotting contours of constant reionization duration.\")\n reionplot.plot_duration_contours(duration_t, reion_completed,\n reion_plots[\"alpha_beta_limits\"],\n output_dir, \"duration_contours\",\n output_format)\n\n if reion_plots[\"optical_depth\"] and rank == 0:\n # tau is used for multiple plots. So check if we need to calculate it.\n try:\n tau_allmodels\n except NameError:\n tau_allmodels = calc_tau(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n reion_data[\"helium_allmodels\"],\n master_mass_frac)\n\n print(\"Plotting the optical depth.\")\n reionplot.plot_tau(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"], \n reion_data[\"cosmology_allmodels\"],\n reion_data[\"t_bigbang_allmodels\"],\n tau_allmodels,\n model_tags, output_dir, \"optical_depth\",\n output_format)\n\n if reion_plots[\"optical_depth\"] and reion_plots[\"history\"] and rank == 0:\n print(\"Plotting the combined optical depth/ionization history.\")\n reionplot.plot_combined_history_tau(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"], \n reion_data[\"cosmology_allmodels\"],\n reion_data[\"t_bigbang_allmodels\"],\n master_mass_frac, tau_allmodels, \n model_tags, output_dir,\n \"history_tau\", output_format)\n\n if reion_plots[\"optical_depth\"] and reion_plots[\"nion\"] and rank == 0:\n print(\"Plotting the combined optical depth/ionizing emissivity.\")\n reionplot.plot_combined_nion_tau(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n reion_data[\"t_bigbang_allmodels\"],\n master_nion,\n reion_data[\"nion_factor_allmodels\"],\n tau_allmodels, model_tags, output_dir,\n \"nion_tau\", output_format)\n\n if reion_plots[\"ps_scales\"] or reion_plots[\"ps_scales_beta\"]:\n print(\"Gathering the 21cm Power Spectra across processors\")\n k, P21, PHII = gather_ps(rank, size, comm,\n reion_data[\"k_allmodels\"],\n reion_data[\"P21_allmodels\"],\n reion_data[\"PHII_allmodels\"],\n reion_data[\"first_snap_allmodels\"],\n reion_data[\"last_snap_allmodels\"])\n\n if rank == 0:\n print(\"Plotting the large scale power as a function of small \"\n \"scale.\")\n\n if reion_plots[\"ps_scales_beta\"]:\n calc_beta = True\n else:\n calc_beta = False \n\n # Now that we have all the PS on the master rank, calculate the\n # amplitude at the specified scales.\n scale_power_dict = calc_scale_power(k, P21, PHII,\n reion_data[\"z_array_reion_allmodels\"], \n reion_plots[\"small_scale_def\"],\n reion_plots[\"large_scale_def\"],\n reion_plots[\"small_scale_err\"],\n reion_plots[\"large_scale_err\"],\n calc_beta=calc_beta)\n\n k_small_scale = scale_power_dict[\"k_small_scale\"]\n k_large_scale = scale_power_dict[\"k_large_scale\"]\n\n P21_small_scale = scale_power_dict[\"P21_small_scale\"]\n P21_large_scale = scale_power_dict[\"P21_large_scale\"]\n\n PHII_small_scale = scale_power_dict[\"PHII_small_scale\"]\n PHII_large_scale = scale_power_dict[\"PHII_large_scale\"]\n\n if reion_plots[\"ps_scales\"]:\n reionplot.plot_ps_scales(P21_small_scale,\n P21_large_scale, master_mass_frac, \n reion_data[\"z_array_reion_allmodels\"],\n reion_plots[\"fixed_XHI_values\"],\n reion_plots[\"ps_scales_z\"],\n reion_plots[\"small_scale_def\"],\n reion_plots[\"large_scale_def\"],\n reion_plots[\"small_scale_err\"],\n reion_plots[\"large_scale_err\"],\n model_tags, output_dir, \"ps_scales\",\n output_format)\n\n if reion_plots[\"ps_scales_beta\"]:\n\n P21_beta = scale_power_dict[\"P21_beta\"]\n P21_beta_error = scale_power_dict[\"P21_beta_error\"]\n PHII_beta = scale_power_dict[\"PHII_beta\"]\n\n reionplot.plot_ps_beta(P21_beta, P21_beta_error,\n reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n reion_data[\"t_bigbang_allmodels\"],\n reion_plots[\"small_scale_def\"],\n reion_plots[\"large_scale_def\"],\n model_tags, output_dir,\n \"ps_scales_beta\", output_format)\n\n\n\n if reion_plots[\"slices_fixed_XHI\"] and rank == 0:\n print(\"Plotting slices at fixed XHI fractions.\")\n reionplot.plot_slices_XHI(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n master_mass_frac, \n reion_data[\"XHII_fbase_allmodels\"],\n reion_data[\"XHII_precision_allmodels\"],\n reion_data[\"GridSize_allmodels\"],\n reion_data[\"boxsize_allmodels\"],\n reion_data[\"first_snap_allmodels\"],\n reion_plots[\"fixed_XHI_values\"],\n reion_plots[\"cut_slice\"],\n reion_plots[\"cut_thickness\"],\n model_tags, output_dir, \"slices_XHI\",\n output_format)\n\n\n if reion_plots[\"bubble_size\"] and rank == 0:\n print(\"Determining bubble sizes at fixed XHI.\")\n reionplot.determine_bubble_size(reion_data[\"z_array_reion_allmodels\"],\n master_mass_frac,\n reion_data[\"first_snap_allmodels\"],\n reion_data[\"GridSize_allmodels\"],\n reion_data[\"boxsize_allmodels\"],\n reion_plots[\"fixed_XHI_values\"],\n model_tags, output_dir)\n\n if reion_plots[\"zreion_dens_cross\"] and rank == 0:\n print(\"Calculating the zreion-density cross correlation.\")\n k, crosspspec, crosscorr, bias = \\\n zreion_dens_cross(reion_data[\"density_fbase_allmodels\"],\n reion_data[\"density_precision_allmodels\"],\n reion_data[\"zreion_path_allmodels\"],\n reion_data[\"GridSize_allmodels\"],\n reion_data[\"boxsize_allmodels\"],\n reion_data[\"last_snap_allmodels\"])\n\n reionplot.plot_zreion_dens_cross(k, crosscorr, bias, model_tags,\n output_dir, \"zreion_dens_crosscorr\",\n output_format)\n\n if reion_plots[\"dens_ion_contours\"] and rank == 0:\n print(\"Plotting contours of density-ionization.\")\n reionplot.plot_dens_reion_contours(master_mass_frac,\n reion_data[\"XHII_fbase_allmodels\"],\n reion_data[\"XHII_precision_allmodels\"],\n reion_data[\"density_fbase_allmodels\"],\n reion_data[\"density_precision_allmodels\"],\n reion_data[\"GridSize_allmodels\"],\n reion_data[\"first_snap_allmodels\"],\n reion_plots[\"fixed_XHI_values\"],\n model_tags, output_dir,\n \"dens_ion_contours\", output_format)\n\n if reion_plots[\"dens_zreion_contours\"] and rank == 0:\n print(\"Plotting contours of density-zreion.\")\n reionplot.plot_dens_zreion_contours(reion_data[\"density_fbase_allmodels\"],\n reion_data[\"density_precision_allmodels\"],\n reion_data[\"zreion_path_allmodels\"],\n reion_data[\"GridSize_allmodels\"],\n reion_data[\"last_snap_allmodels\"],\n model_tags, output_dir,\n \"dens_zreion_contours\", output_format)","def plot_uv(self):\n self.current_plot = 'uv'\n self.ax_zoomed = False\n \n uu = self.uv.d_uv_data['UU']*1e6\n vv = self.uv.d_uv_data['VV']*1e6\n xx = self.uv.d_array_geometry['STABXYZ'][:,0]\n yy = self.uv.d_array_geometry['STABXYZ'][:,1]\n pmax, pmin = np.max([uu, vv])*1.1, np.min([uu,vv])*1.1\n\n \n fig = self.sp_fig\n plt.subplot(121, aspect='equal')\n ax = plt.plot(xx, yy, 'bo')\n for i in range(len(xx)):\n plt.text(xx[i], yy[i], self.uv.d_array_geometry['ANNAME'][i].strip('Stand').strip('Tile'))\n\n plt.title(\"Antenna positions\")\n plt.xlabel(\"X [m]\")\n plt.ylabel(\"Y [m]\")\n \n plt.subplot(122, aspect='equal')\n ax = plt.plot(uu, vv, 'b.')\n plt.title(\"UV data\")\n plt.xlabel(\"UU [$\\\\mu s$]\")\n plt.ylabel(\"VV [$\\\\mu s$]\")\n plt.xlim(pmin, pmax)\n plt.ylim(pmin, pmax)\n return fig, ax","def plot_lollipop(clinvar_path_count):\n os.chdir(\"/Users/Files/nogit/generisk/lollipop/figure\")\n app = '/Users/files/work/bin/lollipops'\n for i in x.itertuples(False, None):\n # uid, variants, gn\n os.system(\"%s -domain-labels=fit -U %s -o %s.svg %s\" % (app, i[0], i[2], i[1]))\n # os.system(\"rsvg-convert %s.svg -o %s_rsvg.png\"%(i[2],i[2]))\n os.system(\"convert -density 500 -units pixelsperinch %s.svg %s.png\" % (i[2], i[2]))","def plot_profiles(self, fig=0, title=''):\n plot_input.plot_profiles(self, fig, title)","def plot_dataset(\n self,\n out_dir: str = None,\n therm_frac: int = 0.,\n num_chains: int = None,\n ridgeplots: bool = True,\n profile: bool = False,\n ):\n tdict = {}\n dataset = self.get_dataset(therm_frac)\n for key, val in dataset.data_vars.items():\n t0 = time.time()\n if np.std(val.values.flatten()) < 1e-2:\n continue\n\n if len(val.shape) == 2: # shape: (chain, draw)\n val = val[:num_chains, :]\n\n if len(val.shape) == 3: # shape: (chain, leapfrogs, draw)\n val = val[:num_chains, :, :]\n\n fig, ax = plt.subplots(constrained_layout=True, figsize=set_size())\n _ = val.plot(ax=ax)\n if out_dir is not None:\n io.check_else_make_dir(out_dir)\n out_file = os.path.join(out_dir, f'{key}_xrPlot.png')\n fig.savefig(out_file, dpi=400, bbox_inches='tight')\n plt.close('all')\n plt.clf()\n\n if profile:\n tdict[key] = time.time() - t0\n io.log(f'time spent plotting {key}: {tdict[key]}')\n\n if out_dir is not None:\n out_dir = os.path.join(out_dir, 'ridgeplots')\n io.check_else_make_dir(out_dir)\n\n if ridgeplots:\n make_ridgeplots(dataset, num_chains=num_chains, out_dir=out_dir)\n\n return tdict","def plot_rose(ext_data, plot_label=None):\n result = ext_data.copy(deep=False)\n sectors = len(result)\n fig = plt.figure(figsize=(12, 12))\n ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=True)\n ax.set_theta_zero_location('N')\n ax.set_theta_direction(-1)\n ax.set_thetagrids(np.arange(0, 360, 360.0/sectors))\n sector_mid_points = []\n widths = []\n for i in result.index:\n angular_pos_start = (np.pi / 180.0) * float(i.split('-')[0])\n angular_pos_end = (np.pi / 180.0) * float(i.split('-')[-1])\n if angular_pos_start < angular_pos_end:\n sector_mid_points.append((angular_pos_start+angular_pos_end)/2.0)\n widths.append(angular_pos_end-angular_pos_start - (np.pi / 180))\n else:\n sector_mid_points.append((np.pi + (angular_pos_start + angular_pos_end)/2.0) % 360)\n widths.append(2*np.pi - angular_pos_start + angular_pos_end - (np.pi / 180))\n max_contour = (ext_data.max() + ext_data.std())\n contour_spacing = max_contour / 10\n num_digits_to_round = 0\n while contour_spacing*(10**num_digits_to_round) <= 1:\n num_digits_to_round += 1\n if 0.5 < contour_spacing < 1:\n contour_spacing = 1\n levels = np.arange(0, max_contour, round(contour_spacing, num_digits_to_round))\n ax.set_rgrids(levels, labels=[str(i) for i in levels], angle=0)\n ax.bar(sector_mid_points, result, width=widths, bottom=0.0, color=COLOR_PALETTE.primary,\n edgecolor=[COLOR_PALETTE.primary_35 for i in range(len(result))], alpha=0.8)\n ax.legend([plot_label])\n plt.close()\n return ax.get_figure()","def plotBatch(inp,output='spectra_plot.pdf',comparisons=None,classify=False,normalize=False,normrange=[0.9,1.4],layout=[2,2],basecolors=['k','m'],legend=[],fontscale=0.7,classify_kwargs={},plot_kwargs={},**kwargs):\n\n# alt keyword check\n for k in ['file','filename']: \n if kwargs.get(k,'') != '': output = kwargs[k]\n for k in ['legends','labels']: \n if kwargs.get(k,'') != '': legend = kwargs[k]\n\n# force input into a list\n if isinstance(inp,list): inputlist = copy.deepcopy(inp)\n else: inputlist = [inp]\n\n# if input is a string of filenames, read in each file to a spectrum object\n if isinstance(inputlist[0],str):\n# try a glob search string \n files = glob.glob(os.path.normpath(inputlist[0]))\n if len(files) > 1 or (len(files) == 1 and inputlist[0].find('*') != -1):\n inputlist = files\n# try reading in files into Spectrum object\n try:\n splist = [splat.Spectrum(file = f) for f in inputlist]\n except:\n raise ValueError('\\nCould not read in list of files {} - make sure the full path is specified and the files are correctly formatted'.format(inputlist))\n\n# if filenames, read in each file to a spectrum object\n elif isinstance(inputlist[0],splat.Spectrum):\n splist = copy.deepcopy(inputlist)\n else:\n raise ValueError('\\nInput should be list of splat.Spectrum objects or filenames')\n\n# normalize if desired\n if normalize==True:\n tmp = [sp.normalize(normrange) for sp in splist]\n\n# comparison files are present\n complist = []\n if comparisons != None:\n comp = copy.deepcopy(comparisons)\n if not isinstance(comp,list): comp = [comp]\n if isinstance(comp[0],str):\n try:\n complist = [splat.Spectrum(file = f) for f in comp]\n except:\n print('\\nCould not read in comparison files: ignoring comparisons')\n if isinstance(comp[0],splat.Spectrum):\n complist = comp\n if len(complist) < len(splist):\n while len(complist) < len(splist):\n complist.append(complist[-1])\n# normalize\n if normalize==True:\n tmp = [sp.normalize(normrange) for sp in complist]\n\n# set comparison files to be standards for spectral classification\n# overrules input comparison sample\n if classify == True:\n complist = []\n base_kwargs={\n 'return_standard': True,\n 'method': 'kirkpatrick',\n }\n base_kwargs.update(classify_kwargs)\n for sp in splist:\n complist.append(splat.classifyByStandard(sp,**base_kwargs))\n\n# prep for plotting\n plotlist = []\n clist = []\n for i,sp in enumerate(splist):\n if len(complist) == len(splist):\n plotlist.append([sp,complist[i]])\n clist.extend(basecolors)\n else:\n plotlist.append([sp])\n clist.extend(basecolors[0])\n\n# manage legends\n if len(legend) != 0:\n if not isinstance(legend,list): legend = [legend]\n if len(legend) < (len(splist)+len(complist)):\n# guess: just left out the comparison legends \n if len(complist) > 0 and len(legend) == len(splist):\n legtmp = []\n for i,l in enumerate(legend):\n legtmp.extend([l,'{}'.format(complist[i].name)])\n legend = legtmp\n else:\n# otherwise: pad the remaining legends with the last legend (pairs) \n while len(legend) < (len(splist)+len(complist)):\n if len(complist)>0:\n legend.extend([legend[-2],legend[-1]])\n else:\n legend.extend([legend[-1]])\n if len(legend) > (len(splist)+len(complist)):\n legend = legend[0:(len(splist)+len(complist))]\n else:\n legend = []\n for i,sp in enumerate(splist):\n l = []\n if 'name' in list(sp.__dict__.keys()): l.append(sp.name)\n else: l.append(os.path.basename(sp.filename))\n if len(complist)>0:\n if 'name' in list(complist[i].__dict__.keys()): l.append(complist[i].name)\n else: l.append(os.path.basename(complist[i].filename))\n legend.extend(l)\n\n# generate plot\n base_kwargs={\n 'multiplot': True,\n 'multipage': True,\n 'legends': legend,\n 'colors': clist,\n 'layout': layout,\n 'fontscale': fontscale,\n 'output': output,\n }\n base_kwargs.update(plot_kwargs)\n fig = plotSpectrum(plotlist,**base_kwargs)\n\n return fig","def multiple(folder_name: str,\r\n min_plant_pixels: int = MIN_PLANT_SIZE,\r\n output_options = [['rows',\r\n 'centers',\r\n 'row_ids',\r\n 'distances'],\r\n \r\n ['rows',\r\n 'centers',\r\n 'row_ids',\r\n 'numbers'],\r\n \r\n ['dirt',\r\n 'ditches',\r\n 'rows',\r\n 'clusters',\r\n 'centers',\r\n 'row_ids',\r\n 'numbers',\r\n 'lines']\r\n ]) -> None:\r\n\r\n # Go to the specified folder\r\n ls = listdir(folder_name)\r\n ls = [join(folder_name, i) for i in ls]\r\n\r\n # Check if the folder exists\r\n if join(folder_name, 'Analysis') in ls:\r\n\r\n # If it does, rename the old folder\r\n new_name = join(folder_name, 'Analysis')\r\n while new_name in ls:\r\n new_name += '_old'\r\n \r\n rename(join(folder_name,'Analysis'), new_name)\r\n\r\n # Create new folders inside the given directory\r\n mkdir(join(folder_name, 'Analysis'))\r\n mkdir(join(folder_name, 'Analysis/Images'))\r\n mkdir(join(folder_name, 'Analysis/Data'))\r\n \r\n # Gather the images to be analysed\r\n co = 0\r\n pics = [j for j in ls if isfile(j)]\r\n le = len(pics)\r\n\r\n # Analyze each of the pictures\r\n for i in pics:\r\n\r\n # Make the field\r\n field = just_field(i, min_plant_pixels)\r\n\r\n # Measure the field and save results\r\n print('Saving data...\\n')\r\n ruler = Ruler(field)\r\n \r\n ruler.output_distances(\r\n join(folder_name,\r\n 'Analysis/Data/{}_Distances.csv'.format(basename(i).split('.')[0])\r\n ) \r\n )\r\n \r\n ruler.output_row_info(\r\n join(folder_name,\r\n 'Analysis/Data/{}_Rows.csv'.format(basename(i).split('.')[0])\r\n )\r\n )\r\n\r\n # Make and save visuals\r\n print('Saving pictures...\\n')\r\n for k in range(len(output_options)):\r\n output_options[k]\r\n img = field.make_visual(ruler, output_options[k])\r\n img.save(\r\n join(folder_name,\r\n 'Analysis/Images/{}_Visual_{}.png'.format(basename(i).split('.')[0], k + 1)))\r\n\r\n # Increment the progress meter\r\n co += 1\r\n print('Completed {}/{} images\\n\\n'.format(co, le))","def main(fpath):\n\t# Load results data\n\twith open(fpath) as f:\n\t\tlines = f.readlines()\n\n\tresults = []\n\tfor line in lines:\n\t\tif not line.startswith(\"//\"):\n\t\t\tresults.append(json.loads(line))\n\n\t# Format relevent data\n\tresults = sorted(results, key=lambda k: k['data_lens'][\"mean\"])\n\t# x = [np.log(x[\"block_lens\"][\"mean\"]) for x in results]\n\tx = [x[\"data_lens\"][\"mean\"] for x in results]\n\ty = [x[\"mean\"] for x in results]\n\tyy = [x[\"block_lens\"][\"mean\"] for x in results]\n\n\n\t# Plot graphs\n\tplt.figure(figsize=(14,5))\n\tplt.subplot(1,2,1)\n\tplt.title('Ratio of Total Block Size to Primary Data Size Against Primary Data Size')\n\tplt.ylabel('Total Block Size / Primary Data Size')\n\t# plt.xlabel('log( Primary Data Size )')\n\tplt.xlabel('Primary Data Size (chars)')\n\tplt.plot(x, y)\n\n\tplt.subplot(1,2,2)\n\tplt.title('Total Block Size Against Primary Data Size')\n\tplt.ylabel('Total Block Size (chars)')\n\tplt.xlabel('Primary Data Size (chars)')\n\tplt.plot(x, yy)\n\n\n\tplt.show()","def plot_sector_ratio(sec_ratio, wdir, sec_ratio_dist, col_names, boom_dir_1=-1, boom_dir_2=-1):\n radians = np.radians(utils._get_dir_sector_mid_pts(sec_ratio_dist.index))\n fig = plt.figure(figsize=(10, 10))\n ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=True)\n ax.set_theta_zero_location('N')\n ax.set_theta_direction(-1)\n ax.set_thetagrids(utils._get_dir_sector_mid_pts(sec_ratio_dist.index))\n ax.plot(np.append(radians, radians[0]), sec_ratio_dist['Mean_Sector_Ratio'].append(sec_ratio_dist.iloc[0]),\n color=COLOR_PALETTE.primary, linewidth=4)\n # Get max and min levels and set chart axes\n max_level = sec_ratio_dist['Mean_Sector_Ratio'].max() + 0.05\n min_level = sec_ratio_dist['Mean_Sector_Ratio'].min() - 0.1\n ax.set_ylim(min_level, max_level)\n # Add boom dimensions to chart, if required\n width = np.pi / 108\n radii = max_level\n annotate = False\n annotation_text = '* Plot generated using '\n if boom_dir_1 >= 0:\n boom_dir_1_rad = np.radians(boom_dir_1)\n ax.bar(boom_dir_1_rad, radii, width=width, bottom=min_level, color=COLOR_PALETTE.fourth)\n if boom_dir_2 == -1:\n annotation_text += '{} (top mounted) divided by {} ({}° boom)'.format(col_names[1], col_names[0],\n boom_dir_1)\n annotate = True\n if boom_dir_2 >= 0:\n boom_dir_2_rad = np.radians(boom_dir_2)\n ax.bar(boom_dir_2_rad, radii, width=width, bottom=min_level, color=COLOR_PALETTE.fifth)\n if boom_dir_1 == -1:\n annotation_text += '{} ({}° boom) divided by {} (top mounted)'.format(col_names[1], boom_dir_2,\n col_names[0])\n annotate = True\n if boom_dir_2 >= 0 and boom_dir_1 >= 0:\n annotation_text += '{} ({}° boom) divided by {} ({}° boom)'.format(col_names[1], boom_dir_2,\n col_names[0], boom_dir_1)\n annotate = True\n if annotate:\n ax.annotate(annotation_text, xy=(0.5, 0.035), xycoords='figure fraction', horizontalalignment='center')\n ax.scatter(np.radians(wdir), sec_ratio, color=COLOR_PALETTE.secondary, alpha=0.3, s=1)\n plt.close()\n return ax.get_figure()","def run_and_plot(self):\n self.raw_processing()\n self.data_averaging_and_cleaning()\n\n print(self.organized_names)\n print(self.organized_film)\n print(self.organized_plank)\n\n height = self.organized_film\n bars = tuple(self.organized_names.copy())\n y_pos = np.arange(len(bars))\n\n plt.bar(y_pos, height)\n plt.xticks(y_pos, bars)\n plt.xlabel('TH% in 100ul water/TH mixture')\n plt.ylabel('CFU/mL count')\n plt.title('Experiment 2.5 (Sucrose Concentration) 7 Aug 2018')\n\n plt.show()\n\n height2 = self.organized_plank\n\n plt.bar(y_pos, height2)\n plt.xticks(y_pos, bars)\n plt.xlabel('TH% in 100ul water/TH mixture')\n plt.ylabel('Proportion of Biofilm CFUs to Planktonic CFUs')\n plt.title('Experiment 2.5 (Sucrose Concentration) 7 Aug 2018')\n\n plt.show()","def plot_data(\n self,\n out_dir: str = None,\n flags: AttrDict = None,\n therm_frac: float = 0.,\n params: AttrDict = None,\n ):\n plot_data(self.data, out_dir, flags,\n therm_frac=therm_frac, params=params)","def main():\n font = {'family' : 'normal',\n 'weight' : 'normal',\n 'size' : 18}\n\n matplotlib.rc('font', **font)\n\n ###Plot overviews\n\n# plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\"12co_combined_peak_full.png\",\n# show_shells=False,title=r\"Combined $^{12}$CO Peak T$_{MB}$\",\n# dist=orion_dist, vmin=None, vmax=None, scalebar_color='white',\n# scalebar_pc=1.,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325)\n \n plot_overview(plotname=\"../paper/figs/12co_nroonly_peak_full_shells.png\", show_shells=True,\n dist=orion_dist, vmin=None, vmax=None, scalebar_color='black', scale_factor = 1.,\n title=r\"\", shells_highlight=best_shells, circle_style='dotted', circle_linewidth=1.5,\n scalebar_pc=1. #,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325\n )\n\n # plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\"12co_combined_mom0_cometary.png\",\n # show_shells=False, title=r\"Combined Integrated $^{12}$CO\",\n # dist=orion_dist, scalebar_color='white', pmax=93., mode='mom0',\n # scale_factor=1./1000,\n # scalebar_pc=0.2,recenter=True, ra=83.99191, dec=-5.6611303, radius=0.117325)\n\n # plot_overview(plotname=\"12co_nroonly_mom0_cometary.png\", show_shells=False,\n # dist=orion_dist, scalebar_color='white', pmax=93., mode='mom0',\n # scale_factor=1./1000, title=r\"NRO Integrated $^{12}$CO\",\n # scalebar_pc=0.2,recenter=True, ra=83.99191, dec=-5.6611303, radius=0.117325)\n\n # plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\"12co_combined_peak_full_shells.png\",\n # show_shells=True, shells_highlight=shells_score3, title=r\"Combined $^{12}$CO Peak T$_{MB}$\",\n # dist=orion_dist, vmin=None, vmax=None, scalebar_color='white', circle_style='dotted',\n # scalebar_pc=1.,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325)\n\n # return\n\n mips_l1641_file = '../catalogs/MIPS_L1641a_24um.fits'\n mips_onc_file = '../catalogs/MIPS_ONC_24um.fits'\n\n irac1_l1641_file = '../catalogs/IRAC_L1641_ch1_merged_clean.fits'\n irac1_onc_file = '../catalogs/IRAC_ONC_ch1_merged_clean.fits'\n\n irac2_l1641_file = '../catalogs/IRAC_L1641_ch2_merged_clean.fits'\n irac2_onc_file = '../catalogs/IRAC_ONC_ch2_merged_clean.fits'\n\n irac4_l1641_file = '../catalogs/IRAC_L1641_ch4_merged_clean_northup.fits'\n irac4_onc_file = '../catalogs/IRAC_ONC_ch4_merged_clean_northup.fits'\n\n planck_herschel_file = '../catalogs/planck_herschel.fits'\n\n region_file = '../shell_candidates/AllShells.reg'\n vrange_file = '../shell_candidates/AllShells_vrange.txt'\n shell_list = get_shells(region_file=region_file, velocity_file=vrange_file)\n\n obaf_file = 'stars_obaf.txt'\n yso_file = \"../catalogs/spitzer_orion.fit\"\n\n obaf = ascii.read(obaf_file)\n obaf_ra, obaf_dec, obaf_label = np.array(obaf['RA']), np.array(obaf['DEC']), np.array([sp.strip(\"b'\") for sp in obaf['SP_TYPE']])\n yso = fits.open(yso_file)[1].data\n yso_ra, yso_dec, yso_label = yso['RAJ2000'], yso['DEJ2000'], yso['Cl']\n\n # for nshell in range(19,43):\n # shell = shell_list[nshell-1]\n # ra, dec, radius = shell.ra.value, shell.dec.value, shell.radius.value\n\n # #Check whether shell is in each mips image coverage.\n # l1641_xy = WCS(mips_l1641_hdu).all_world2pix(ra, dec, 0)\n \n # if (l1641_xy[0] >= 0) & (l1641_xy[0] <= mips_l1641_hdu.shape[1]) & \\\n # (l1641_xy[1] >= 0) & (l1641_xy[1] <= mips_l1641_hdu.shape[0]):\n # hdu = mips_l1641_hdu\n # else:\n # hdu = mips_onc_hdu\n\n # plot_stamp(map=hdu, ra=ra, dec=dec, radius=radius, circle_color='red',\n # pad_factor=1.5, contour_map=None, contour_levels=5., source_ra=None, source_dec=None, source_lists=None, \n # source_colors='cyan', plotname='{}shell{}_stamp.png'.format('MIPS',nshell), return_fig=False,\n # stretch='linear', plot_simbad_sources=False, dist=orion_dist, cbar_label=r'counts',\n # auto_scale=True, auto_scale_mode='min/max', auto_scale_pad_factor=1., vmin=0, vmax=3000)\n\n\n #cube_file = '../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits'\n cube_file = '../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits'\n ir_l1641_hdu = fits.open(irac4_l1641_file)[0]\n ir_onc_hdu = fits.open(irac4_onc_file)[0]\n\n spec_cube = SpectralCube.read(cube_file)\n ra_grid = spec_cube.spatial_coordinate_map[1].to(u.deg).value\n dec_grid = spec_cube.spatial_coordinate_map[0].to(u.deg).value\n vel_grid = spec_cube.spectral_axis\n pad_factor = 1.5\n\n #plot_overview(show_shells=True)\n #plot_overview(plotname=\"12co_nro_peak.png\", show_shells=False)\n #plot_overview(cube=\"/Volumes/Untitled/13co_pix_2.cm.fits\", plotname=\"13co_combined_peak.png\", show_shells=False)\n #return\n #channel_vmax = [12.9, 14]\n for nshell in range(17,18):\n shell = shell_list[nshell-1]\n ra, dec, radius = shell.ra.value, shell.dec.value, shell.radius.value\n\n l1641_xy = WCS(ir_l1641_hdu).wcs_world2pix(ra, dec, 0)\n #print(l1641_xy)\n if (l1641_xy[0] >= 0) & (l1641_xy[0] <= ir_l1641_hdu.shape[1]) & \\\n (l1641_xy[1] >= 0) & (l1641_xy[1] <= ir_l1641_hdu.shape[0]):\n ir_hdu = ir_l1641_hdu\n else:\n ir_hdu = ir_onc_hdu\n\n #Extract sub_cube around shell.\n subcube_mask = (abs(ra_grid - ra) < radius * pad_factor) &\\\n (abs(dec_grid - dec) < radius * pad_factor)\n sub_cube = spec_cube.with_mask(subcube_mask).minimal_subcube().spectral_slab(shell.vmin, shell.vmax)\n\n #Integrate between vmin and vmax.\n mom0_hdu = sub_cube.moment0().hdu\n\n # mask_inshell = (abs(ra_grid - ra) < radius) &\\\n # (abs(dec_grid - dec) < radius)\n # subcube_inshell = spec_cube.with_mask(mask_inshell).minimal_subcube().spectral_slab(shell.vmin, shell.vmax)\n # mom0_hdu_inshell = subcube_inshell.moment0().hdu\n\n #Calculate contour levels.\n empty_channel = spec_cube.closest_spectral_channel(500*u.Unit('m/s'))\n sigma = np.nanstd(spec_cube[empty_channel][subcube_mask]).value\n #print(\"sigma: {}\".format(sigma))\n delta_vel = (sub_cube.spectral_extrema[1] - sub_cube.spectral_extrema[0]).value\n #print(\"delta_vel: {}\".format(delta_vel))\n mom0_sigma = sigma * delta_vel\n #print(mom0_sigma) \n #contour_levels = np.linspace(5.*mom0_sigma, np.nanmax(mom0_hdu_inshell.data), 12)\n contour_levels = np.linspace(28.*mom0_sigma, 45.*mom0_sigma, 6 )\n\n #Get source coordinates.\n\n\n # plot_stamp(map=ir_hdu, ra=ra, dec=dec, radius=radius, circle_color='red',\n # pad_factor=pad_factor, contour_map=mom0_hdu, contour_levels=contour_levels, contour_color='white',\n # plotname='{}shell{}_{}{}to{}_stamp.png'.format('8µm', nshell, \"12CO\", shell.vmin.value, shell.vmax.value),\n # return_fig=False,\n # stretch='linear', plot_simbad_sources=False, dist=orion_dist,\n # auto_scale=True, auto_scale_mode='median', auto_scale_pad_factor=0.8, auto_scale_nsigma=4.,\n # cbar_label=\"Counts\", cmap='inferno',\n # source_ra=[obaf_ra, yso_ra], source_dec=[obaf_dec, yso_dec],\n # source_colors=['white', 'red'], source_markers=['*', 'None'], source_sizes=[300,50],\n # source_labels=[obaf_label, yso_label], dpi=300\n # )\n\n #cube_file = \"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\"\n \n \n # plot_channels(cube=cube_file, ra=ra, dec=dec, radius=radius,\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\n # plotname='12co_channels_shell'+str(nshell)+'.png', chan_step=2, plot_simbad_sources=False,\n # vmin=None, vmax=None, max_chans=12,\n # #cbar_label=\"Counts\",\n # source_ra=[obaf_ra, yso_ra], source_dec=[obaf_dec, yso_dec],\n # source_colors=['white', 'red'], source_markers=['*', '+'], source_sizes=[200,15], dpi=300)\n\n # angle = 90*u.deg\n # pv = plot_pv(cube=cube_file, ra_center=shell.ra, dec_center=shell.dec,\n # vel=[shell.vmin - 1*u.km/u.s, shell.vmax + 1*u.km/u.s], length=shell.radius*4.,\n # width=7.5*u.arcsec, angle=angle,\n # pad_factor=1., plotname='12co_pv_shell'+str(nshell)+'_angle'+str(angle.value)+'.png',\n # stretch='linear', auto_scale=True, dpi=900.)\n \n\n\n #simbad_brightstars(output='stars_obaf.txt', output_format='ascii', replace_ra='deg')\n\n\n #movie(test=False, labels=False) \n\n #cube_file = '../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits'\n # region_file = '../nro_maps/SouthShells.reg'\n # N = 2 # Number of shell candidates to plot\n # shell_list = get_shells(region_file=region_file)\n\n # cube_file = \"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\"\n # #cube_file = \"../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits\"\n\n # for n in range(1,2):\n # shell = shell_list[n]\n # for deg in np.linspace(0, 180, 13):\n # angle = deg*u.deg\n # pv = plot_pv(cube=cube_file, ra_center=shell.ra, dec_center=shell.dec,\n # vel=[4*u.km/u.s, 8*u.km/u.s], length=shell.radius*2.*4.,\n # width=7.5*u.arcsec, angle=105*u.deg,\n # pad_factor=1., plotname='12co_pv_shell'+str(n+1)+'_angle'+str(angle.value)+'morev.png', return_subplot=True,\n # stretch='linear', auto_scale=True)\n\n # cube_file = \"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\"\n # for n in range(N):\n # shell = shell_list[n]\n # plot_channels(cube=cube_file, ra=shell.ra.value, dec=shell.dec.value, radius=shell.radius.value,\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\n # plotname='12co_channels_shell'+str(n+1)+'.png', chan_step=2, plot_simbad_sources=True, simbad_color='blue')\n\n # cube_file = \"../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits\"\n # for n in range(N):\n # shell = shell_list[n]\n # plot_channels(cube=cube_file, ra=shell.ra.value, dec=shell.dec.value, radius=shell.radius.value,\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\n # plotname='13co_channels_shell'+str(n+1)+'.png', chan_step=2, plot_simbad_sources=True, simbad_color='blue')","def cloudy_hii_radial_hyd(props=['ne'],cols=['b'],model_name = '',**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n if p.add:\n ax = plt.gca()\n else:\n fig,ax = plt.subplots(figsize=(8,6))\n\n for prop,col in zip(props,cols):\n hyd = pd.read_table(p.d_cloudy_test + '%s.hyd' % model_name,skiprows=1,\\\n names=['depth','Te','nH','ne','HI/H','HII/H','H2/H','H2+/H','H3+/H','H-/H'])\n if '/' in prop:\n try:\n ax2.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'o',ms=5,color=col)\n ax2.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'-',lw=1,color=col,label=prop)\n except:\n print('no twinx axis, starting a new one')\n ax2 = ax.twinx()\n ax2.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'o',ms=5,color=col)\n ax2.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'-',lw=1,color=col,label=prop)\n else:\n ax.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'o',ms=5,color=col)\n ax.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'-',lw=1,color=col,label=prop)\n\n ax.set_xlabel('Depth [pc]')\n ax.set_ylabel('cm$^{-3}$')\n ax.legend()\n ax2.legend()\n\n if p.savefig:\n if not os.path.isdir(p.d_plot + 'cloudy/'): os.mkdir(p.d_plot + 'cloudy/') \n plt.savefig(p.d_plot + 'cloudy/%s_hyd.png' % (model_name), format='png', dpi=300, facecolor='w')","def plot_alleles(folder):\n\n abs_alt,perc_alt = parse_geno_file(folder,False)\n\n strain_matcher = re.compile('(.*) \\(.*\\)') ## regex to get strain name from radio button click\n strain_matcher2 = re.compile('(.*)-(.*)')\n \n fig, ax = plt.subplots()\n l, = plt.plot(perc_alt['MC'],perc_alt[S],'bs')\n ax.set_ylabel('Alternate Allele Percentage (MC)')\n ax.set_xlabel('Alternate Allele Percentage (MC)')\n \n rax1 = plt.axes([0.92, 0.1, 0.08, 0.8])\n radio1 = RadioButtons(rax1, ('MC (Sand)','CL (Sand)','CM (Sand)','CN (Sand)','TI (Sand)','DC (Sand)','MS (Sand)','CV (Sand)','PN (Rock)','AC (Rock)','LF (Rock)','MP (Rock)','MZ (Rock)','Sand-MC','Rock-MC','Sand-MZ','Rock-MZ','Rock-Sand'), active=0)\n\n rax2 = plt.axes([0.92, 0.9, 0.08, 0.1])\n radio2 = RadioButtons(rax2, ('%', 'Abs'), active=0)\n\n #for strain in perc_alt.keys():\n #print strain\n \n #ylabel = plt.axes([1,1,0.08,0.08])\n\n def update1(strain):\n if strain not in [\"Rock-MZ\",\"Sand-MC\",\"Rock-MC\",\"Sand-MZ\",\"Rock-Sand\"]:\n match = re.match(strain_matcher,strain)\n strain = match.group(1)\n global base\n base = 'MC'\n else:\n match = re.match(strain_matcher2,strain)\n strain = match.group(1)\n #global base \n base = match.group(2)\n\n #print D\n if(D == \"%\"):\n l.set_xdata(perc_alt[base])\n l.set_ydata(perc_alt[strain])\n ax.set_ylabel('Alternate Allele Percentage (%s)'%(strain))\n ax.set_xlabel('Alternate Allele Percentage (%s)'%(base))\n else:\n l.set_xdata(abs_alt[base])\n l.set_ydata(abs_alt[strain])\n ax.set_ylabel('Alternate Allele Absolute (%s)'%(strain))\n ax.set_xlabel('Alternate Allele Absolute (%s)'%(base))\n\n ax.relim()\n ax.autoscale()\n fig.canvas.draw_idle()\n global S \n #print S\n S = strain\n\n\n def update2(data):\n if(data == '%'):\n l.set_xdata(perc_alt[base])\n l.set_ydata(perc_alt[S])\n ax.relim()\n ax.autoscale()\n ax.set_ylabel('Alternate Allele Percentage (%s)'%(S))\n ax.set_xlabel('Alternate Allele Percentage (%s)'%(base))\n fig.canvas.draw_idle()\n if(data == 'Abs'):\n l.set_xdata(abs_alt[base])\n l.set_ydata(abs_alt[S])\n ax.relim()\n ax.autoscale()\n ax.set_ylabel('Alternate Allele Absolute (%s)'%(S))\n ax.set_xlabel('Alternate Allele Absolute (%s)'%(base))\n fig.canvas.draw_idle()\n \n global D\n D = data\n\n radio1.on_clicked(update1)\n radio2.on_clicked(update2)\n plt.show()","def createPrettyPlots(self, inputDir, outputDir, fnExtension = 'png'):\n number_of_entries_per_row = 4\n number_of_files_per_column = 2\n imageWidth = 200 # 1600 org is four times as large\n imageHeight = 150 # 1200\n nTmessage(\"Updating index files for input directory: %s\" % inputDir)\n if os.path.exists(outputDir):\n# nTmessage(\"Removing output directory: %s\" % outputDir)\n shutil.rmtree(outputDir)\n # end if\n# nTmessage(\"Creating output directory: %s\" % outputDir)\n os.mkdir(outputDir)\n# nTdebug(\"Doing copyCingHtmlJsAndCssToDirectory\")\n copyCingHtmlJsAndCssToDirectory(outputDir) \n# htmlDir = os.path.join(cingRoot, \"HTML\")\n fnMatchPattern = '*.' + fnExtension\n image_fn_list = glob(os.path.join(inputDir,fnMatchPattern)) \n inputDirBase = os.path.basename(inputDir)\n# nTdebug(\"Got relative part of inputDir: %s\" % inputDirBase) # e.g. plotTrend\n image_code_list = []\n for image_fn in image_fn_list:\n _root, image_code, _ext = nTpath(image_fn)\n image_code_list.append(image_code)\n # end for \n ## Get the number of files required for building an index\n number_of_images_all_present = len(image_code_list)\n number_of_images_per_file = number_of_entries_per_row * number_of_files_per_column\n ## Number of files with indexes in google style\n number_of_files = int(number_of_images_all_present / number_of_images_per_file)\n if number_of_images_all_present % number_of_images_per_file:\n number_of_files += 1\n # end if\n nTmessage(\"Creating %s pages for %s image codes\" % (number_of_files, number_of_images_all_present))\n# nTmessage(\"Generating %s index html files\" % (number_of_files))\n\n file_name = os.path.join (self.base_dir, \"data\", self.results_base, \"indexPplot.html\")\n file_content = open(file_name, 'r').read()\n old_string = r\"<!-- INSERT NEW TITLE HERE -->\"\n new_string = capitalizeFirst( inputDirBase )\n file_content = string.replace(file_content, old_string, new_string)\n old_string = r\"<!-- INSERT NEW FOOTER HERE -->\"\n file_content = string.replace(file_content, old_string, self.htmlFooter)\n old_string = r\"<!-- INSERT GOOGLE ANALYTICS TEMPLATE HERE -->\"\n file_content = string.replace(file_content, old_string, GOOGLE_ANALYTICS_TEMPLATE)\n old_string = r\"<!-- INSERT GOOGLE PLUS ONE TEMPLATE HERE -->\"\n file_content = string.replace(file_content, old_string, GOOGLE_PLUS_ONE_TEMPLATE)\n ## Count will track the number of entries done per index file\n images_done_per_file = 0\n ## Following variable will track all done sofar\n images_done_all = 0\n ## Tracking the number in the current row. Set for the rare case that there\n ## are no entries at all. Otherwise it will be initialize on first pass.\n num_in_row = 0\n ## Tracking the index file number\n file_id = 1\n ## Text per row in an index file to insert\n insert_text = ''\n ## Repeat for all entries plus a dummy pass for writing the last index file\n for image_code in image_code_list + [ None ]:\n ## Finish this index file\n ## The last index file will only be written once...\n if images_done_per_file == number_of_images_per_file or images_done_all == number_of_images_all_present:\n begin_image_count = number_of_images_per_file * (file_id - 1) + 1\n end_image_count = min(number_of_images_per_file * file_id,\n number_of_images_all_present)\n# nTdebug(\"begin_image_count, end_image_count, number_of_images_all_present: %5d %5d %5d\" % (\n# begin_image_count, end_image_count, number_of_images_all_present))\n # image_code is just the base name of the file name.\n new_string = \"Images: %s-%s of %s.\" % (\n begin_image_count,\n end_image_count,\n number_of_images_all_present\n )\n old_string = r\"<!-- INSERT NEW RESULT STRING HERE -->\" \n new_file_content = string.replace(file_content, old_string, new_string)\n # Always end the row by adding dummy columns\n if num_in_row != number_of_entries_per_row:\n insert_text += (number_of_entries_per_row - num_in_row) * 2 * r\"<td> </td>\" + r\"</tr>\"\n # end if\n ## Create the new index file from the example one by replacing a string\n ## with the new content.\n old_string = r\"<!-- INSERT NEW ROWS HERE -->\"\n new_file_content = string.replace(new_file_content, old_string, insert_text)\n\n first_string = '<a href=\"index_%s.html\">First < <</a>' % 1\n final_string = '<a href=\"index_%s.html\">Last > ></a>' % number_of_files\n prev_string = ''\n if file_id > 1:\n prev_string = '<a href=\"index_%s.html\">Previous <</a>' % ( file_id - 1)\n # end if\n next_string = ''\n if file_id < number_of_files:\n next_string = '<a href=\"index_%s.html\">> Next</a>' % ( file_id + 1)\n # end if\n first_link = max(1, file_id - number_of_files_per_column)\n last_link = min(number_of_files, file_id + number_of_files_per_column - 1)\n links_string = ''\n for link in range(first_link, last_link + 1):\n ## List link but don't include a link out for the current file_id\n if link == file_id:\n links_string += ' <B>%s</B>' % link\n else:\n links_string += ' <a href=\"index_%s.html\">%s</a>' % (\n link, link)\n # end if\n # end for\n old_string = r\"<!-- INSERT NEW LINKS HERE -->\"\n new_string = 'Result pages: ' + ' '.join([first_string, prev_string, links_string, next_string, final_string])\n new_file_content = string.replace(new_file_content, old_string, new_string)\n ## Make the first index file name still index.html\n new_file_name = os.path.join( outputDir, 'index_%s.html' % file_id)\n if not file_id:\n new_file_name = os.path.join( outputDir, '/index.html' )\n # end if \n writeTextToFile(new_file_name, new_file_content) \n images_done_per_file = 0\n num_in_row = 0\n insert_text = \"\"\n file_id += 1\n # end for\n ## Build on current index file\n ## The last iteration will not execute this block because of this clause\n if images_done_all < number_of_images_all_present:\n images_done_all += 1\n images_done_per_file += 1\n ## Get the html code right by abusing the formatting chars.\n ## as in sprintf etc.\n imageRelUrl = os.path.join( '..', inputDirBase, image_code + '.' + fnExtension)\n tmp_string = \"\"\"\n<td> <a href=\"%(imageRelUrl)s\"> <img SRC=\"%(imageRelUrl)s\" border=\"0\" width=\"%(imageWidth)s\" height=\"%(imageHeight)s\"> </a> </td>\"\"\" % dict(\n imageRelUrl=imageRelUrl, imageWidth=imageWidth, imageHeight=imageHeight)\n num_in_row = images_done_per_file % number_of_entries_per_row\n if num_in_row == 0:\n num_in_row = number_of_entries_per_row\n # end if\n if num_in_row == 1:\n # Start new row\n tmp_string = \"\\n<tr>\" + tmp_string\n elif (num_in_row == number_of_entries_per_row):\n # End this row\n tmp_string = tmp_string + \"\\n</tr>\"\n # end if\n insert_text += tmp_string\n # end if\n # end if\n index_file_first = 'index_1.html'\n index_file = os.path.join(outputDir, 'index.html')\n ## Assume that a link that is already present is valid and will do the job\n# nTdebug('Symlinking: %s %s' % (index_file_first, index_file))\n symlink(index_file_first, index_file)","def ex1_plots(instance, destination, prefix, save, animate):\n \n plts = ukf_plots(instance, destination, prefix, save, animate)\n\n truths = truth_parser(instance)\n nan_array= nan_array_parser(instance, truths, instance.base_model)\n #obs, obs_key = obs_parser(instance, True)\n obs_key = obs_key_parser(instance, True)\n preds = preds_parser(instance, True)\n #forecasts = forecasts_parser(instance, True)\n \n ukf_params = instance.ukf_params\n index2 = ukf_params[\"index2\"]\n \n \"remove agents not in model to avoid wierd plots\"\n #obs *= nan_array\n truths *= nan_array\n preds *= nan_array\n #forecasts*= nan_array\n \n \"indices for unobserved agents\"\n not_index2 = np.array([i for i in np.arange(truths.shape[1]) if i not in index2])\n plts.pair_frame(truths, preds, obs_key, 10, destination)\n plts.error_hist(truths[::instance.sample_rate,index2], \n preds[::instance.sample_rate,index2],\"Observed Errors\")\n if len(not_index2)>0:\n plts.error_hist(truths[::instance.sample_rate, not_index2], \n preds[::instance.sample_rate, not_index2],\"Unobserved Errors\")\n \n #plts.path_plots(obs[::instance.sample_rate] , \"Observed\")\n plts.path_plots(preds[::instance.sample_rate], \"Predicted\")\n plts.path_plots(truths, \"True\")\n #plts.path_plots(forecasts[::instance.sample_rate], \"Forecasts\")\n\n if animate:\n #plts.trajectories(truths, \"plots/\")\n plts.pair_frames(truths, preds, obs_key,\n truths.shape[0], \"../../plots/\")","def plot_files(n=15):\n lod = read_files(n)\n\n for i in range(len(lod)):\n plt.plot(range(len(lod[i])), lod[i])\n\n plt.show()","def plot_training_progress(model_output_path):\n try:\n results = load_results(model_output_path)\n except FileNotFoundError:\n print('monitor.csv file is not found!')\n\n results['l_moving_avg_100'] = results['l'].rolling(window=100).mean()\n results['r_moving_avg_100'] = results['r'].rolling(window=100).mean()\n results['t_per_M'] = results['t'] / 1000\n\n fig, axs = plt.subplots()\n results.plot(\n ax=axs,\n x='t_per_M', y='r_moving_avg_100',\n title='Training Progress',\n xlabel='Million Steps',\n ylabel='Mean Reward'\n )\n return results","def plot_Cmd_AngVel_EulerAng(data_fcs, data_vel, data_att, dest_folder=None):\n \n # Variables assignment\n t_fcs = data_fcs[:,0]\n delta_a = data_fcs[:,18]\n delta_e = data_fcs[:,6]\n delta_r = data_fcs[:,9]\n delta_t = data_fcs[:,20]\n \n t_vel = data_vel[:,0]\n p_rad = data_vel[:,4]\n q_rad = data_vel[:,5]\n r_rad = data_vel[:,6]\n \n t_att = data_att[:,0]\n phi_rad = data_att[:,1]\n the_rad = data_att[:,2]\n psi_rad = data_att[:,3]\n \n fig = plt.figure(figsize=(12.3,15))\n \n \n # Commands\n ax1a = fig.add_subplot(3,1,1)\n ax1a.plot(t_fcs, delta_a, ls='solid', color='r', label=r'$\\delta_a$')\n ax1a.plot(t_fcs, delta_e, ls='solid', color='g', label=r'$\\delta_e$')\n ax1a.plot(t_fcs, delta_r, ls='solid', color='b', label=r'$\\delta_r$')\n \n ax1a.set_title(\"Commands\") \n ax1a.set_xlabel(r'$t$ (s)')\n ax1a.set_ylabel(r'$\\delta_a$ , $\\delta_e$ , $\\delta_r$ (°)')\n ax1a.set_ylim(ymin=-1+np.floor(min(list(delta_a)+list(delta_e)+list(delta_r))),\n ymax=1+np.ceil(max(list(delta_a)+list(delta_e)+list(delta_r))))\n \n \n ax1b = ax1a.twinx()\n ax1b.plot(t_fcs, delta_t, ls='solid', color='0.65', label=r'$\\delta_t$')\n \n ax1b.set_ylabel(r'$\\delta_t$')\n ax1b.set_ylim(ymax=1, ymin=-0.05)\n \n handlesa, labelsa = ax1a.get_legend_handles_labels()\n handlesb, labelsb = ax1b.get_legend_handles_labels()\n ax1a.legend(handlesa+handlesb, labelsa+labelsb, ncol=4, loc='best')\n \n\n # Angular velocities\n ax2 = fig.add_subplot(3,1,2)\n \n ax2.plot(t_vel, (180/np.pi)*p_rad, color='r', label=r'$p$')\n ax2.plot(t_vel, (180/np.pi)*q_rad, color='g', label=r'$q$')\n ax2.plot(t_vel, (180/np.pi)*r_rad, color='b', label=r'$r$')\n \n ax2.set_title(\"Angular velocities\") \n ax2.set_xlabel(r'$t$ (s)')\n ax2.set_ylabel(r'$p$ , $q$ , $r$ (°/s)')\n \n handles, labels = ax2.get_legend_handles_labels()\n ax2.legend(handles, labels, ncol=3, loc='best')\n \n \n # Euler angles\n ax3a = fig.add_subplot(3,1,3)\n \n ax3a.plot(t_att, (180/np.pi)*phi_rad, color='r', label=r\"$\\phi$\")\n ax3a.plot(t_att, (180/np.pi)*the_rad, color='g', label=r\"$\\theta$\")\n \n ax3a.set_title(\"Euler angles\") \n ax3a.set_xlabel(r'$t$ (s)')\n ax3a.set_ylabel(r'$\\phi$ , $\\theta$ (°)')\n \n \n ax3b = ax3a.twinx()\n ax3b.plot(t_att, (180/np.pi)*psi_rad, color='b', label=r\"$\\psi$\")\n \n ax3b.set_ylabel(r'$\\psi$ (°)')\n \n handlesa, labelsa = ax3a.get_legend_handles_labels()\n handlesb, labelsb = ax3b.get_legend_handles_labels()\n ax3b.legend(handlesa+handlesb, labelsa+labelsb, ncol=3, loc='best')\n \n plt.tight_layout()\n \n \n # Export\n if dest_folder != None:\n plt.savefig(dest_folder+'plot_Cmd_AngVel_EulerAng.pdf')","def do_jet_pt_plots(tree, output_dir, cut=''):\n for logz, normx in product([True, False], [True, False]):\n make_2d_plot(tree, 'httL1', HTT_L1_STR, NB_HTT, HTT_MIN, HTT_MAX, 'pt', PT_L1_STR, NB_PT, PT_MIN, PT_MAX,\n os.path.join(output_dir, 'pt_httL1.pdf'), logz=logz, normx=normx,\n cut=cut, title=TITLE, diagonal_line=True)\n make_2d_plot(tree, 'httL1', HTT_L1_STR, NB_HTT, HTT_MIN, HTT_MAX, 'ptRef', PT_REF_STR, NB_PT, PT_MIN, PT_MAX,\n os.path.join(output_dir, 'ptRef_httL1.pdf'), logz=logz, normx=normx,\n cut=cut, title=TITLE, diagonal_line=True)\n make_2d_plot(tree, 'httRef', HTT_REF_STR, NB_HTT, HTT_MIN, HTT_MAX, 'pt', PT_L1_STR, NB_PT, PT_MIN, PT_MAX,\n os.path.join(output_dir, 'pt_httRef.pdf'), logz=logz, normx=normx,\n cut=cut, title=TITLE, diagonal_line=True)\n make_2d_plot(tree, 'httRef', HTT_REF_STR, NB_HTT, HTT_MIN, HTT_MAX, 'ptRef', PT_REF_STR, NB_PT, PT_MIN, PT_MAX,\n os.path.join(output_dir, 'ptRef_httRef.pdf'), logz=logz, normx=normx,\n cut=cut, title=TITLE, diagonal_line=True)","def plot_balance_list_output(balance_list, path, nframes=4):\n import matplotlib\n font = {'size' : 15, 'weight': 'normal'}\n matplotlib.rc('font', **font)\n\n nplots=len(balance_list)\n ncols=2\n nrows=int(np.ceil(nframes/ncols))\n _, axes = plt.subplots(nrows, ncols, figsize=(25, 5*nrows))\n for n in range(nframes):\n i = int(np.floor(n / ncols))\n j=n % ncols\n r_p = []\n for k in range(len(balance_list[n])-1):\n r_p.append(np.abs(balance_list[n][k]-balance_list[n][k+1])/balance_list[n][k])\n\n axes[i,j].plot(balance_list[n], label='balance', color='b')\n axes[i,j].set_title('Outer loop # '+ str(n))\n # axes[i,j].set_yscale('log')\n # axes[i,j].set_xscale('log')\n axes[i,j].grid(True)\n axes[i,j].set_ylabel('Balance norm')\n # axes[i,j].legend()\n axes[i,j].set_ylim([0, 10])\n # ax_2=axes[i,j].twinx()\n # ax_2.plot(r_p, 'g')\n # ax_2.set_yscale('log')\n # ax_2.set_ylabel('relative change')\n\n plt.savefig(path,transparent=True, dpi=400)","def plot_overview(cube=nro_12co,\n region_file='../shell_candidates/AllShells.reg', mode='peak', plotname='12co_peak_shells.png',\n interactive=False, show_shells=True, shells_highlight=None, dist=orion_dist, vmin=None, vmax=None,\n scalebar_color=\"white\", scalebar_pc = 1., scale_factor=1., pmin=0.25,\n pmax=99.75, cbar_label=r\"Peak T$_{\\rm MB}$ [K]\",\n circle_color='white', circle_linewidth=1, circle_style=\"solid\", return_fig=False, show=True,\n title=r\"$^{12}$CO Peak T$_{MB}$\", recenter=False, ra=None, dec=None, radius=None):\n try:\n cube = SpectralCube.read(cube)\n except ValueError:\n pass\n\n if mode == \"peak\":\n image = (cube.max(axis=0) * scale_factor).hdu\n \n\n if mode == \"mom0\":\n image = (cube.moment0() * scale_factor).hdu\n\n\n\n fig = FITSFigure(image)\n if show:\n fig.show_colorscale(cmap='viridis', vmin=vmin, vmax=vmax, pmin=pmin,\n pmax=pmax, interpolation='none')\n fig.tick_labels.set_yformat(\"dd:mm\")\n fig.tick_labels.set_xformat(\"hh:mm\")\n #fig.hide_yaxis_label()\n #fig.hide_ytick_labels()\n plt.title(title)\n plt.xlabel(\"RA (J2000)\")\n plt.ylabel(\"DEC (J2000)\")\n\n if show_shells:\n shell_list = get_shells(region_file=region_file)\n for i, shell in enumerate(shell_list):\n if shells_highlight:\n if i+1 in shells_highlight:\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle='solid', edgecolor=circle_color,\n facecolor='none', linewidth=3)\n else:\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle=circle_style, edgecolor=circle_color,\n facecolor='none', linewidth=circle_linewidth)\n else:\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle=circle_style, edgecolor=circle_color,\n facecolor='none', linewidth=circle_linewidth)\n\n #RECENTER\n if recenter:\n fig.recenter(ra, dec, radius)\n\n\n #SCALEBAR\n fig.add_scalebar(206265 * scalebar_pc / (dist.to(u.pc).value * 3600), color=scalebar_color)\n fig.scalebar.set_label(\"{} pc\".format(scalebar_pc))\n\n fig.add_colorbar()\n cb = fig.colorbar\n cb.set_axis_label_text(cbar_label)\n\n if return_fig:\n return fig\n else:\n fig.save(plotname, dpi=600)","def basic_stats_and_plots():\n \n basename = sys.argv[1]\n ops = (\"two_opt\", \"twoh_opt\", \"three_opt\", \"three_opt_broad\", \"swap\", \"swap_adj\")\n opfs = {\n \"two_opt\": tsp.two_opt,\n \"twoh_opt\": tsp.twoh_opt,\n \"three_opt\": tsp.three_opt,\n \"three_opt_broad\": tsp.three_opt_broad,\n \"swap\": tsp.swap_two,\n \"swap_adj\": tsp.swap_adj\n }\n \n lengths = range(6, 11)\n for length in lengths:\n stddev = []\n gini = []\n nneighbours = []\n prop_unique = []\n for op in ops:\n filename = os.path.join(basename,\n \"tsp_length_%d_%s\" % (length, op),\n \"TP_row0.dat\")\n print op, length\n x = np.genfromtxt(filename)\n # stats to get:\n stddev.append(np.std(x))\n gini.append(random_walks.gini_coeff(x))\n nneighbours.append(np.sum(x > 0))\n mu, sigma = rw_experiment_with_op(length, opfs[op])\n prop_unique.append((mu, sigma))\n\n gini_barchart(length, gini, ops)\n stddev_barchart(length, stddev, ops)\n plot_gini_v_nneighbours(length, gini, nneighbours, ops)\n plot_stddev_v_nneighbours(length, stddev, nneighbours, ops)\n plot_gini_v_prop_unique(length, gini, prop_unique, ops)\n plot_stddev_v_prop_unique(length, stddev, prop_unique, ops)"],"string":"[\n \"def plot_directory_profiles(path, outname=None, show=True, xscale=1, yscale=1,\\n xval='x', adjustRadial=True):\\n outdirs = np.sort(os.listdir(path))\\n plt.figure()\\n\\n #labels=['homogeneous','1D layering', '3D tomography'] #xscale=1e-3, yscale=1e2\\n for i,outdir in enumerate(outdirs):\\n pointsFile = os.path.join(path, outdir, 'points.h5')\\n #print(pointsFile)\\n #x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile, output='cyl',adjustRadial=adjustRadial)\\n #x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile)\\n #Load data\\n\\n x,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n #Y = uz / yscale\\n if xval == 'x':\\n X = x / xscale\\n Y1 = ux / yscale\\n elif xval == 'r':\\n X = np.hypot(x,y) / xscale\\n ur_fem = np.hypot(ux,uy)\\n Y1 = ur_fem / yscale\\n if adjustRadial: #fix sign from hypot square root\\n ur_fem = pu.radial2negative(Y1)\\n\\n x_fem = X #/ xscale #double scaling!\\n ur_fem = Y1 #/ yscale\\n uz_fem = uz / yscale\\n\\n #print(pointsFile)\\n print(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max())\\n\\n l, = plt.plot(x_fem,uz_fem,'.-',lw=3,label=outdir)\\n #l, = plt.plot(x_fem,uz_fem,'.-',lw=2,label=labels[i]) #for 3d heterogeneity example\\n plt.plot(x_fem,ur_fem,'.--',lw=3, mfc='w',color=l.get_color()) #mfc='none' transparent\\n\\n # Annotate\\n plt.axhline(color='k',lw=0.5)\\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\\n plt.legend()\\n\\n #NOTE: custom annotations for 3d heterogeneity\\n #plt.title('Elastic Heterogeneity Effects')\\n #plt.legend([l1,l2,l3],['homogeneous','1D layering', '3D tomography'])\\n\\n if outname: plt.savefig(outname)\\n if show: plt.show()\",\n \"def plot(profiler, outdir):\\n # go through the outputs of all morphisms\\n for cur_name, cur_output in profiler.profile.items():\\n cur_outdir = os.path.join(outdir, cur_name)\\n if not os.path.exists(cur_outdir):\\n os.makedirs(cur_outdir)\\n\\n ProfilePlotter.plot_morphism_output(cur_output, cur_outdir)\",\n \"def plot_morphism_output(data, outdir):\\n\\n # show the distributions for each variable separately\\n for col in data.columns:\\n ProfilePlotter._plot_1d(data[col], outfile = os.path.join(outdir, col + \\\".pdf\\\"))\\n\\n # later, maybe also show 2d plots etc.\",\n \"def plot_directory_numex(path, vals, param='density', outname=None, show=True,\\n xscale=1e-3,yscale=1e2):\\n #vals = arange(2300.0, 2800.0, 50.0)\\n outdirs = np.sort(os.listdir(path))\\n plt.figure()\\n\\n # Plot surface profiles for each parameter\\n for val,outdir in zip(vals,outdirs):\\n pointsFile = os.path.join(path, outdir, 'points.h5')\\n print(pointsFile)\\n x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile, output=True, adjustRadial=True)\\n x_fem = x_fem / xscale\\n ur_fem = ur_fem / yscale\\n uz_fem = uz_fem / yscale\\n l, = plt.plot(x_fem,uz_fem,'.-',label=str(val))\\n plt.plot(x_fem,ur_fem,'.-',color=l.get_color())\\n\\n # Annotate\\n plt.axhline(color='k') #zero displacement line\\n plt.title(param)\\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\\n plt.legend()\\n\\n if outname: plt.savefig(outname)\\n if show: plt.show()\",\n \"def plot_profile(outdir, xval='x', xscale=1, yscale=1, comp2los=False, adjustRadial=False,\\n fig=True):\\n #Load data\\n path = os.path.join(outdir,'points.h5')\\n x,y,z,ux,uy,uz = pu.extract_points(path)\\n\\n Y = uz / yscale\\n if xval == 'x':\\n X = x / xscale\\n Y1 = ux / yscale\\n elif xval == 'r':\\n X = np.hypot(x,y) / xscale\\n ur = np.hypot(ux,uy)\\n Y1 = ur / yscale\\n if adjustRadial: #fix sign from hypot square root\\n ur = pu.radial2negative(Y1)\\n\\n if fig:\\n plt.figure()\\n # otherwise profile added to active plot\\n\\n #plt.plot(X,uy/yscale,'r.-',label='Uy') #should be zero along EW axis\\n de = 90e3 / xscale #eastern data extent\\n if comp2los != False:\\n data_extents = (X<=de)\\n if comp2los == 'west': #switch sign of radial profile\\n #ux = -ux #move to comp2los function\\n X = -X\\n Y1 = -Y1\\n de = -de\\n data_extents = (X>=de)\\n\\n los = pu.comp2los(x,ux,uy,uz,track=comp2los)\\n plt.plot(X, los/yscale, 'k-', lw=2, label='Ulos_' + comp2los)\\n plt.fill_between(X,los/yscale, where=data_extents, color='gray',alpha=0.5)\\n\\n plt.plot(X, Y, 'b-', lw=2, label='Uz')\\n plt.plot(X, Y1, 'b--',lw=2, mfc='None',label='U{0}'.format(xval))\\n\\n # Annotate\\n plt.title(outdir)\\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n plt.ylabel('Uz [{}]'.format(get_unit(yscale)))\\n plt.axhline(color='k')\\n plt.axvline(de,color='k', linestyle='dashed', label='EW data extent') #EW extent of InSAR coverage\\n plt.legend(loc='best')\\n plt.grid(True)\\n plt.show()\",\n \"def plot_one_directory(args, dirnames, figname):\\n logdir = args.logdir\\n num = len(ATTRIBUTES)\\n fig, axes = subplots(num, figsize=(13,4*num))\\n\\n for (dd, cc) in zip(dirnames, COLORS):\\n A = np.genfromtxt(join(logdir, dd, 'log.txt'), \\n delimiter='\\\\t', \\n dtype=None, \\n names=True)\\n x = A['Iterations']\\n\\n for (i,attr) in enumerate(ATTRIBUTES):\\n axes[i].plot(x, A[attr], '-', lw=lw, color=cc, label=dd)\\n axes[i].set_ylabel(attr, fontsize=ysize)\\n axes[i].tick_params(axis='x', labelsize=tick_size)\\n axes[i].tick_params(axis='y', labelsize=tick_size)\\n axes[i].legend(loc='best', ncol=2, prop={'size':legend_size})\\n\\n axes[0].set_ylim([-10,10])\\n axes[1].set_ylim([-10,10])\\n axes[2].set_ylim([0,10])\\n axes[3].set_ylim([0,10])\\n\\n plt.tight_layout()\\n plt.savefig(figname)\",\n \"def create_plots(self):\\n if not os.path.exists(self.output_folder):\\n os.makedirs(self.output_folder)\\n self.sse_plot()\\n self.avg_sse_plot()\",\n \"def Plot(self):\\n\\n ### Create the path names ###\\n folder_string = self.params.folder+\\\"/plots/\\\"\\n u_string = self.params.folder+\\\"/plots/u.pdf\\\"\\n p_string = self.params.folder+\\\"/plots/p.pdf\\\"\\n\\n ### Check if folder exists ###\\n if not os.path.exists(folder_string): os.makedirs(folder_string)\\n\\n ### Plot the x component of velocity ###\\n plot(self.u_next[0],title=\\\"Velocity in the x Direction\\\")\\n plt.savefig(u_string)\\n plt.figure()\\n\\n ### Plot the pressure ###\\n plot(self.p_next,title=\\\"Pressure\\\")\\n plt.savefig(p_string)\\n plt.show()\",\n \"def run_plots(self):\\n # load the files\\n self.pre_dark_file = os.path.join(self.input_dir, 'step_lastframe.fits')\\n self.post_dark_file = os.path.join(self.input_dir, 'step_dark_current.fits')\\n self.jump_file = os.path.join(self.input_dir, 'step_jump.fits')\\n self.rate_file = os.path.join(self.input_dir, 'step_rate.fits')\\n self.ramp_file = glob.glob(os.path.join(self.input_dir, '*.fits'))[0]\\n\\n # plots\\n self.plot_jump_flags_image()\\n self.plot_groupdq_flags(pixel=[884, 550])\\n self.plot_ramps_pre_post_correction(pixel=[884, 550])\",\n \"def plot_it(self, ui=None, res_dir=None):\\r\\n print_it(\\\"plotting results\\\")\\r\\n plt_profile(self.sun, PltOpts.DD.value, res_dir, SubDir.profiles.value)\\r\\n plt_profile(self.sun, PltOpts.DDD.value, res_dir, SubDir.profiles.value)\\r\\n plt_profile(self.planet, PltOpts.DD.value, res_dir,\\r\\n SubDir.profiles.value)\\r\\n plt_profile(self.planet, PltOpts.DDD.value, res_dir,\\r\\n SubDir.profiles.value)\\r\\n plt_profile_approx(res_dir, SubDir.profiles.value)\\r\\n plt_contact(self.sun, self.planet, PltOpts.DD.value, res_dir,\\r\\n SubDir.contacts.value)\\r\\n plt_contact(self.sun, self.planet, PltOpts.DDD.value, res_dir,\\r\\n SubDir.contacts.value)\\r\\n\\r\\n plt_3d(self.sun.x_axis, self.sun.y_axis, self.sun.press,\\r\\n self.sun.x_label, self.sun.y_label, 'pressure in MPa',\\r\\n 'contact_pressure_sun', res_dir, SubDir.pressures.value,\\r\\n 'contact_pressure_sun')\\r\\n plt_2d_scatt_line(self.sun.x_axis, self.pv, self.sun.x_axis, self.pv,\\r\\n self.sun.x_label,\\r\\n 'pv_rel in {}'.format(Unit.pvrel.value), 'pv_rel',\\r\\n res_dir, SubDir.energy.value, 'pv_rel')\\r\\n plt_2d_scatt_line(self.sun.x_axis, self.sun.e_akin, self.sun.x_axis,\\r\\n self.sun.e_akin, self.sun.x_label,\\r\\n 'e_akin in {}'.format(Unit.eakin.value), 'e_akin',\\r\\n res_dir, SubDir.energy.value, 'sun.e_akin')\\r\\n plt_2d_scatt_line(self.planet.x_axis, self.planet.e_akin,\\r\\n self.planet.x_axis, self.planet.e_akin,\\r\\n self.planet.x_label,\\r\\n 'e_akin in {}'.format(Unit.eakin.value), 'e_akin',\\r\\n res_dir,\\r\\n SubDir.energy.value, 'planet.e_akin')\\r\\n plt_energy_ring_on_ring(self, res_dir, SubDir.energy.value,\\r\\n 'e-akin-vs-pv-rel')\",\n \"def main():\\n\\n\\timport numpy as np\\n\\timport matplotlib as mpl\\n\\n\\t# Parse arguments\\n\\targs = cli.parse_args()\\n\\n\\t# Check all files exist\\n\\tfor filepath in args.files:\\n\\t\\tif not os.path.isfile(filepath):\\n\\t\\t\\t_exit('file {} does not exist'.format(filepath))\\n\\n\\t# Use TK interactive backend as it should work on all installations\\n\\tmpl.use('tkagg')\\n\\n\\t# Turn on interactive plotting (pyplot import must come after call to use())\\n\\timport matplotlib.pyplot as plt\\n\\tplt.ion()\\n\\n\\t# Get torsion angle arrays for all input files\\n\\tarrays = []\\n\\tfor filepath in args.files:\\n\\t\\twith open(filepath) as fobj:\\n\\t\\t\\tchain = list(parse_pdb_chain(fobj))\\n\\t\\t\\tarrays.append(torsion_array(chain))\\n\\n\\tangles = np.concatenate(arrays, axis=0)\\n\\n\\t# Make the plot\\n\\tif args.plottype == 'hexbin':\\n\\t\\thb = ramachandran_hexbin(angles, log=args.log, degrees=not args.radians)\\n\\t\\tif args.cbar:\\n\\t\\t\\tplt.colorbar(hb)\\n\\n\\telif args.plottype == 'scatter':\\n\\t\\tramachandran_scatter(angles, degrees=not args.radians)\\n\\n\\telif args.plottype == 'kde':\\n\\t\\t_assert_seaborn_available('kde')\\n\\t\\tramachandran_kdeplot(angles, shade=True, degrees=not args.radians)\\n\\n\\telif args.plottype == 'joint':\\n\\t\\t_assert_seaborn_available('joint')\\n\\t\\tramachandran_jointplot(angles, kind='kde', degrees=not args.radians)\\n\\n\\telse:\\n\\t\\traise ValueError(args.plottype)\\n\\n\\t# Plot title\\n\\tif len(args.files) == 1:\\n\\t\\tfilename = os.path.basename(args.files[0])\\n\\telse:\\n\\t\\tfilename = '{} files'.format(len(args.files))\\n\\n\\tplt.gcf().suptitle('{} ({} residues)'.format(filename, angles.shape[0]))\\n\\n\\t# Show the plot, blocking until closed\\n\\tplt.show(block=True)\",\n \"def plot_potential_profile(rims_object):\\r\\n if not os.path.exists(rims_object.path_for_output):\\r\\n os.makedirs(rims_object.path_for_output)\\r\\n number_of_profiles = rims_object.potential_profile_mat.shape[0]\\r\\n x = [dx * pow(10, 4) for dx in rims_object.x_space_vec]\\r\\n fig, axs = plt.subplots(number_of_profiles)\\r\\n plt.suptitle('RIMS: Ratchet potential profiles', fontsize=14, fontweight='bold')\\r\\n\\r\\n for i_profile in range(number_of_profiles):\\r\\n y = [dy for dy in rims_object.potential_profile_mat[i_profile]]\\r\\n axs[i_profile].plot(x, y, color=YELLOW, label=\\\"V(x) potential profile\\\")\\r\\n axs[i_profile].tick_params(axis='y', labelcolor=YELLOW)\\r\\n ax2 = axs[i_profile].twinx()\\r\\n y = [dy * pow(10, -4) for dy in rims_object.electric_field_mat[i_profile]]\\r\\n ax2.plot(x, y, color=PURPLE, label=r\\\"E(x) electric field = -$\\\\nabla $V\\\")\\r\\n ax2.tick_params(axis='y', labelcolor=PURPLE)\\r\\n text_kwargs = dict(fontsize=10, color=YELLOW, fontweight='bold')\\r\\n fig.text(0.1, 0.91, 'V(x) potential profile [v]', text_kwargs)\\r\\n text_kwargs = dict(fontsize=10, color=PURPLE, fontweight='bold')\\r\\n fig.text(0.5, 0.91, r\\\"E(x) electric field = -$\\\\nabla $V [v/$\\\\mu $m]\\\", text_kwargs)\\r\\n axs[number_of_profiles-1].set_xlabel(r\\\"X [$\\\\mu $m]\\\")\\r\\n\\r\\n if number_of_profiles < 4:\\r\\n fig.tight_layout()\\r\\n plt.savefig(rims_object.path_for_output + 'Ratchet potential profiles.jpeg')\\r\\n plt.close()\\r\\n write_to_log(rims_object, \\\"potential profile plot saved\\\")\\r\\n return\",\n \"def generate_plots(path):\\n videos = glob(path + '/*.mkv')\\n print(path, len(videos), videos)\\n\\n if len(videos) == 0:\\n return\\n else:\\n videos = videos[0]\\n\\n metadata_list = glob(path + '/metadata.txt')\\n #print(path, len(metadata_list), metadata_list)\\n\\n if len(metadata_list) == 0:\\n return \\n\\n P = Preprocessor()\\n P.import_video(str(videos))\\n P.read_metadata(path)\\n P.preprocess()\\n Im = P.frames_processed\\n if len(Im) == 0:\\n print(len(Im))\\n return\\n\\n z_start = P.z_start\\n z_end = P.z_end\\n\\n mean, cov = analyze_image(Im)\\n\\n window_size = 10\\n mean_smoothed = smoothing.mean_moving_average(mean, window_size)\\n cov_smoothed = smoothing.cov_moving_average(cov, window_size)\\n\\n c = CubicFitRotated()\\n c.fit(mean=mean_smoothed, cov=cov_smoothed, z_start=z_start, z_end=z_end)\\n\\n try:\\n os.mkdir(path + '/analysis')\\n path += '/analysis'\\n except OSError:\\n pass\\n\\n\\n plots.plot_mean(mean, z_start, z_end).savefig(path + '/beam_center.png')\\n plots.plot_beta(cov, z_start, z_end).savefig(path + '/sigma_squared.png')\\n\\n export.export_mean(mean = mean, filename = path + '/center.csv', z_start = z_start, z_end = z_end)\\n export.export_cov(cov = cov, filename = path + '/cov.csv', z_start = z_start, z_end = z_end)\\n\\n plt.close('all')\",\n \"def plot(self):\\n\\t\\tplot_chain(self.database_path, self.temp_folder)\\n\\t\\tplot_density(self.database_path, self.temp_folder, self.cal_params)\",\n \"def plot_visualization(path_results, x_data, y_data, variant_mode, nb_classes, signal_test, args):\\n\\n\\t#path_tsne = path_results + \\\"/Visualization/train/\\\" + str(args.step) + \\\"_2d.csv\\\"\\n\\t#data_frame = pd.read_csv(path_tsne)\\n\\t\\n\\tpath_maping = path_results + \\\"/Maping/\\\" + str(args.subject).split(\\\".txt\\\")[0] + \\\"/\\\"\\n\\tfilename = path_maping + \\\"maping_\\\" + str(args.step) + \\\"_\\\" + str(args.subject).split(\\\".txt\\\")[0] + \\\"_stick\\\" + str(args.stick) + \\\".png\\\"\\n\\n\\tprint(\\\"path_save maping\\\", path_maping)\\n\\n\\tif not os.path.exists(path_maping):\\n\\t\\tos.makedirs(path_maping)\\n\\n\\t#print(\\\"path_tsne\\\", path_tsne)\\n\\n\\tlabel_maping = np.array([10])\\n\\n\\tx_data = np.concatenate((x_data,signal_test),axis=0)\\n\\ty_data = np.concatenate((y_data,label_maping),axis=0)\\n\\n\\tprint(\\\"x_data concatenate\\\",x_data.shape)\\n\\tprint(\\\"y_data concatenate\\\",y_data.shape)\\n\\n\\tdata_frame = tsne_2d(x_data, y_data)\\n\\n\\t\\n\\t\\n\\tgroups = data_frame.groupby('label')\\n\\n\\tcluster_names, cluster_colors = get_target_names_dr(nb_classes, args.mode, args, variant_mode)\\n\\n\\tfig = plt.figure(figsize=(20, 10))\\n\\tax = fig.add_subplot(111)\\n\\tax.margins(0.05) # Optional, just adds 5% padding to the autoscaling\\n\\tfor name, group in groups:\\n\\t\\t\\n\\t\\tif cluster_names[name] == str(args.subject):\\n\\t\\t\\tax.scatter(group.x, group.y, marker='D', s=150, edgecolors = 'face',label=cluster_names[name], color=cluster_colors[name])\\n\\t\\telse:\\n\\t\\t\\tax.scatter(group.x, group.y, marker='o', label=cluster_names[name], color=cluster_colors[name])\\n\\n\\tax.legend(numpoints=1) #show legend with only 1 point\\n\\tplt.savefig(filename) #save the plot\",\n \"def plot_dat_file(dat_paths: [str]):\\n import pandas as pd\\n import matplotlib.pyplot as plt\\n\\n fig, ax = plt.subplots(1, 3, sharey=\\\"all\\\", sharex=\\\"col\\\", figsize=(8, 6))\\n for i, dat_path in enumerate(dat_paths):\\n if i == i:\\n skipfoot = 11 + 9\\n else:\\n skipfoot = 11\\n dat_file = pd.read_csv(\\n dat_path,\\n skiprows=3,\\n skipfooter=skipfoot,\\n header=None,\\n delim_whitespace=True,\\n engine=\\\"python\\\",\\n )\\n depth = dat_file.values[:, 0]\\n vp = dat_file.values[:, 1]\\n vs = dat_file.values[:, 3]\\n dens = dat_file.values[:, 5]\\n\\n ax[0].plot(vp, depth, label=f\\\"nr {i}\\\")\\n\\n ax[1].plot(vs, depth)\\n ax[2].plot(dens, depth)\\n ax[0].set_ylim(ax[0].get_ylim()[::-1])\\n ax[0].legend()\\n plt.show()\",\n \"def plot_directory_surface_rmse(path, vals, param='Vp'):\\n\\n unw = '/home/scott/data/insar/cvz/t2282/geo/geo_stack282_8rlks.unw'\\n incidence = '/home/scott/data/insar/cvz/t2282/aux_files/geo_incidence_8rlks.unw'\\n dem = '/home/scott/data/dems/cgiar/uturuncu_1000_1000.tif'\\n #surface = '/home/scott/research/models/pylith/3d/uturuncu_layered/output/step01/surface.h5'\\n #geosurface = '/home/scott/research/models/pylith/scripts/geo_fem_Uz.tif'\\n\\n plt.figure()\\n outdirs = np.sort(os.listdir(path))\\n\\n # Calculate rmse\\n rmse = np.zeros_like(vals)\\n for i,outdir in enumerate(outdirs):\\n surface = os.path.join(path,outdir,'surface.h5')\\n los,fem_los,residual = pu.los2pylith(surface, dem, unw, incidence)\\n rmse[i] = rms_flat(residual[np.isfinite(residual)])\\n\\n plt.plot(vals,rmse,'b.-')\\n\\n # Annotate\\n #plt.title(param)\\n plt.xlabel('{} [km]'.format(param))\\n plt.ylabel('RMSE [cm]')\\n plt.legend()\\n plt.show()\",\n \"def plot_results(dir_path):\\n results, labels, dx = get_results_labels(dir_path)\\n\\n colors = plt.cm.get_cmap('tab10', len(labels)+1)\\n fig = plt.figure(figsize=(16, 9))\\n for i, (label, result) in enumerate(zip(labels, results)):\\n plt.plot(np.arange(result.shape[1]) * dx, np.mean(result, 0),\\n color=colors(i), linewidth=2, label=label)\\n plt.fill_between(np.arange(len(result[0])) * dx,\\n np.mean(result, 0) - np.std(result, 0),\\n np.mean(result, 0) + np.std(result, 0),\\n alpha=0.25, color=colors(i))\\n plt.title('Training Performance of Different Algorithms', fontsize=25)\\n plt.ylabel('Cumulative return', fontsize=20)\\n plt.xlabel('Steps', fontsize=20)\\n plt.xlim([0, results[0].shape[1] * dx])\\n plt.tick_params(labelsize=15)\\n plt.ticklabel_format(axis='both', style='sci', scilimits=(-2, 2))\\n plt.legend(fontsize=20)\\n plt.grid(linestyle=':')\\n plt.show()\\n\\n return fig\",\n \"def plot(cp_profile, *args, destination=\\\"browser\\\",\\n show_profiles=True, show_observations=True, show_residuals=False, show_rugs=False,\\n aggregate_profiles=None, selected_variables=None,\\n color=None, size=2, alpha=0.4,\\n color_pdps=None, size_pdps=None, alpha_pdps=None,\\n color_points=None, size_points=None, alpha_points=None,\\n color_residuals=None, size_residuals=None, alpha_residuals=None,\\n height=500, width=600,\\n plot_title='', yaxis_title='y',\\n print_observations=True,\\n **kwargs):\\n\\n params = dict()\\n params.update(kwargs)\\n params[\\\"variables\\\"] = _calculate_plot_variables(cp_profile, selected_variables)\\n params['color'] = \\\"_label_\\\" if args else color\\n params['show_profiles'] = show_profiles\\n params['show_observations'] = show_observations\\n params['show_rugs'] = show_rugs\\n params['show_residuals'] = show_residuals and (cp_profile.new_observation_true is not None)\\n params['add_table'] = print_observations\\n params['height'] = height\\n params['width'] = width\\n params['plot_title'] = plot_title\\n params['size_ices'] = size\\n params['alpha_ices'] = alpha\\n params = _params_update(params,\\n color_pdps=color_pdps, size_pdps=size_pdps, alpha_pdps=alpha_pdps,\\n size_points=size_points, alpha_points=alpha_points, color_points=color_points,\\n size_residuals=size_residuals, alpha_residuals=alpha_residuals,\\n color_residuals=color_residuals,\\n yaxis_title=yaxis_title)\\n\\n if aggregate_profiles in {'mean', 'median', None}:\\n params['aggregate_profiles'] = aggregate_profiles\\n else:\\n logging.warning(\\\"Incorrect function for profile aggregation: {}. Parameter ignored.\\\"\\n \\\"Available values are: 'mean' and 'median'\\\".format(aggregate_profiles))\\n params['aggregate_profiles'] = None\\n\\n all_profiles = [cp_profile] + list(args)\\n\\n plot_id = str(next(_PLOT_NUMBER))\\n plot_path, params_path, obs_path, profile_path = _get_data_paths(plot_id)\\n\\n with open(params_path, 'w') as f:\\n f.write(\\\"params = \\\" + json.dumps(params, indent=2) + \\\";\\\")\\n\\n save_observations(all_profiles, obs_path)\\n save_profiles(all_profiles, profile_path)\\n\\n with app.app_context():\\n data = render_template(\\\"plot_template.html\\\", i=plot_id, params=params)\\n\\n with open(plot_path, 'w') as f:\\n f.write(data)\\n\\n destination = _detect_plot_destination(destination)\\n if destination == \\\"notebook\\\":\\n from IPython.display import IFrame, display\\n display(IFrame(plot_path, width=int(width * 1.1), height=int(height * 1.1)))\\n else:\\n # open plot in a browser\\n if sys.platform == \\\"darwin\\\": # check if on OSX\\n plot_path = \\\"file://\\\" + os.path.abspath(plot_path)\\n webbrowser.open(plot_path)\",\n \"def combine_plot(qa_out_path,brain_path):\\n \\n #Get the scan volume of the brain.\\n brain_ref = nib.load(brain_path)\\n brain_ref_shape = brain_ref.shape[0:3]\\n \\n plots_list = ['Rotate_Z_axis_000000.png','Rotate_Z_axis_000001.png','Rotate_Z_axis_000002.png',\\n 'Rotate_Y_axis_000000.png','Rotate_Y_axis_000001.png','Rotate_Y_axis_000002.png',\\n 'Rotate_X_axis_000000.png','Rotate_X_axis_000001.png','Rotate_X_axis_000002.png']\\n y_labels = [\\\"Rotate with Z axis\\\",\\\"Rotate with Y axis\\\",\\\"Rotate with X axis\\\"]\\n x_labels = [\\\"angle=0\\\",\\\"angle=120\\\",\\\"angle=240\\\"]\\n \\n #Temporary list to store the image nparray:\\n im_arr=[] \\n \\n fig= plt.figure()\\n plt.title(f'QA_tractography. Scan volume = {brain_ref_shape} \\\\n\\\\n', fontsize=60,fontweight='bold')\\n plt.xticks([])\\n plt.yticks([])\\n plt.axis(\\\"off\\\")\\n\\n j = 0\\n for i in range(9):\\n #Load in the nine images into a nparray one by one.\\n im_arr = np.array(Image.open(qa_out_path + \\\"/\\\" + plots_list[i]))\\n #Change the background of the image into black:\\n im_arr = np.where(im_arr<=0.01, 255, im_arr) \\n ax = fig.add_subplot(3,3,i+1)\\n ax.imshow(im_arr,interpolation=\\\"none\\\",alpha=0.9)\\n \\n #Set the X labels and Y labels\\n if i<3:\\n ax.set_title(x_labels[i],fontsize=60,fontweight='bold')\\n if i % 3 == 0:\\n ax.set_ylabel(y_labels[j],fontsize=60,fontweight='bold')\\n j = j + 1\\n plt.xticks([])\\n plt.yticks([])\\n \\n fig.set_size_inches(40, 40, forward = True)\\n fig.savefig(qa_out_path + \\\"/\\\" + 'qa_tractography.png', format='png')\\n\\n #Delete the Nine images which used to generate the qa_tractography.png \\n for plot in plots_list:\\n if os.path.exists(qa_out_path + \\\"/\\\" + plot):\\n os.remove(qa_out_path + \\\"/\\\" + plot)\\n else:\\n print('No such file generated from streamlines window. Please check if the streamline.trk files is generated from the pipeline correctly or not')\",\n \"def matplotlib_plot(self, output_dir: Union[str, Path]):\\n keys2 = set.union(*[set(self.get_keys2(k)) for k in self.get_keys()])\\n for key2 in keys2:\\n keys = [k for k in self.get_keys() if key2 in self.get_keys2(k)]\\n plt = self._plot_stats(keys, key2)\\n p = Path(output_dir) / f\\\"{key2}.png\\\"\\n p.parent.mkdir(parents=True, exist_ok=True)\\n plt.savefig(p)\",\n \"def plot_parcles_run(k, v):\\n\\n L.info(f'Received Input: {v}')\\n\\n L.info(f\\\"Plotting results from: {v['filepath']}\\\")\\n\\n plotpath = Path(__file__).parent.parent / 'plots'\\n filename = v['id'] + '.png'\\n plotfile = str(plotpath / filename) \\n\\n plotTrajectoriesFile(v['filepath'], mode='2d', show_plt=False)\\n f = plt.gcf()\\n f.savefig(plotfile)\\n\\n L.info(f'Saved plot to: {plotfile}')\",\n \"def plot_all_LLRs(self, outdir):\\n\\t\\t#Iterate over all parameter groups\\n\\t\\tfor group in self.group_names:\\n\\t\\t\\tself.plot_group_LLR(groupname=group, outdir=outdir)\",\n \"def plot_track_rigidbody(params, datadir, pp=4, zoom=None):\\n h = params['h']\\n\\n # get dirs\\n xypath = sorted(glob.glob(datadir + 'xyv/'))[0]\\n # list files\\n xyfiles = sorted(glob.glob(xypath + '*.txt'))\\n\\n plt.clf()\\n ax1 = plt.subplot(5, 1, 1)\\n ax2 = plt.subplot(5, 1, 2)\\n ax3 = plt.subplot(5, 1, 3)\\n ax4 = plt.subplot(5, 1, 4)\\n ax5 = plt.subplot(5, 1, 5)\\n doall = range(0, len(xyfiles))\\n for i in doall:\\n iterind = (xyfiles[i].split('_')[-1]).split('.')[0]\\n t = float(iterind) * h\\n\\n x, y, theta, phi, psi = np.loadtxt(xyfiles[i], delimiter=',', usecols=(0, 1, 2, 3, 4), unpack=True)\\n # vX,vY,vtheta,vphi,vpsi = np.loadtxt(xyfiles[i],delimiter=',', usecols=(5,6,7,8,9), unpack=True)\\n\\n ax1.plot(t, x[pp], 'k.')\\n ax2.plot(t, y[pp], 'r.')\\n ax3.plot(t, theta[pp], 'r.')\\n ax4.plot(t, phi[pp], 'r.')\\n ax5.plot(t, psi[pp], 'g.')\\n\\n title = 'Tracking Single Gyro'\\n ax1.set_title(title)\\n ax5.set_xlabel('time')\\n ax1.set_ylabel('X')\\n ax2.set_ylabel('Y')\\n ax3.set_ylabel(r'$\\\\theta$')\\n ax4.set_ylabel(r'$\\\\phi$')\\n ax5.set_ylabel(r'$\\\\psi$')\\n\\n ax1.set_xlim([-h, t])\\n ax2.set_xlim([-h, t])\\n ax3.set_xlim([-h, t])\\n ax4.set_xlim([-h, t])\\n ax5.set_xlim([-h, t])\\n\\n ax1.set_xticks([])\\n ax2.set_xticks([])\\n ax3.set_xticks([])\\n ax4.set_xticks([])\\n\\n outname = datadir + 'Track.png'\\n plt.savefig(outname)\\n\\n if zoom != None:\\n ax1.set_xlim([-h, zoom])\\n ax2.set_xlim([-h, zoom])\\n ax3.set_xlim([-h, zoom])\\n ax4.set_xlim([-h, zoom])\\n ax5.set_xlim([-h, zoom])\\n\\n outname = datadir + 'Track_zoom.png'\\n plt.savefig(outname)\",\n \"def plot_pdf(pop_name, pop_val, pop_file, full_pop_file, outdir='.'):\\n try:\\n plt.style.use(\\n \\\"https://gist.githubusercontent.com/avivajpeyi/4d9839b1ceb7d3651cbb469bc6b0d69b/raw/4ee4a870126653d542572372ff3eee4e89abcab0/publication.mplstyle\\\")\\n except Exception:\\n pass\\n\\n plt.close('all')\\n all = pd.read_csv(full_pop_file, sep=\\\" \\\")\\n all['cos_theta_1'] = all['cos_tilt_1']\\n all = process_samples(all)\\n sub = pd.read_csv(pop_file, sep=\\\" \\\")\\n sub = process_samples(sub)\\n sub['cos_theta_1'] = sub['cos_tilt_1']\\n\\n fig, axes = plt.subplots(1, 2, figsize=(10, 5))\\n for ax, l in zip(axes, [\\\"cos_theta_1\\\", \\\"cos_theta_12\\\"]):\\n ax.hist(all[l], density=True, histtype='step', color=\\\"tab:blue\\\", label=\\\"ALL\\\", lw=2, alpha=0.8)\\n ax.scatter(all[l], [0 for _ in all[l]], color=\\\"tab:blue\\\",marker=\\\"+\\\")\\n ax.hist(sub[l], density=True, histtype='step', color=\\\"tab:purple\\\", label=\\\"HIGH SNR\\\", lw=2, alpha=0.6)\\n ax.scatter(sub[l], [0 for _ in sub[l]], color=\\\"tab:purple\\\", marker=\\\"+\\\")\\n\\n x = np.linspace(-1, 1, 100)\\n y1 = TruncatedNormal(mu=1, sigma=pop_val[0], minimum=-1, maximum=1).prob(x)\\n y2 = TruncatedNormal(mu=1, sigma=pop_val[1], minimum=-1, maximum=1).prob(x)\\n axes[1].plot(x, y2, color='tab:gray', zorder=-10, lw=3, label=\\\"TRUE\\\")\\n axes[0].plot(x, y1, color='tab:gray', zorder=-10, lw=3)\\n\\n for i in range(len(axes)):\\n if (i == 0):\\n axes[i].set_xlabel(r\\\"$\\\\cos\\\\ \\\\theta_1$\\\")\\n axes[i].set_ylabel(\\\"PDF\\\")\\n else:\\n axes[i].set_xlabel(r\\\"$\\\\cos\\\\ \\\\theta_{12}$\\\")\\n axes[i].set_yticklabels([])\\n axes[i].legend()\\n axes[i].grid(False)\\n axes[i].set_xlim(-1, 1)\\n\\n plt.suptitle(f\\\"POP {pop_name}\\\")\\n plt.tight_layout()\\n plt.savefig(f\\\"{outdir}/pop_trues_{pop_name}.png\\\")\",\n \"def plot_dir(main):\\n try:\\n wd = str(main.lineEdit_8.text())\\n if wd == '':\\n main.msg(\\\"Error \\\"+errorPath+\\\"plot_dir: Must choose directory first\\\")\\n return\\n for fi in os.listdir(wd):\\n dataPath = os.path.join(wd, fi)\\n main.msg(\\\"Plotting \\\"+str(fi))\\n img = mpimg.imread(str(dataPath))\\n imgObj = Img.Img(img, title=str(fi), filePath=str(dataPath))\\n main.imgObjList.append(imgObj)\\n func.update(main)\\n slider.slider_update(main)\\n except:\\n main.msg(\\\"Error \\\"+errorPath+\\\"plot_dir: Make sure all files are images (tiff, jpeg, etc.)\\\")\",\n \"def plot(path, subjects):\\n transformToXYZmm = np.array([[-3.125, 0, 0, 81.250], [0, 3.125, 0, -115.625], [0, 0, 6, -54.000], [0, 0, 0, 1.000]])\\n data = data_load.load_data(path, subjects)\\n dimx = int(data[0][\\\"meta\\\"][\\\"dimx\\\"][0])\\n dimy = int(data[0][\\\"meta\\\"][\\\"dimy\\\"][0])\\n dimz = int(data[0][\\\"meta\\\"][\\\"dimz\\\"][0])\\n coordToCol = data[0][\\\"meta\\\"][\\\"coordToCol\\\"][0][0]\\n images = {}\\n max_val = 0\\n voxels = np.load(\\\"data/general_selected_500_1.npy\\\")\\n directory = os.listdir(\\\"data/input/\\\")\\n bar = pyprind.ProgBar(len(directory), title='Info extraction and Image Building')\\n bar2 = pyprind.ProgBar(len(images.keys()), title='Saving Pictures')\\n for file in directory:\\n file_name = \\\"data/input/{}\\\".format(file)\\n fh = open(file_name)\\n activation_values = np.asarray(list(map(lambda x: float(x), filter(lambda x: x != '', fh.read().split(\\\",\\\")))))\\n fh.close()\\n plot_matrix = np.zeros((dimx, dimy, dimz))\\n for x in range(dimx):\\n for y in range(dimy):\\n for z in range(dimz):\\n indice = coordToCol[x][y][z]\\n if indice != 0:\\n if indice in list(voxels):\\n voxel_indice = list(voxels).index(indice)\\n value = activation_values[voxel_indice]\\n if abs(value) > max_val:\\n max_val = abs(value)\\n plot_matrix[x][y][z] = value\\n image = nib.Nifti1Image(plot_matrix, transformToXYZmm)\\n images[file_name] = image\\n bar.update(force_flush=True)\\n print(bar)\\n for image in images:\\n plotting.plot_glass_brain(images[image], display_mode='ortho', vmax=max_val, plot_abs=False, threshold=None, colorbar=True, output_file=\\\"{}-wom1.png\\\".format(image))\\n bar2.update(force_flush=True)\\n print(bar2)\",\n \"def plot_folder(folder, title, stochastic=True):\\n results = open_folder(folder, stochastic=stochastic)\\n assert len(results) > 0, 'Cannot find any results'\\n ce_values = np.concatenate(\\n [np.expand_dims(r.item()['train_xent'][:-1], 1) for r in results],\\n axis=1)\\n steps = np.concatenate(\\n [np.expand_dims(r.item()['step'][:-1], 1) for r in results], axis=1)\\n alpha_eff_values = np.concatenate(\\n [\\n np.expand_dims(r.item()['lr'] / (1.0 - r.item()['momentum']), 1)\\n for r in results\\n ],\\n axis=1)\\n condition = ['Manual', 'SMD']\\n plot_report_figure_combined(\\n steps,\\n ce_values,\\n alpha_eff_values,\\n condition,\\n title,\\n 'Loss',\\n 'Eff. Learning Rate',\\n os.path.join(\\n folder, 'combined_{}.pdf'.format('stoc' if stochastic else 'det')),\\n include_legend=True)\",\n \"def plot_PDs(output_path,M_max,max_dim,normalized=False,output_name=None):\\n plots_folder = os.path.join(output_path,'plots')\\n if output_name is None: \\n aux = ['PDs']\\n input_file = os.path.join(output_path,'outputs_PDS.csv')\\n else:\\n aux = [output_name,'PDs']\\n input_file = os.path.join(output_path,'%s_PDS.csv' % output_name)\\n if normalized is True:\\n aux.append('normalized')\\n plot_file_name = '-'.join(aux)+'.png'\\n plot_file_name = os.path.join(plots_folder,plot_file_name)\\n\\n \\n data = pd.read_csv(input_file,index_col = 0)\\n \\n\\n fig_size_aux = 15/(3-max_dim)\\n plt.figure(figsize=(fig_size_aux,5))\\n if(normalized):\\n for i in range(1,max_dim+2):\\n plt.subplot(1,max_dim+1,i, aspect='equal')\\n plt.plot(data[data.dimH==i-1].birth.values/np.float(M_max),data[data.dimH==i-1].death.values/np.float(M_max),'bo',alpha=.3,label='dim %i'%(i-1))\\n plt.xlim((0,1)); plt.ylim((0,1))\\n frame = plt.legend(loc=4,frameon=True,title='normalized')\\n frame = frame.get_frame()\\n frame.set_edgecolor('black')\\n plt.xlabel('birth'); plt.ylabel('death')\\n plt.plot([0, 1], [0, 1], ls=\\\"--\\\", c=\\\".3\\\")\\n plt.suptitle('Persistence Diagrams')\\n plt.savefig(plot_file_name)\\n print 'Saved PDs plots in %s'%plot_file_name\\n else:\\n for i in range(1,max_dim+2):\\n plt.subplot(1,max_dim+1,i, aspect='equal')\\n plt.plot(data[data.dimH==i-1].birth.values,data[data.dimH==i-1].death.values,'bo',alpha=.3,label='dim %i'%(i-1))\\n plt.xlim((0,M_max)); plt.ylim((0,M_max))\\n frame = plt.legend(loc=4,frameon=True)\\n frame = frame.get_frame()\\n frame.set_edgecolor('black')\\n plt.xlabel('birth'); plt.ylabel('death')\\n plt.plot([0, M_max], [0, M_max], ls=\\\"--\\\", c=\\\".3\\\")\\n plt.suptitle('Persistence Diagrams')\\n plt.savefig(plot_file_name)\\n print 'Saved PDs plots in %s'%plot_file_name\\n return()\",\n \"def plot_results(param_names, param_options, results, params):\\n\\n\\t# circuit/run_num where run_num is one before the existing one\\n\\tdirectory = params.circuit\\n\\tif not os.path.isdir(directory):\\n\\t\\tos.mkdir(directory)\\n\\truns = immediate_subdir(directory)\\n\\tlatest_run = 0\\n\\tif runs:\\n\\t\\tnatural_sort(runs)\\n\\t\\tlatest_run = get_trailing_num(runs[-1])\\n\\tdirectory = os.path.join(directory, \\\"run\\\" + str(latest_run+1))\\n\\n\\tprint(directory)\\n\\tif not os.path.isdir(directory):\\n\\t\\tos.mkdir(directory)\\n\\n\\twith Chdir(directory):\\n\\n\\t\\texport_results_to_csv(param_names, results, params)\\n\\n\\t\\tx = results.keys()\\n\\t\\ty = []\\n\\t\\tnext_figure = True\\n\\n\\t\\tp = 0\\n\\t\\tplt.figure()\\n\\t\\twhile p < len(param_names):\\n\\t\\t\\tprint(param_names[p])\\n\\n\\t\\t\\tif param_options[p]:\\n\\t\\t\\t\\tnf = True\\n\\t\\t\\t\\tfor option in param_options[p].split():\\n\\t\\t\\t\\t\\t# stopping has veto power (must all be True to pass)\\n\\t\\t\\t\\t\\tnf = nf and plot_options(option)\\n\\t\\t\\t\\tnext_figure = nf\\n\\n\\t\\t\\tif not next_figure:\\n\\t\\t\\t\\t# y becomes list of lists (for use with stackable plots)\\n\\t\\t\\t\\ty.append([result[p] for result in results.values()])\\n\\t\\t\\t\\tp += 1\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\telif not y:\\n\\t\\t\\t\\ty = [result[p] for result in results.values()]\\n\\n\\t\\t\\tlx = x[-1]\\n\\t\\t\\tly = y[-1]\\n\\t\\t\\tplot_method(x,y)\\n\\t\\t\\tplt.xlabel('iteration')\\n\\t\\t\\tplt.xlim(xmin=0)\\n\\t\\t\\t\\n\\t\\t\\tplt.ylabel(param_names[p])\\n\\n\\t\\t\\t# annotate the last value\\n\\t\\t\\tannotate_last(lx,ly)\\n\\n\\t\\t\\tif next_figure:\\n\\t\\t\\t\\tplt.savefig(param_names[p])\\n\\t\\t\\t\\tplt.figure()\\n\\n\\t\\t\\tp += 1\\n\\t\\t# in case the last figure hasn't been shuffled onto file yet\\n\\t\\tif not next_figure:\\n\\t\\t\\tplot_method(x,y)\\n\\t\\t\\tplt.savefig(param_names[-1])\",\n \"def generateTrajectoryPlots(dir_path, traj_list, plot_name='scecliptic', plot_vg=True, plot_sol=True, \\\\\\n plot_density=True, plot_showers=False):\\n\\n\\n\\n ### Plot Sun-centered geocentric ecliptic plots ###\\n\\n lambda_list = []\\n beta_list = []\\n vg_list = []\\n sol_list = []\\n\\n shower_no_list = []\\n shower_obj_dict = {}\\n\\n hypo_count = 0\\n jd_min = np.inf\\n jd_max = 0\\n for traj in traj_list:\\n\\n # Reject all hyperbolic orbits\\n if traj.orbit.e > 1:\\n hypo_count += 1\\n continue\\n\\n # Compute Sun-centered longitude\\n lambda_list.append(traj.orbit.L_g - traj.orbit.la_sun)\\n\\n beta_list.append(traj.orbit.B_g)\\n vg_list.append(traj.orbit.v_g/1000)\\n sol_list.append(np.degrees(traj.orbit.la_sun))\\n\\n # Track first and last observation\\n jd_min = min(jd_min, traj.jdt_ref)\\n jd_max = max(jd_max, traj.jdt_ref)\\n\\n\\n\\n if plot_showers:\\n\\n # Perform shower association and track the list of all showers\\n shower_obj = associateShowerTraj(traj)\\n\\n # If the trajectory was associated, sort it to the appropriate shower\\n if shower_obj is not None:\\n if shower_obj.IAU_no not in shower_no_list:\\n shower_no_list.append(shower_obj.IAU_no)\\n shower_obj_dict[shower_obj.IAU_no] = [shower_obj]\\n else:\\n shower_obj_dict[shower_obj.IAU_no].append(shower_obj)\\n\\n\\n\\n # Compute mean shower radiant for all associated showers\\n shower_obj_list = []\\n if plot_showers and shower_obj_dict:\\n for shower_no in shower_obj_dict:\\n\\n # Check if there are enough shower members for plotting\\n if len(shower_obj_dict[shower_no]) < MIN_SHOWER_MEMBERS:\\n continue\\n\\n la_sun_mean = meanAngle([sh.la_sun for sh in shower_obj_dict[shower_no]])\\n L_g_mean = meanAngle([sh.L_g for sh in shower_obj_dict[shower_no]])\\n B_g_mean = np.mean([sh.B_g for sh in shower_obj_dict[shower_no]])\\n v_g_mean = np.mean([sh.v_g for sh in shower_obj_dict[shower_no]])\\n\\n # Init a new shower object\\n shower_obj_mean = MeteorShower(la_sun_mean, L_g_mean, B_g_mean, v_g_mean, shower_no)\\n\\n shower_obj_list.append(shower_obj_mean)\\n\\n\\n\\n print(\\\"Hyperbolic percentage: {:.2f}%\\\".format(100*hypo_count/len(traj_list)))\\n\\n # Compute the range of solar longitudes\\n sol_min = np.degrees(jd2SolLonSteyaert(jd_min))\\n sol_max = np.degrees(jd2SolLonSteyaert(jd_max))\\n\\n\\n\\n # Plot SCE vs Vg\\n if plot_vg:\\n plotSCE(lambda_list, beta_list, vg_list, (sol_min, sol_max), \\n \\\"Sun-centered geocentric ecliptic coordinates\\\", \\\"$V_g$ (km/s)\\\", dir_path, plot_name + \\\"_vg.png\\\", \\\\\\n shower_obj_list=shower_obj_list, plot_showers=plot_showers)\\n\\n\\n # Plot SCE vs Sol\\n if plot_sol:\\n plotSCE(lambda_list, beta_list, sol_list, (sol_min, sol_max), \\\\\\n \\\"Sun-centered geocentric ecliptic coordinates\\\", \\\"Solar longitude (deg)\\\", dir_path, \\\\\\n plot_name + \\\"_sol.png\\\", shower_obj_list=shower_obj_list, plot_showers=plot_showers)\\n \\n\\n \\n # Plot SCE orbit density\\n if plot_density:\\n plotSCE(lambda_list, beta_list, None, (sol_min, sol_max), \\n \\\"Sun-centered geocentric ecliptic coordinates\\\", \\\"Count\\\", dir_path, plot_name + \\\"_density.png\\\", \\\\\\n density_plot=True, shower_obj_list=shower_obj_list, plot_showers=plot_showers)\",\n \"def plot_directory_surface(path,figsize=(17,11), comp=2, nrow=1, norm=None,\\n cbar='each', cloc='top', outname=None, labels='1', show=True):\\n outdirs = np.sort(os.listdir(path))\\n nplots = len(outdirs)\\n ncol = np.ceil(nplots/nrow).astype(np.int)\\n fig = plt.figure(figsize=figsize)\\n\\n grid = ImageGrid(fig, 111, # similar to subplot(111)\\n nrows_ncols = (nrow, ncol),\\n direction=\\\"row\\\",\\n axes_pad = 0.25,\\n add_all=True,\\n label_mode = labels, #'all', 'L', '1'\\n share_all = True,\\n cbar_location=cloc, #top,right\\n cbar_mode=cbar, #each,single,None\\n cbar_size=0.1,#\\\"7%\\\",\\n cbar_pad=0.0#,\\\"1%\\\",\\n )\\n\\n #NOTE: if cbar='single',cloc='right', a way to automatically normalize by grid[0]\\n #if normalize:\\n # verts,data,tris = load_h5(os.path.join(path,'step01/surface.h5'))\\n # if comp==3: #radial displacements\\n # z = np.hypot(data[:,:,0], data[:,:,1]).flatten()\\n # else:\\n # z = data[:,:,comp].flatten()\\n # norm = Normalize(vmin=np.nanmin(z), vmax=np.nanmax(z))\\n #else:\\n # norm=None\\n\\n for i,outdir in enumerate(outdirs):\\n ax = grid[i]\\n print(outdir)\\n im = plotSurface(os.path.join(path,outdir,'surface.h5'), comp=comp, ax=ax,\\n points=False, tris=False, profile=False, annotate=False, norm=norm,\\n xscale=1e-3, yscale=1e-3)\\n\\n # colorbar settings, not sure what's up with set_xticks...\\n ax.cax.colorbar(im)\\n #cmin = np.nanmin(data)\\n #cmax = np.nanmax(data)\\n #ax.cax.set_xticks([cmin,0,cmax])\\n\\n # label upper left\\n ax.text(0.05,0.95,outdir,\\n weight='bold',\\n ha='left',\\n va='top',\\n bbox=dict(facecolor='white'),\\n transform=ax.transAxes)\\n #ax.set_ylabel(outdir)\\n #ax.tick_params(labelbottom=0,labeltop=0,labelleft=0,labelright=0,\\n # bottom=0,top=0,left=0,right=0)\\n\\n #if cbar=='single':\\n # grid[0].cax.colorbar(im)\\n\\n # Annotate Plot\\n # don't show grid frames without data...\\n Nextra = grid.ngrids - nplots\\n if Nextra > 0:\\n for ax in grid[-Nextra:]:\\n #print(ax)\\n ax.set_visible(False)\\n ax.cax.set_visible(False)\\n fig.suptitle(path, fontsize=14, fontweight='bold')\\n if outname: plt.savefig(outname)\\n if show: plt.show()\",\n \"def plot_pipeline(differences_dir, plots_dir_intonation, num_quantiles = 31):\\n perf_list = ['54363310_1939750539', '540791114_1793842568']\\n difference_path_list = [os.path.join(differences_dir, perf_list[i] + \\\".npy\\\") for i in range(len(perf_list))]\\n comparisons_list = [np.load(path) for _, path in enumerate(difference_path_list)]\\n num_samples = 10000\\n # quantile indices\\n q_indices = (np.linspace(0, 1, num_quantiles)*(num_samples-1)).astype(np.int32)\\n plt.style.use('ggplot')\\n labels = ['perf. A', 'perf. B']\\n colors = ['blue', 'red']\\n linestyles = ['dotted', 'dashed']\\n grid = plt.GridSpec(2, 2)\\n ax1 = plt.subplot(grid[1, 0])\\n ax2 = plt.subplot(grid[1, 1])\\n ax4 = plt.subplot(grid[0, :])\\n ax4.plot(comparisons_list[0], color=colors[0], label=labels[0], linestyle=linestyles[0])\\n ax4.plot(comparisons_list[1], color=colors[1], label=labels[1], linestyle=linestyles[1])\\n ax4.set_title(\\\"Difference between MIDI and pYIN, two performances\\\")\\n ax4.set_ylabel(\\\"Cents\\\")\\n ax4.set_xlabel(\\\"Frames\\\")\\n ax4.axhline(y=200, linestyle=\\\"solid\\\", linewidth=0.7, c=\\\"black\\\", zorder=2, label=\\\"thresh.\\\")\\n ax4.axhline(y=-200, linestyle=\\\"solid\\\", linewidth=0.7, c=\\\"black\\\", zorder=2)\\n ax4.legend(loc=\\\"upper right\\\")\\n ax1.set_title(\\\"10k random sample of distances\\\")\\n ax1.set_ylabel(r\\\"$|$Cents$|$\\\")\\n ax1.set_xlabel(\\\"Frames sorted by distance\\\")\\n ax2.set_title(\\\"Sample quantiles\\\")\\n ax2.set_xlabel(\\\"Quantile indices\\\")\\n # run analysis song by song\\n for i, arr in enumerate(comparisons_list):\\n # random sample so all arrays have the same size\\n samples = np.random.choice(arr, num_samples, replace=True)\\n # sort\\n samples = np.sort(np.abs(samples))\\n # discard the high values (might be due to misalignment, etc...)\\n samples = samples[samples <= 200]\\n samples = np.random.choice(samples, num_samples, replace=True)\\n samples = np.sort(np.abs(samples))\\n ax1.plot(samples, color=colors[i], linestyle=linestyles[i], label=labels[i])\\n # get the quantiles\\n samples = samples[q_indices]\\n ax2.plot(samples, color=colors[i], linestyle=linestyles[i], label=labels[i])\\n ax1.legend()\\n ax2.legend()\\n plt.tight_layout()\\n plt.savefig(os.path.join(plots_dir_intonation, \\\"data processing pipeline.eps\\\"), format=\\\"eps\\\")\\n plt.show()\",\n \"def plot(model, results, filename):\\n\\n # c = model.compartments.get_one(id='c')\\n #\\n # rna_1 = model.species_types.get_one(id='rna_1').species.get_one(compartment=c)\\n # rna_2 = model.species_types.get_one(id='rna_2').species.get_one(compartment=c)\\n # rna_3 = model.species_types.get_one(id='rna_3').species.get_one(compartment=c)\\n #\\n pops = results.get('populations')\\n time = pops.index\\n pop_rna_1 = pops['rna_1[c]']\\n pop_rna_2 = pops['rna_2[c]']\\n pop_rna_3 = pops['rna_3[c]']\\n\\n pop_atp = pops['atp[c]']\\n pop_gtp = pops['gtp[c]']\\n pop_utp = pops['ctp[c]']\\n pop_ctp = pops['utp[c]']\\n\\n pop_amp = pops['amp[c]']\\n pop_gmp = pops['gmp[c]']\\n pop_ump = pops['cmp[c]']\\n pop_cmp = pops['ump[c]']\\n\\n print(pop_rna_1, pop_atp, pop_gtp, pop_utp, pop_ctp)\\n\\n fig1, axes1 = pyplot.subplots(nrows=3, ncols=1)\\n\\n axes1[0].plot(time / 3600, pop_rna_1)\\n axes1[0].plot(time / 3600, pop_rna_2)\\n axes1[0].plot(time / 3600, pop_rna_3)\\n axes1[0].set_xlim((time[0] / 3600, time[-1] / 3600))\\n axes1[0].set_ylim((0., 10.0))\\n axes1[0].legend(loc='upper right')\\n\\n axes1[1].plot(time / 3600, pop_atp)\\n axes1[1].plot(time / 3600, pop_gtp)\\n axes1[1].plot(time / 3600, pop_utp)\\n axes1[1].plot(time / 3600, pop_ctp)\\n axes1[1].set_xlim((time[0] / 3600, time[-1] / 3600))\\n # axes1[1].set_ylim((0., 10.0))\\n axes1[1].legend(loc='upper right')\\n\\n axes1[2].plot(time / 3600, pop_amp)\\n axes1[2].plot(time / 3600, pop_gmp)\\n axes1[2].plot(time / 3600, pop_ump)\\n axes1[2].plot(time / 3600, pop_cmp)\\n axes1[2].set_xlim((time[0] / 3600, time[-1] / 3600))\\n # axes1[2].set_ylim((0., 10.0))\\n axes1[2].legend(loc='upper right')\\n\\n fig1.savefig(filename.format('species'))\\n pyplot.close(fig1)\",\n \"def app_SN_combined_moisture_series(self, dfs, phase_dirs, sizer_val, styler_val):\\n\\n print('Currently plotting plot_SN_combined_moisture_series')\\n\\n for df, direc in zip(dfs, phase_dirs):\\n # this iterates one or multiple times\\n self.plotter.plot_SN_combined_moisture_series(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['01_combined_plots'],\\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\\n styler=self.formatter.styler[styler_val]\\n )\\n self.plotter.plot_SN_combined_moisture_series(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['01_combined_plots'],\\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\\n styler=self.formatter.styler[styler_val],\\n xaxis_type='datetime'\\n )\\n\\n print('Done\\\\n')\",\n \"def plot_visco_profiles(pointsh5, skip=slice(None,None,1), xscale=1e3, yscale=1e-2, tscale=3.1536e7, adjustRadial=False, benchmark=[], title=None):\\n\\tplt.figure()\\n\\n\\tcoords,data,number,times = pu.load_h5_visco(pointsh5)\\n\\n\\t#x = 1e3*np.loadtxt(points,usecols=[0]) # output_points2.txt\\n\\t#y = np.zeros_like(x)\\n\\tx = coords[:,0]\\n\\ty = np.zeros_like(x)\\n\\n\\t# NOTE: plot elastic solution by passing dictionary as showelastic\\n\\t# Plot analytic elastic solution (t=0)\\n\\t#print(benchmark)\\n\\tif len(benchmark)>=1:\\n\\t\\tur = zeros_like(x)\\n\\t\\tuz = np.zeros_like(x)\\n\\t\\tfor b in benchmark:\\n\\t\\t\\turi,uzi = m.calc_mogi_dp(x,y,**params)\\n\\t\\t\\tur += uri\\n\\t\\t\\tuz += uzi\\n\\t\\tplt.plot(x*xscale,uz*yscale,'ko',label='benchmark')\\n\\n\\t# Convert units\\n\\t#ur = np.hypot(data[:,:,0], data[:,:,1]) #assume progiles are along EW profile\\n\\tur = data[:,:,0]\\n\\tuz = data[:,:,2]\\n\\tx = x / xscale\\n\\tur = ur / yscale #cm\\n\\tuz = uz / yscale #cm\\n\\ttimes = times / tscale\\n\\t#times = times / 8.64e4 #days\\n\\t#times = times / 31536000 #years\\n\\n\\t#plots = np.arange(0,times.size,skip)\\n\\t#print(plots.size)\\n\\t#way to cycle through markers if plotting many lines\\n\\t#marker = itertools.cycle(['o','^','s','D']) #plot(marker=marker.next() iterates list)\\n\\t#way to use gradually changing colors from a colormap\\n\\t#color = plt.cm.jet(1.0*i/plots.size)\\n\\tindplots = np.arange(times.size-1)\\n\\tprint(indplots)\\n\\tindplots = indplots[skip]\\n\\tprint(indplots)\\n\\tfor i in indplots:\\n\\t\\tline, = plt.plot(x, uz[i], color=plt.cm.jet(1.0*i/indplots[-1]), label='{:.1f}'.format(times[i]))\\n\\t\\tplt.plot(x, ur[i], ls='dashed', color=line.get_color())\\n\\t#print uz[i]\\n\\t#print uz[i-1]\\n\\n\\tif title:\\n\\t\\tplt.title(title)\\n\\telse:\\n\\t\\tplt.title(pointsh5)\\n\\n\\tplt.axhline(color='k',linestyle='dashed')\\n\\tplt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n\\tplt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\\n\\tplt.show()\\n\\tplt.legend(title='{}'.format(get_unit(tscale)))\\n\\tplt.grid()\",\n \"def multi_plot(self, plottitle, gof_fileroot, indir, outdir,\\n legends, num_stations):\\n # Pick components and labels\\n xtick_loc = XTICK_LOC_0_01\\n xtick_label = XTICK_LABEL_0_01\\n\\n # Initialize data arrays\\n periods = [[] for _ in range(len(gof_fileroot))]\\n bias = [[] for _ in range(len(gof_fileroot))]\\n m90 = [[] for _ in range(len(gof_fileroot))]\\n p90 = [[] for _ in range(len(gof_fileroot))]\\n sigma = [[] for _ in range(len(gof_fileroot))]\\n sigma0 = [[] for _ in range(len(gof_fileroot))]\\n\\n bias_l = [[] for _ in range(len(gof_fileroot))]\\n bias_h = [[] for _ in range(len(gof_fileroot))]\\n conf_l = [[] for _ in range(len(gof_fileroot))]\\n conf_h = [[] for _ in range(len(gof_fileroot))]\\n\\n # Read data from all input files\\n for compnum in xrange(0, len(gof_fileroot)):\\n filenamebase = os.path.join(indir, gof_fileroot[compnum])\\n #print(\\\"Reading component files %s.*\\\" % (filenamebase))\\n periods[compnum], bias[compnum] = self.read_data(\\\"%s.bias\\\" %\\n (filenamebase),\\n 0.01)\\n periods[compnum], m90[compnum] = self.read_data(\\\"%s.m90\\\" %\\n (filenamebase),\\n 0.01)\\n periods[compnum], p90[compnum] = self.read_data(\\\"%s.p90\\\" %\\n (filenamebase),\\n 0.01)\\n periods[compnum], sigma[compnum] = self.read_data(\\\"%s.sigma\\\" %\\n (filenamebase),\\n 0.01)\\n periods[compnum], sigma0[compnum] = self.read_data(\\\"%s.sigma0\\\" %\\n (filenamebase),\\n 0.01)\\n\\n # Compute bias and conf interval lower/upper bounds\\n for i in xrange(0, len(bias[compnum])):\\n bias_l[compnum].append(bias[compnum][i] - sigma0[compnum][i])\\n bias_h[compnum].append(bias[compnum][i] + sigma0[compnum][i])\\n conf_l[compnum].append(m90[compnum][i])\\n conf_h[compnum].append(p90[compnum][i])\\n\\n num_periods = len(periods[0])\\n for comp in periods:\\n if len(comp) != num_periods:\\n print(\\\"Number of data points unequal across components\\\")\\n return\\n\\n # Construct baseline\\n baseline = [0.0 for _ in periods[0]]\\n\\n # Find max, min values\\n min_x = min([min(comp) for comp in periods])\\n max_x = max([max(comp) for comp in periods])\\n min_y = MIN_Y_AXIS\\n max_y = MAX_Y_AXIS\\n\\n # Start plots\\n num_plots = len(gof_fileroot)\\n # Make 1 column of \\\"num_plots\\\" rows\\n fig, axs = pylab.plt.subplots(num_plots, 1)\\n # Set plot dims\\n fig.set_size_inches(6, 10)\\n\\n #subplots_adjust(left=0.125)\\n #subplots_adjust(right=0.9)\\n #subplots_adjust(top=0.85)\\n fig.subplots_adjust(hspace=0.4)\\n fig.subplots_adjust(wspace=0.5)\\n\\n # Add subplots in a list\\n subfigs = []\\n for idx in range(0, num_plots):\\n subfigs.append(axs[idx])\\n\\n # Now walk through each subfig\\n for (subfig, subplot_title, cur_period,\\n cur_bias, cur_bias_h, cur_bias_l,\\n cur_conf_h, cur_conf_l) in zip(subfigs,\\n legends,\\n periods,\\n bias,\\n bias_h,\\n bias_l,\\n conf_h,\\n conf_l):\\n subfig.set_xlim(min_x, max_x)\\n subfig.set_ylim(min_y, max_y)\\n subfig.set_title(\\\"%s\\\" % subplot_title, size=10)\\n subfig.plot(cur_period, cur_bias, color='red', label='_nolegend_')\\n subfig.fill_between(cur_period, cur_bias_h,\\n cur_bias_l, color='cyan',\\n label='_nolegend_')\\n subfig.fill_between(cur_period, cur_conf_h,\\n cur_conf_l, color='yellow',\\n label='_nolegend_')\\n subfig.plot(cur_period, baseline, color='grey',\\n label='_nolegend_')\\n # Only put xlabel on bottom plot\\n if legends.index(subplot_title) == len(gof_fileroot) - 1:\\n subfig.set_xlabel(\\\"Period (sec)\\\", size=8)\\n subfig.set_ylabel(\\\"ln (data/model)\\\", size=8)\\n subfig.set_xscale('log')\\n # Old way to do it\\n # subfig.set_xticks(xtick_loc, xtick_label)\\n subfig.set_xticks(xtick_loc)\\n subfig.set_xticklabels(xtick_label)\\n subfig.tick_params(labelsize=8)\\n subfig.minorticks_on()\\n\\n fig.suptitle('%s\\\\nNumber of stations: %d' % (plottitle, num_stations),\\n size=12)\\n # Figure out output filename\\n outfile = gof_fileroot[0]\\n outfile = outfile[:outfile.rfind(\\\"-\\\")]\\n outfile = os.path.join(outdir, \\\"gof-%s.png\\\" % (outfile))\\n print(\\\"==> Created GoF plot: %s\\\" % (outfile))\\n fig.savefig(outfile, format=\\\"png\\\",\\n transparent=False, dpi=plot_config.dpi)\\n pylab.close()\",\n \"def plot_profiles(snap, profs, dust_species_to_plot, debug=False):\\n print('Plotting profiles...')\\n\\n units = {\\n 'position': 'au',\\n 'gas_velocity_radial_analytical': 'dimensionless',\\n 'dust_velocity_radial_analytical': 'dimensionless',\\n 'velocity_radial_numerical': 'dimensionless',\\n }\\n p = profs['gas'][0]\\n\\n if debug:\\n num_dust = snap.num_dust_species\\n ax = p.plot(x='radius', y=['velocity_pressure', 'velocity_visc'], units=units)\\n y = ['gas_velocity_radial']\\n y += [f'dust_velocity_radial_{idx+1:03}' for idx in range(num_dust)]\\n ax = p.plot(x='radius', y=y, units=units)\\n ax.legend().remove()\\n\\n fig, ax = plt.subplots()\\n\\n # Plot \\\"analytical\\\" radial drift velocity / velocity pressure component\\n p.plot(\\n x='radius',\\n y='gas_velocity_radial_analytical',\\n units=units,\\n color='black',\\n label='',\\n ax=ax,\\n )\\n y = [f'dust_velocity_radial_analytical_{idx+1:03}' for idx in dust_species_to_plot]\\n p.plot(x='radius', y=y, units=units, label='', ax=ax)\\n colors = [line.get_color() for line in ax.lines[1:]]\\n\\n # Plot \\\"numerical\\\" radial drift velocity / velocity pressure component\\n p.plot(\\n x='radius',\\n y='velocity_radial_numerical',\\n units=units,\\n color='black',\\n linestyle='',\\n marker='o',\\n markersize=4,\\n fillstyle='none',\\n label='gas',\\n std='shading',\\n ax=ax,\\n )\\n profs_to_plot = [\\n prof for idx, prof in enumerate(profs['dust']) if idx in dust_species_to_plot\\n ]\\n for species, prof, color in zip(dust_species_to_plot, profs_to_plot, colors):\\n label = f'{snap.properties[\\\"grain_size\\\"][species].to(\\\"cm\\\"):.1f~P}'\\n prof.plot(\\n x='radius',\\n y='velocity_radial_numerical',\\n units=units,\\n color=color,\\n linestyle='',\\n marker='o',\\n markersize=4,\\n fillstyle='none',\\n label=label,\\n std='shading',\\n ax=ax,\\n )\\n\\n ax.set_ylabel(r'$v_R / |v_P|$')\\n ax.grid()\\n\\n textstr = f't = {snap.properties[\\\"time\\\"].to(\\\"years\\\").m:.0f} years'\\n bbox = dict(boxstyle='round', facecolor='white', edgecolor='grey', alpha=0.8)\\n ax.text(\\n 0.97,\\n 0.97,\\n textstr,\\n transform=ax.transAxes,\\n horizontalalignment='right',\\n verticalalignment='top',\\n bbox=bbox,\\n )\\n ax.legend(framealpha=0.8, edgecolor='grey')\\n\\n return ax\",\n \"def main():\\n parser = argparse.ArgumentParser(description=\\n ('Plot and save data from DS9 projections. If only labels are '\\n 'given, it will just plot existing dat files.'\\n 'Other regions/objects in file are ignored.'))\\n\\n parser.add_argument('infile', help='Input DS9 region file (fk5 coords)')\\n parser.add_argument('datroot', help='Stem for output profile data')\\n\\n parser.add_argument('-p', '--pltroot', help='Stem for output plots')\\n parser.add_argument('-f', '--files', help=('Files (.fits) to be processed,'\\n ' one for each energy band'),\\n nargs='*')\\n\\n parser.add_argument('-l', '--labels', help='Band labels for plots/files',\\n nargs='+')\\n parser.add_argument('-v', '--verbose', action='store_true',\\n help='verbose mode')\\n parser.add_argument('-s', '--subplot', action='store_true',\\n help='Generate subplot plots')\\n\\n # Parse arguments\\n args = parser.parse_args()\\n regions_file = args.infile\\n pltroot, datroot = args.pltroot, args.datroot\\n bands, labels = args.files, args.labels # NOTE bands = args.files...\\n verbose, subplot = args.verbose, args.subplot\\n\\n # Check arguments for sanity\\n # If -p is supplied, output plots\\n # If -b is supplied, output data\\n if bands is None:\\n if not pltroot:\\n parser.error('Nothing to be done! Need bands or pltroot.')\\n else:\\n print 'No bands supplied, generating plots only'\\n else:\\n if len(bands) != len(labels):\\n raise ValueError(('Non-zero number of bands '\\n 'does not match number of labels!'))\\n elif not pltroot:\\n print 'No pltroot supplied, generating data only'\\n\\n # Parse projections\\n rspecs = get_projection_params(regions_file)\\n if verbose:\\n print 'Projections parsed from region file'\\n\\n # Generate data files, if desired\\n if bands is not None:\\n regparse.check_dir(datroot, verbose) # only create if saving data\\n generate_dat_files(rspecs, datroot, bands, labels)\\n\\n # Generate plots, if desired\\n if pltroot:\\n regparse.check_dir(pltroot, verbose)\\n generate_plots(rspecs, datroot, pltroot, labels, verbose, subplot)\\n\\n if verbose:\\n print 'Done!'\",\n \"def plot_physical_profiles(self, fig=2):\\n # Select the physical parameters\\n phys_parms = ['temperature', 'salinity', 'theta', 'N']\\n \\n # Plot these parameters\\n self.plot_profiles(phys_parms, fig)\",\n \"def compare_hist_2(results_dir_root):\\n plot_style = [\\n {'color': 'k', 'marker': 'none', 'lw': 1.5},\\n {'color': 'r', 'marker': 'none', 'lw': 1.5}\\n ]\\n unwrap_levels = ['r08']\\n\\n fig, axes = plt.subplots(figsize=(8, 10), nrows=5, ncols=2, sharex=True,\\n sharey=False)\\n fig.subplots_adjust(left=0.1, bottom=0.08, right=0.98, top=0.98,\\n hspace=0.05, wspace=0.15)\\n\\n print(axes.shape)\\n\\n results_dirs = [results_dir_root + '_0h', results_dir_root + '_4h']\\n\\n fig.text(0.5, 0.02, r'Baseline length (m)', ha='center')\\n fig.text(0.01, 0.5, r'Baseline count per bin', va='center',\\n rotation='vertical')\\n\\n # Loop over models\\n for i in range(7, 8):\\n models = ['ska1_v5', 'model%02i' % (i + 1)]\\n # Loop over 0h or 4h\\n for j in range(1):\\n idx = 0\\n ax = axes[i, j]\\n for model in models:\\n # Load saved psf results.\\n filename = join(results_dirs[j], '%s_uv_hist.p' % model)\\n print('-- Loading: %s' % filename)\\n hist = pickle.load(open(filename, 'rb'))\\n # Plot comparison of PSF profiles.\\n for tel in hist:\\n if tel == 'ska1_v5' or any(s in tel for s in unwrap_levels):\\n style = plot_style[idx % len(plot_style)]\\n x = hist[tel]['log']['hist_x']\\n y = hist[tel]['log']['hist_n']\\n cut_idx = np.argmax(x > 5e3)\\n x = x[:cut_idx]\\n y = y[:cut_idx]\\n ax.plot(x, y, color=style['color'],\\n linestyle='-',\\n label=tel + ' max')\\n idx += 1\\n length_str = 'snapshot' if j == 0 else '4 hours'\\n ax.text(0.02, 0.95, ('SKA1 v5 vs. Model %i\\\\n' % (i + 1)) + length_str,\\n weight='bold',\\n ha='left', va='top', transform=ax.transAxes,\\n fontsize='small')\\n # ax.legend(loc='best', fontsize='small', ncol=1)\\n # ax.set_xlabel('Baseline length (m)')\\n # ax.set_ylabel('Number of baselines per bin')\\n ax.set_xlim(10, 1e4)\\n if j == 1:\\n ax.set_ylim(1.5e3)\\n if j == 0:\\n ax.set_ylim(5)\\n ax.set_yscale('log')\\n ax.set_xscale('log')\\n # if i == 4:\\n # ax.set_xlabel('Baseline length (m)')\\n # ax.set_ylabel('Baseline count per bin')\\n ax.grid()\\n plt.show(True)\\n fig.savefig(join('compare_hist_%s.png' %\\n ('_'.join(unwrap_levels))))\\n plt.close(fig)\",\n \"def plot_folder(path):\\r\\n plt.figure(figsize=(20, 10))\\r\\n for filename in glob.glob(path + '/*.pspec'):\\r\\n x, y= np.loadtxt(fname=filename, delimiter='\\\\t',dtype=int, usecols = (1,2),\\r\\n skiprows=100, unpack = True)\\r\\n plt.plot(x, y)\\r\\n return plt.show()\",\n \"def make_plots(self):\\n n_rounds = self.run.n_rounds\\n\\n log.info('Making %d frames', n_rounds)\\n args = [self._get_for_parallel(i) for i in range(n_rounds)]\\n self.lbv.map(_plot_helper, args)\",\n \"def plot_skyplot(\\n self,\\n figure_name: str=\\\"plot_skyplot_{system}.{FIGURE_FORMAT}\\\",\\n ) -> List[pathlib.PosixPath]:\\n figure_paths = list()\\n \\n # Convert azimuth to range 0-360 degree\\n azimuth = self.dset.site_pos.azimuth\\n idx = azimuth < 0\\n azimuth[idx] = 2 * np.pi + azimuth[idx]\\n \\n # Convert zenith distance from radian to degree\\n zenith_distance = np.rad2deg(self.dset.site_pos.zenith_distance)\\n \\n # Generate x- and y-axis data per system\\n for sys in sorted(self.dset.unique(\\\"system\\\")):\\n x_arrays = []\\n y_arrays = []\\n labels = []\\n \\n figure_path = self.figure_dir / figure_name.replace(\\\"{system}\\\", sys).replace(\\\"{FIGURE_FORMAT}\\\", FIGURE_FORMAT)\\n figure_paths.append(figure_path)\\n \\n for sat in sorted(self.dset.unique(\\\"satellite\\\")):\\n if not sat.startswith(sys):\\n continue\\n idx = self.dset.filter(satellite= sat)\\n x_arrays.append(azimuth[idx])\\n y_arrays.append(zenith_distance[idx])\\n labels.append(sat)\\n \\n # Plot with polar projection\\n # TODO: y-axis labels are overwritten after second array plot. Why? What to do?\\n plot(\\n x_arrays=x_arrays,\\n y_arrays=y_arrays,\\n xlabel=\\\"\\\",\\n ylabel=\\\"\\\",\\n y_unit=\\\"\\\",\\n labels=labels,\\n figure_path=figure_path,\\n opt_args={\\n \\\"colormap\\\": \\\"hsv\\\",\\n \\\"figsize\\\": (7, 7.5),\\n \\\"legend\\\": True,\\n \\\"legend_ncol\\\": 6,\\n \\\"legend_location\\\": \\\"bottom\\\",\\n \\\"plot_to\\\": \\\"file\\\",\\n \\\"plot_type\\\": \\\"scatter\\\",\\n \\\"projection\\\": \\\"polar\\\",\\n \\\"title\\\": f\\\"Skyplot for {enums.gnss_id_to_name[sys]}\\\\n Azimuth [deg] / Elevation[deg]\\\",\\n \\\"xlim\\\": [0, 2 * np.pi],\\n \\\"ylim\\\": [0, 90],\\n \\\"yticks\\\": (range(0, 90, 30)), # sets 3 concentric circles\\n \\\"yticklabels\\\": (map(str, range(90, 0, -30))), # reverse labels from zenith distance to elevation\\n },\\n )\\n \\n return figure_paths\",\n \"def main(self, args):\\n for plot in args.plots:\\n if plot == 'no_plot':\\n break\\n print \\\"plotting\\\", plot\\n\\n fig = self.plot_figure(plot)\\n\\n fformat = '{plot}_{index}.{ext}'\\n fname = fformat.format(plot=plot, index=self.index, ext='png')\\n fpath = os.path.join(plot_dir, fname)\\n fig.savefig(fpath)\\n\\n if args.distributions == 'all':\\n distributions = ['Uf', 'Wf', 'uf_abs',\\n 'vorticity', 'vertical_shear']\\n else:\\n distributions = args.distributions\\n for dist in distributions:\\n range = self.properties[dist]['range']\\n name = self.properties[dist]['name']\\n print \\\"plotting distribution\\\", dist, name\\n fig = self.plot_distribution(getattr(self, dist), range, name)\\n\\n fformat = 'distribution_{q}_{index}.{ext}'\\n fname = fformat.format(q=dist, index=self.index, ext='png')\\n fpath = os.path.join(plot_dir, fname)\\n fig.savefig(fpath)\\n\\n if args.funcs:\\n for func in args.funcs:\\n print \\\"multiprocessing\\\", func\\n f = getattr(self, 'plot_' + func)\\n f()\",\n \"def plotSpectrums2D(path_fsrcnn, path_liif, path_msrn, path_esrgan, path_bicubic, out_path):\\n radial_FSRCNN = []\\n radial_LIIF = []\\n radial_MSRN = []\\n radial_ESRGAN = []\\n radial_BICUBIC = []\\n\\n for FSRCNN_path, LIIF_path, MSRN_path, ESRGAN_path, bicubic_path in zip(sorted(glob.glob(path_fsrcnn)), sorted(glob.glob(path_liif)), sorted(glob.glob(path_msrn)), sorted(glob.glob(path_esrgan)), sorted(glob.glob(path_bicubic))):\\n print(FSRCNN_path)\\n radialProfile_FSRCNN = spectrum2D(FSRCNN_path)\\n print(len(radialProfile_FSRCNN))\\n radial_FSRCNN.append(radialProfile_FSRCNN)\\n print(LIIF_path)\\n radialProfile_LIIF = spectrum2D(LIIF_path)\\n radial_LIIF.append(radialProfile_LIIF)\\n print(MSRN_path)\\n radialProfile_msrn = spectrum2D(MSRN_path)\\n radial_MSRN.append(radialProfile_msrn)\\n print(ESRGAN_path)\\n radialProfile_esrgan = spectrum2D(ESRGAN_path)\\n radial_ESRGAN.append(radialProfile_esrgan)\\n print(bicubic_path)\\n radialProfile_bicubic = spectrum2D(bicubic_path)\\n radial_BICUBIC.append(radialProfile_bicubic)\\n\\n image_name = FSRCNN_path.split('/')[-1]\\n if not os.path.exists(out_path):\\n os.makedirs(out_path)\\n\\n plt.figure()\\n plt.plot(radialProfile_FSRCNN, label='FSRCNN')\\n plt.plot(radialProfile_LIIF, label='LIIF')\\n plt.plot(radialProfile_msrn, label='MSRN')\\n plt.plot(radialProfile_esrgan, label='ESRGAN')\\n plt.plot(radialProfile_bicubic, label='BICUBIC')\\n plt.legend()\\n plt.title(image_name)\\n plt.yscale('log')\\n plt.savefig(out_path + image_name)\\n\\n mean_FSRCNN = tolerant_mean(radial_FSRCNN)\\n mean_LIIF = tolerant_mean(radial_LIIF)\\n mean_MSRN = tolerant_mean(radial_MSRN)\\n mean_ESRGAN = tolerant_mean(radial_ESRGAN)\\n mean_BICUBIC = tolerant_mean(radial_BICUBIC)\\n plt.figure()\\n plt.plot(mean_FSRCNN, label='FSRCNN')\\n plt.plot(mean_LIIF, label='LIIF')\\n plt.plot(mean_MSRN, label='MSRN')\\n plt.plot(mean_ESRGAN, label='ESRGAN')\\n plt.plot(mean_BICUBIC, label='BICUBIC')\\n plt.legend()\\n plt.title('MEAN')\\n plt.yscale('log')\\n plt.savefig(out_path + 'mean')\\n #return radialProfile_FSRCNN.shape, radialProfile_LIIF.shape, radialProfile_msrn.shape\",\n \"def plot_profiles(self, parameters, fig=1):\\n # Make sure the parameters are a list\\n if isinstance(parameters, str) or isinstance(parameters, unicode):\\n parameters = [parameters]\\n \\n # Decide how many subplots to create\\n nrows = int(len(parameters) / 3)\\n if len(parameters) % 3 > 0:\\n nrows += 1\\n \\n # Initialize a figure for plotting\\n width = 8\\n height = 4 * nrows\\n plt.figure(fig, figsize=(width, height))\\n plt.clf()\\n \\n # Plot each parameter\\n for parm in parameters:\\n ax = plt.subplot(nrows, 3, parameters.index(parm)+1)\\n self.plot_parameter(parm)\\n \\n plt.tight_layout()\\n \\n plt.show()\",\n \"def PlotProfile():\\n (metadata, data) = Parse('/tmp/sdcard-scalability.txt')\\n gp = Gnuplot.Gnuplot(persist=1)\\n gp('set data style impulses')\\n gp('set xtics 1')\\n gp('set pointsize 2')\\n gp.clear()\\n gp.xlabel('writer process')\\n gp.ylabel('duration in second')\\n gp.title(metadata.AsTitle())\\n\\n dataset = data[0]\\n x = numpy.array(dataset.time, dtype='int_')\\n d = Gnuplot.Data(x, dataset.data,\\n title=dataset.name,\\n with_='linespoints')\\n gp.replot(d)\\n gp.hardcopy('/tmp/%s-%s-%f.png' %\\n (metadata.name, metadata.kernel, metadata.duration),\\n terminal='png')\",\n \"def stm_profile_plot(flat_file, points, scan_dir=0, cmap=None, vmin=None, vmax=None, xy_ticks=4, z_ticks=4):\\n nm = 10 ** -9 # Define the nanometer to meter conversion.\\n\\n fig, ax = plt.subplots() # Create an instance of a pyplot figure and axis.\\n\\n # Set the minimum of the scan data to zero.\\n figure_data = (flat_file[scan_dir].data - np.amin(flat_file[scan_dir].data)) / nm\\n\\n if cmap is None: # If no color scheme is given use hot as default.\\n cmap = 'hot'\\n\\n if vmin is None: # If no z-axis minimum is given use minimum of the image data.\\n vmin = np.amin(figure_data)\\n if vmax is None: # If no z-axis maxmimum is given use 125% of the maximum in the image data.\\n vmax = 1.25 * np.amax(figure_data)\\n\\n # Add image plot to the axis and define it so that the color map can be generated.\\n cax = ax.imshow(figure_data, origin='lower', cmap=cmap, vmin=vmin, vmax=vmax)\\n\\n # Convert nanometer values into pixel numbers.\\n for point in range(len(points)):\\n points[point][0] = nm2pnt(points[point][0], flat_file, axis='x')\\n points[point][1] = nm2pnt(points[point][1], flat_file, axis='y')\\n\\n # Plot the line profile points on the axis.\\n ax.plot(points[:, 0], points[:, 1], 'bo-')\\n\\n xy_units = flat_file[scan_dir].info['unitxy'] # Get xy units.\\n\\n x_res = flat_file[scan_dir].info['xres'] # Get number of x-axis pixels.\\n y_res = flat_file[scan_dir].info['yres'] # Get number of y-axis pixels.\\n\\n x_max = flat_file[scan_dir].info['xreal'] # Get x-axis image size.\\n y_max = flat_file[scan_dir].info['yreal'] # get y-axis image size.\\n\\n # Set the x-axis ticks from number given.\\n ax.set_xticks([x for x in np.arange(0, x_res + 1, x_res / xy_ticks)])\\n # Set the x-axis tick labels from image size.\\n ax.set_xticklabels([str(np.round(x, 1)) for x in np.arange(0, x_max + 1, x_max / xy_ticks)])\\n\\n # Set the y-axis ticks from number given\\n ax.set_yticks([y for y in np.arange(0, y_res + 1, y_res / xy_ticks)])\\n # Set the y-axis tick labels from image size.\\n ax.set_yticklabels([str(np.round(y, 1)) for y in np.arange(0, y_max + 1, y_max / xy_ticks)])\\n\\n # Set the x- and y-axis labels.\\n ax.set_xlabel(xy_units, size=16, weight='bold')\\n ax.set_ylabel(xy_units, size=16, weight='bold')\\n\\n # Define the limits of the plot.\\n ax.set_xlim([0, x_res])\\n ax.set_ylim([0, y_res])\\n\\n # St the plot title with the image setpoint parameters.\\n ax.set_title('Set-Points: {voltage} V, {current} pA'.format(voltage=flat_file[scan_dir].info['vgap'],\\n current=np.round(\\n flat_file[scan_dir].info['current']*10**12)))\\n\\n # Define list containing the z-axis ticks from number given.\\n cbar_ticks = [z for z in np.arange(vmin, vmax * 1.01, vmax / z_ticks)]\\n # Define the z-axis tick labels.\\n cbar_ticklabels = [str(np.round(z, 1)) for z in np.arange(vmin, vmax + 1, vmax / z_ticks)]\\n # Create color bar.\\n cbar = fig.colorbar(cax, ticks=cbar_ticks)\\n # Set the color bar tick labels.\\n cbar.ax.set_yticklabels(cbar_ticklabels, size=16)\\n # Set color bar label.\\n cbar.set_label('Height [' + xy_units + ']', size=18, weight='bold')\\n\\n plt.show()\",\n \"def generate_plots(self, env):\\n print(' Generating diagnostic plots for : {0}'.format(self.__class__.__name__))\\n\\n # chdir into the working directory\\n os.chdir(env['WORKDIR'])\\n\\n for nclPlotFile in self._ncl:\\n # copy the NCL command to the workdir\\n shutil.copy2('{0}/{1}'.format(env['NCLPATH'],nclPlotFile), '{0}/{1}'.format(env['WORKDIR'], nclPlotFile))\\n\\n nclFile = '{0}/{1}'.format(env['WORKDIR'],nclPlotFile)\\n rc, err_msg = cesmEnvLib.checkFile(nclFile, 'read')\\n if rc:\\n try:\\n print(' calling NCL plot routine {0}'.format(nclPlotFile))\\n subprocess.check_call(['ncl', '{0}'.format(nclFile)], env=env)\\n except subprocess.CalledProcessError as e:\\n print('WARNING: {0} call to {1} failed with error:'.format(self.name(), nclFile))\\n print(' {0}'.format(e.cmd))\\n print(' rc = {0}'.format(e.returncode))\\n else:\\n print('{0}... continuing with additional plots.'.format(err_msg))\",\n \"def app_SN_combined_temperature_series(self, dfs, phase_dirs, sizer_val, styler_val): # need to implement other options\\n\\n print('Currently plotting plot_SN_combined_temperature_series')\\n\\n for df, direc in zip(dfs, phase_dirs):\\n # this iterates one or multiple times\\n self.plotter.plot_SN_combined_temperature_series(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['01_combined_plots'],\\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\\n styler=self.formatter.styler[styler_val]\\n )\\n self.plotter.plot_SN_combined_temperature_series(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['01_combined_plots'],\\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\\n styler=self.formatter.styler[styler_val],\\n xaxis_type='datetime'\\n )\\n\\n print('Done\\\\n')\",\n \"def make_plots(srcdir, outdir, include_subdir=False, level=3):\\n srcfiles = get_ordered_srcfiles(srcdir, include_subdir)\\n nodelist = get_f_nodelist(srcfiles)\\n for n in nodelist:\\n print(os.path.basename(n.name))\\n for m in n.dependencies:\\n print(' ' + os.path.basename(m.name))\\n print('')\\n\\n if not os.path.isdir(outdir):\\n raise Exception('output directory does not exist')\\n\\n for n in nodelist:\\n filename = os.path.join(outdir, os.path.basename(n.name) + '.png')\\n print('Creating ' + filename)\\n graph = pydot.Dot(graph_type='digraph')\\n node_dict = {}\\n ilev = 0\\n add_pydot_nodes(graph, node_dict, n, ilev, level)\\n edge_set = set()\\n ilev = 1\\n add_pydot_edges(graph, node_dict, edge_set, n, ilev, level)\\n graph.write_png(filename)\\n\\n return\",\n \"def plots():\\n out = interactive_output(generate_plots, {'gsize':gridSlider, 'ra':RABox, 'ra':RASlider, 'dec':DECBox, 'dec':DECSlider, 'ang':radBox, 'ang':radSlider, 'style':hexDrop})\\n return display(widgrid, out)\",\n \"def plotPaperFigures(folder='results/'):\\n #model Example\\n _AiryDisc(amplitude=1e6, center_x=10.0, center_y=10.0, radius=0.5, focus=0.4, size=21)\\n _CCDkernel(CCDx=10, CCDy=10, width_x=0.35, width_y=0.4, size=21)\\n plotModelExample()\\n\\n #simulation figures\\n theta1 = (2.e5, 9.9, 10.03, 0.41, 0.51, 10., 10., 0.291, 0.335)\\n try:\\n _plotDifferenceIndividualVsJoined(individuals='simulatedResults/RunI*.pkl',\\n joined='results/simulated800nmJoint.pkl',\\n title='Simulated Data: CCD PSF Recovery', truthx=theta1[7], truthy=theta1[8],\\n requirementE=None, requirementFWHM=None, requirementR2=None)\\n _plotModelResiduals(id='RunI1', folder='simulatedResults/', out='Residual1.pdf', individual=True)\\n except:\\n print 'No simulated data to plot...'\\n\\n #real data\\n _plotDifferenceIndividualVsJoined(individuals=folder+'I800nm?.pkl', joined=folder+'J800nm.pkl', title='800nm',\\n FWHMlims=(7.3, 11.8))\\n\\n _plotModelResiduals(id='I800nm2', folder=folder, out='ResidualData.pdf', individual=True)\\n _plotModelResiduals(id='RunI2', folder='simulatedResults/', out='Residual2.pdf', individual=True)\\n\\n #_plotModelResiduals(id='G600nm0', folder=folder, out='ResidualG600.pdf', individual=True)\\n #_plotModelResiduals(id='G700nm0', folder=folder, out='ResidualG700.pdf', individual=True)\\n _plotModelResiduals(id='G800nm0', folder=folder, out='ResidualG800.pdf', individual=True)\\n #_plotModelResiduals(id='G890nm0', folder=folder, out='ResidualG890.pdf', individual=True)\\n\\n #wavelength dependency\\n plotLambdaDependency()\\n\\n #brighter fatter\\n plotBrighterFatter()\",\n \"def generate_plots(rspecs, datroot, pltroot, labels,\\n verbose=False, subplot=False):\\n\\n if subplot:\\n n = len(labels)\\n plt.figure(figsize=(4*n,4))\\n else:\\n plt.figure(figsize=(6,4))\\n\\n if verbose:\\n print 'Generating {} plots...'.format(len(rspecs))\\n print 'First plot will hang a little longer'\\n\\n # Make a plot for each region\\n for i in xrange(len(rspecs)):\\n # Plot line/points for each label\\n for flab, j in zip(labels, xrange(n)):\\n dat_fname = '{0}_{1:02d}_band_{2}.dat'.format(datroot, i+1, flab)\\n a = np.loadtxt(dat_fname)\\n if subplot:\\n plt.subplot(1, n, j+1) # j indexes labels\\n plt.plot(a[:,0], a[:,1], '-o') # Use default color cycle\\n plt.title('Region {:g}, band {}'.format(i+1, flab))\\n fplot('Radial dist. (?)', 'Intensity? (?)')\\n else:\\n plt.plot(a[:,0], a[:,1], '-o') # Use default color cycle\\n # Format overall plot\\n if not subplot:\\n fplot('Radial dist. (?)', 'Intensity? (?)')\\n plt.title('Region %g' % (i+1))\\n plt.legend(labels, loc='best')\\n plt.tight_layout()\\n plt.savefig('{0}_{1:02d}.png'.format(pltroot, i+1), dpi=150)\\n plt.clf()\\n if verbose:\\n print 'Saved: {0}_{1:02d}.png'.format(pltroot, i+1)\",\n \"def plot_results(path: Path, output_dir: Path, skip: int = 100) -> Path:\\n with xr.open_dataset(path) as ds:\\n lons = ds.lon.values\\n lats = ds.lat.values\\n status = ds.status.values\\n stranded_flag = get_stranded_flag_from_status(ds)\\n\\n _ = plt.figure(figsize=(10, 10))\\n ax = plt.axes(projection=ccrs.PlateCarree(central_longitude=180))\\n ax.set_extent(\\n [-210, -140, 45, 75],\\n crs=ccrs.PlateCarree()\\n )\\n nparticles = len(lons)\\n if nparticles > skip:\\n iter_particles = np.arange(0, nparticles, skip)\\n else:\\n iter_particles = np.arange(0, nparticles)\\n\\n for particle in iter_particles:\\n # Create mask for stranded or not moving particles\\n mask = np.logical_and(\\n status[particle, :] <= 1,\\n status[particle, :] >= 0\\n )\\n # Cannot save figure if you plot something that is completely masked\\n # Cartopy will raise an error on save\\n if not np.any(mask):\\n continue\\n ax.plot(\\n lons[particle, mask],\\n lats[particle, mask],\\n color='g',\\n transform=ccrs.PlateCarree()\\n )\\n\\n # Starting position\\n ax.scatter(\\n ds.lon[particle, 0],\\n ds.lat[particle, 0],\\n c='b',\\n transform=ccrs.PlateCarree()\\n )\\n stranded_ix = ds.status[particle, :] == stranded_flag\\n\\n # Stranded particles\\n if np.any(stranded_ix):\\n ax.scatter(\\n ds.lon[particle, stranded_ix],\\n ds.lat[particle, stranded_ix],\\n c='r',\\n transform=ccrs.PlateCarree()\\n )\\n\\n ax.coastlines()\\n ax.add_feature(cartopy.feature.LAND.with_scale('110m'))\\n ax.gridlines(draw_labels=True)\\n\\n fname = path.name.replace('.nc', '.png')\\n outpath = output_dir / fname\\n\\n plt.tight_layout()\\n plt.savefig(outpath)\\n plt.close()\\n\\n return outpath\",\n \"def plot_path_statistics( self, path_file=\\\"tse_ensemble.json\\\" ):\\n from matplotlib import pyplot as plt\\n with open(path_file,'r') as infile:\\n data = json.load(infile)\\n try:\\n paths = data[\\\"transition_paths\\\"]\\n except KeyError:\\n paths = [data]\\n total_product_indicator = np.zeros(len(paths[0][\\\"symbols\\\"]))\\n total_reactant_indicator = np.zeros(len(paths[0][\\\"symbols\\\"]))\\n self.nuc_mc.min_size_product = paths[0][\\\"min_size_product\\\"]\\n self.nuc_mc.max_size_reactant = paths[0][\\\"max_size_reactant\\\"]\\n for path in paths:\\n product_indicator = []\\n reactant_indicator = []\\n reactant_indicator, product_indicator = self.get_basin_indicators(path)\\n\\n total_product_indicator += np.cumsum(product_indicator)/float( len(product_indicator) )\\n total_reactant_indicator += np.cumsum(reactant_indicator)/float( len(reactant_indicator) )\\n\\n total_reactant_indicator /= float( len(paths) )\\n total_product_indicator /= float( len(paths) )\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(1,1,1)\\n ax.plot( total_product_indicator, label=\\\"Product\\\" )\\n ax.plot( total_reactant_indicator, label=\\\"Reactant\\\" )\\n ax.set_xlabel( \\\"MC sweeps\\\" )\\n ax.set_ylabel( \\\"Indicator\\\" )\\n ax.spines[\\\"right\\\"].set_visible(False)\\n ax.spines[\\\"top\\\"].set_visible(False)\\n ax.legend( frameon=False, loc=\\\"best\\\" )\\n return fig\",\n \"def main():\\n import argparse\\n import os\\n parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)\\n parser.add_argument('--dirs', help='List of log directories', nargs='*', default=['./log'])\\n parser.add_argument('--num_timesteps', type=int, default=int(10e6))\\n parser.add_argument('--xaxis', help='Varible on X-axis', default=X_TIMESTEPS)\\n parser.add_argument('--task_name', help='Title of plot', default='Breakout')\\n args = parser.parse_args()\\n args.dirs = [os.path.abspath(folder) for folder in args.dirs]\\n plot_results(args.dirs, args.num_timesteps, args.xaxis, args.task_name)\\n plt.show()\",\n \"def save_plots(self):\\n pdir = os.path.splitext(self.filename)[0] + '_plots'\\n if not os.path.exists(pdir):\\n os.mkdir(pdir)\\n\\n for ii in range(self.uv.n_ant):\\n fig, ax = self.plot_single_baseline_dual_pol(ii+1, ii+1)\\n print \\\"Saving ant %i\\\"%ii\\n plt.savefig(os.path.join(pdir, 'ant-%i.png'%ii))\\n plt.clf()\",\n \"def app_SN_combined_temperature_gradient(self, dfs, phase_dirs, sizer_val, styler_val): # need to implement other options\\n\\n print('Currently plotting plot_SN_combined_temperature_gradient')\\n\\n for df, direc in zip(dfs, phase_dirs):\\n # this iterates one or multiple times\\n self.plotter.plot_SN_combined_temperature_gradient(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['01_combined_plots'],\\n sizer=self.formatter.sizer[sizer_val]['3x1_partial_width'],\\n styler=self.formatter.styler[styler_val],\\n xscale=self.xscale_var.get()\\n )\\n\\n print('Done\\\\n')\",\n \"def Diagnostic_plot3(self):\\n\\n floc = glob.glob('/home/mxs191/Desktop/MathewSchofield/TRG/DetTest/DetTest1_results/Info2Save/*.csv')\\n fig = plt.figure()\\n plt.rc('font', size=18)\\n #fig, ax = generalPlot(xaxis=r'$\\\\nu / \\\\mu$Hz', yaxis=r'$P_{\\\\rm det}$')\\n gs = gridspec.GridSpec(1, 2, width_ratios=(4,1))\\n ax = fig.add_subplot(gs[0])\\n\\n for idx, i in enumerate(floc):\\n\\n d = pd.read_csv(i)\\n\\n if idx == 0:\\n fullpdet = d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']]\\n else:\\n fullpdet = pd.concat([ fullpdet,\\\\\\n d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']] ])\\n\\n plt.scatter(d['f0'], d['Pdet_Kepler'], color='b',\\\\\\n label=r\\\"$\\\\rm Kepler - 4\\\\ yrs$\\\" if idx == 0 else '')\\n plt.scatter(d['f0'], d['Pdet_TESS365'], color='orange',\\\\\\n label=r'$\\\\rm TESS - 1\\\\ yr$' if idx == 0 else '')\\n plt.scatter(d['f0'], d['Pdet_TESS27'], color='g',\\\\\\n label=r'$\\\\rm TESS - 27\\\\ days$' if idx == 0 else '')\\n\\n plt.axhline(fullpdet['Pdet_Kepler'].median(), color='b')\\n plt.axhline(fullpdet['Pdet_TESS365'].median(), color='orange')\\n plt.axhline(fullpdet['Pdet_TESS27'].median(), color='g')\\n ax.legend(loc='lower right')\\n plt.ylim([0,1])\\n ax.set_ylabel(r'$P_{\\\\rm det}$')\\n ax.set_xlabel(r'$\\\\nu / \\\\mu \\\\rm Hz$')\\n\\n bx = fig.add_subplot(gs[1])\\n import seaborn as sns\\n bw = 0.4\\n sns.kdeplot(fullpdet['Pdet_Kepler'].values, shade=True, vertical=True, \\\\\\n ax=bx, color='b', bw=bw)\\n sns.kdeplot(fullpdet['Pdet_TESS365'].values, shade=True, vertical=True, \\\\\\n ax=bx, color='orange', bw=bw)\\n sns.kdeplot(fullpdet['Pdet_TESS27'].values, shade=True, vertical=True, \\\\\\n ax=bx, color='g', bw=bw)\\n bx.set_ylim([0.0,1.0])\\n bx.set_xticks([])\\n bx.set_yticks([])\\n bx.set_xlabel(r'$\\\\rm Density$')\\n plt.tight_layout()\\n\\n plt.show()\\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\\\\n 'DetTest_Diagnostic_plot3.pdf')\\n sys.exit()\",\n \"def plotPerLumiSection(options):\\n name = options['name'] + '_perLS'\\n f = openRootFileR(name)\\n histname = plotName(options['title']+'_perLS', timestamp=False)\\n filename = plotName(options['title']+'_perLS', timestamp=True)\\n filepath = plotPath(options['title']+'_perLS', timestamp=True)\\n print '<<< Save plot:', filepath\\n hist = f.Get(histname)\\n canvas = TCanvas()\\n canvas.SetLogy(options['logy'])\\n gStyle.SetOptStat(options['optstat'])\\n hist.Draw()\\n gPad.Update()\\n hist.GetXaxis().SetTitle('Lumisection')\\n hist.GetYaxis().SetTitle(options['ytitle'])\\n hist.GetYaxis().SetTitleOffset(1.2)\\n for axis in [hist.GetXaxis(), hist.GetYaxis()]:\\n axis.SetTitleFont(133)\\n axis.SetTitleSize(16)\\n axis.SetLabelFont(133)\\n axis.SetLabelSize(12)\\n axis.CenterTitle()\\n drawSignature(filename)\\n gPad.Modified()\\n gPad.Update()\\n #canvas.Print(filepath)\\n #canvas.Close()\\n #closeRootFile(f, name)\\n return [canvas, hist, f]\",\n \"def plot_results(infer_images, inference_predicted_class, inference_predictions, class_names=['plants', 'water']):\\n plt.style.use(['dark_background', 'bmh'])\\n rc('figure', figsize=(8, 8), max_open_warning=False)\\n rc('axes', facecolor='none')\\n plt.figure(figsize=(15, 15))\\n\\n for i, (infer_img, _) in enumerate(infer_images.take(10)):\\n ax = plt.subplot(5, 2, i + 1)\\n plt.imshow(infer_img.numpy()/255)\\n\\n # Find the predicted class from predictions\\n m = \\\"Predicted: {}, {:.2f}%\\\".format(\\n class_names[inference_predicted_class[i]], inference_predictions[i]*100)\\n plt.title(m)\\n plt.axis(\\\"off\\\")\\n plt.show()\",\n \"def plot_visual_abstract():\\n # Which generations to plot\\n GENERATIONS = [100, 230, 350]\\n\\n # LunarLander CMA-ES\\n experiment_path = glob(\\\"experiments/wann_LunarLander-v2_CMAES*\\\")\\n assert len(experiment_path) == 1, \\\"There should be only one CMA-ES experiment with LunarLander-v2\\\"\\n experiment_path = experiment_path[0]\\n\\n pivector_paths = glob(os.path.join(experiment_path, \\\"pivectors\\\", \\\"*\\\"))\\n\\n tsnes = []\\n rewards = []\\n for generation in GENERATIONS:\\n # Find pivector files for specific generation, load them and store points\\n generation_paths = [path for path in pivector_paths if \\\"gen_{}_\\\".format(generation) in path]\\n\\n population = [np.load(path) for path in generation_paths]\\n population_tsnes = np.array([x[\\\"tsne\\\"] for x in population])\\n population_rewards = np.array([x[\\\"average_episodic_reward\\\"] for x in population])\\n tsnes.append(population_tsnes)\\n rewards.append(population_rewards)\\n\\n figure, axs = pyplot.subplots(\\n figsize=[2.5 * 3, 2.5],\\n nrows=1,\\n ncols=len(GENERATIONS),\\n sharex=\\\"all\\\",\\n sharey=\\\"all\\\"\\n )\\n\\n min_reward = min(x.min() for x in rewards)\\n max_reward = max(x.max() for x in rewards)\\n scatter = None\\n\\n for idx in range(len(GENERATIONS)):\\n population_tsne = tsnes[idx]\\n population_rewards = rewards[idx]\\n generation = GENERATIONS[idx]\\n ax = axs[idx]\\n\\n scatter = ax.scatter(\\n population_tsne[:, 0],\\n population_tsne[:, 1],\\n c=population_rewards,\\n vmin=min_reward,\\n vmax=max_reward,\\n cmap=\\\"plasma\\\"\\n )\\n ax.set_title(\\\"Generation {}\\\".format(generation))\\n ax.set_xticks([])\\n ax.set_yticks([])\\n ax.axis(\\\"off\\\")\\n\\n # Making room for colorbar\\n # Stackoverflow #13784201\\n figure.subplots_adjust(right=1.0)\\n cbar = figure.colorbar(scatter)\\n cbar.set_ticks([])\\n cbar.ax.set_ylabel(\\\"Reward $\\\\\\\\rightarrow$\\\", rotation=90, fontsize=\\\"large\\\")\\n\\n figure.tight_layout()\\n figure.savefig(\\\"figures/visual_abstract.pdf\\\", bbox_inches=\\\"tight\\\", pad_inches=0.05)\",\n \"def plotting(self,job,input_zip,output_file,df,my_dpi):\\n if len(job.Y2headers)>0:\\n X1=df.loc[:,job.X1header].values\\n X2=df.loc[:,job.X2header].values\\n Y1=df.loc[:,job.Y1headers].values\\n if (job.name.startswith(\\\"Morphine\\\") or job.name.startswith(\\\"Sarin\\\")) and os.path.exists(job.experimentalData):\\n df2=pd.read_csv(job.experimentalData)\\n Y2=np.array(df2.loc[:,job.Y2headers].values)\\n X1=np.array(df2.loc[:,job.X1header].values[:Y2.shape[0]])\\n Y1=np.array(df.loc[:,job.Y1headers].values[:Y2.shape[0]])\\n X2=np.array(df.loc[:,job.X2header].values[:Y2.shape[0]])\\n else:\\n Y2=df.loc[:,job.Y2headers].values\\n fig,ax = plt.subplots()\\n fig.set_size_inches(w=job.imageWidth/my_dpi+3.1,h=job.imageHeight/my_dpi+1)\\n \\n if not os.path.exists(job.outputDir):\\n os.mkdir(job.outputDir)\\n \\n if job.X1LowerBound and job.X1UpperBound:\\n ax.set_xlim(job.X1LowerBound,job.X1UpperBound)\\n elif job.X1LowerBound:\\n ax.set_xlim(left=job.X1LowerBound)\\n elif job.X1UpperBound:\\n ax.set_xlim(right=job.X1UpperBound)\\n\\n if job.Y1LowerBound and job.Y1UpperBound:\\n ax.set_ylim(job.Y1LowerBound,job.Y1UpperBound)\\n elif job.Y1LowerBound:\\n ax.set_ylim(bottom=job.Y1LowerBound)\\n elif job.Y1UpperBound:\\n ax.set_ylim(top=job.Y1UpperBound) \\n \\n ax.get_yaxis().set_major_locator(MaxNLocator(nbins=18,min_n_ticks=8))\\n ax.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\\n ax.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\\n ax.set_xlabel(job.X1header,fontsize=job.fontSize)\\n \\n if job.Y1Label!=None:\\n ax.set_ylabel(job.Y1Label,color=\\\"g\\\",fontsize=job.fontSize)\\n else:\\n ax.set_ylabel(job.Y1headers[0],color=\\\"g\\\",fontsize=job.fontSize)\\n p1=ax.plot(X1,Y1,color=\\\"g\\\")\\n\\n ax2=ax.twinx()\\n \\n if job.Y2LowerBound and job.Y2UpperBound:\\n ax2.set_ylim(job.Y2LowerBound,job.Y2UpperBound)\\n elif job.Y2LowerBound:\\n ax2.set_ylim(bottom=job.Y2LowerBound)\\n elif job.Y2UpperBound:\\n ax2.set_ylim(top=job.Y2UpperBound)\\n \\n ax2.get_yaxis().set_major_locator(MaxNLocator(nbins=18,min_n_ticks=8))\\n ax2.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\\n ax2.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\\n ax2.set_xlabel(job.X1header,fontsize=job.fontSize)\\n \\n if job.Y2Label!=None:\\n ax2.set_ylabel(job.Y2Label,color=\\\"b\\\",fontsize=job.fontSize)\\n else:\\n ax2.set_ylabel(job.Y2headers[0],color=\\\"b\\\",fontsize=job.fontSize)\\n \\n p2=ax2.plot(X2,Y2,color=\\\"b\\\")\\n title=job.name+\\\"_\\\"\\n title+=job.Y2headers[0]\\n title = title + \\\"vs_\\\" + job.X1header\\n \\n if job.X2header != None and not job.X1header.lower() == job.X2header.lower():\\n title = title + \\\"_\\\" + job.X2header\\n # Override the constructed title if desired\\n \\n if job.titleOverride != None and not len(job.titleOverride)==0 and not job.titleOverride.lower() == \\\"None\\\".lower():\\n title = job.titleOverride\\n if job.log>=1:\\n logging.info(\\\"Creating Graph:\\\"+title)\\n \\n if job.titleOverride !=\\\"None\\\":\\n plt.title(title,fontsize=job.fontSize)\\n \\n if job.showGridLines:\\n plt.grid(b=True, which='major', color='r', linestyle='--')\\n \\n if not job.removeAllLegends:\\n p=p1+p2\\n labs=[job.Y1headers[0],job.Y2headers[0]]\\n ax.legend(p,labs)\\n \\n if \\\"(\\\" and \\\")\\\" in job.outputFilename:\\n job.outputFilename=job.outputFilename.split(\\\"(\\\")[0]+\\\".jpg\\\"\\n plt.savefig(os.path.join(job.outputDir,job.outputFilename),dpi=my_dpi)\\n plt.close(\\\"all\\\")\\n\\n elif len(job.Y2headers)==0:\\n X1=df.loc[:,job.X1header]\\n Y1=df.loc[:,job.Y1headers]\\n fig,ax = plt.subplots()\\n fig.set_size_inches(w=job.imageWidth/my_dpi+3.1,h=job.imageHeight/my_dpi+1)\\n \\n if not os.path.exists(job.outputDir):\\n os.mkdir(job.outputDir)\\n \\n if job.X1LowerBound and job.X1UpperBound:\\n ax.set_xlim(job.X1LowerBound,job.X1UpperBound)\\n elif job.X1LowerBound:\\n ax.set_xlim(left=job.X1LowerBound)\\n elif job.X1UpperBound:\\n ax.set_xlim(right=job.X1UpperBound)\\n\\n if job.Y1LowerBound and job.Y1UpperBound:\\n ax.set_ylim(job.Y1LowerBound,job.Y1UpperBound)\\n elif job.Y1LowerBound:\\n ax.set_ylim(bottom=job.Y1LowerBound)\\n elif job.Y1UpperBound:\\n ax.set_ylim(top=job.Y1UpperBound) \\n \\n ax.get_yaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=8))\\n ax.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\\n ax.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\\n ax.set_xlabel(job.X1header,fontsize=job.fontSize)\\n ax.set_ylabel(job.Y1headers[0],fontsize=job.fontSize)\\n p=ax.plot(X1,Y1)\\n title=job.name+\\\"_\\\"\\n title = title + \\\"vs_\\\" + job.X1header\\n \\n if job.X2header != None and not job.X1header.lower() == job.X2header.lower():\\n title = title + \\\"_\\\" + job.X2header\\n \\n # Override the constructed title if desired\\n if job.titleOverride != None and not len(job.titleOverride)==0 and not job.titleOverride.lower() == \\\"None\\\".lower():\\n title = job.titleOverride\\n if job.log>=1:\\n logging.info(\\\"Creating Graph:\\\"+title)\\n \\n if job.titleOverride !=\\\"None\\\":\\n plt.title(title,fontsize=job.fontSize)\\n \\n if job.showGridLines:\\n plt.grid(b=True, which='major', color='r', linestyle='--')\\n \\n if not job.removeAllLegends:\\n labs=job.Y1headers\\n plt.legend(p,labs)\\n \\n if \\\"(\\\" and \\\")\\\" in job.outputFilename:\\n job.outputFilename=job.outputFilename.split(\\\"(\\\")[0]+\\\".jpg\\\"\\n plt.savefig(os.path.join(job.outputDir,job.outputFilename),dpi=my_dpi)\\n plt.close(\\\"all\\\")\\n \\n else:\\n X1=df.loc[:,job.X1header]\\n Y1=df.loc[:,job.Y1headers]\\n fig,ax = plt.subplots()\\n fig.set_size_inches(w=job.imageWidth/my_dpi+3.1,h=job.imageHeight/my_dpi+1)\\n \\n if not os.path.exists(job.outputDir):\\n os.mkdir(job.outputDir)\\n \\n if job.X1LowerBound and job.X1UpperBound:\\n ax.set_xlim(job.X1LowerBound,job.X1UpperBound)\\n elif job.X1LowerBound:\\n ax.set_xlim(left=job.X1LowerBound)\\n elif job.X1UpperBound:\\n ax.set_xlim(right=job.X1UpperBound)\\n\\n if job.Y1LowerBound and job.Y1UpperBound:\\n ax.set_ylim(job.Y1LowerBound,job.Y1UpperBound)\\n elif job.Y1LowerBound:\\n ax.set_ylim(bottom=job.Y1LowerBound)\\n elif job.Y1UpperBound:\\n ax.set_ylim(top=job.Y1UpperBound) \\n \\n ax.get_yaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=8))\\n ax.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\\n ax.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\\n ax.set_xlabel(job.X1header,fontsize=job.fontSize)\\n ax.set_ylabel(job.Y1headers[0],fontsize=job.fontSize)\\n p1=ax.plot(X1,Y1)\\n title=job.name+\\\"_\\\"\\n title = title + \\\"vs_\\\" + job.X1header\\n \\n if job.X2header != None and not job.X1header.lower() == job.X2header.lower():\\n title = title + \\\"_\\\" + job.X2header\\n \\n # Override the constructed title if desired\\n if job.titleOverride != None and not len(job.titleOverride)==0 and not job.titleOverride.lower() == \\\"None\\\".lower():\\n title = job.titleOverride\\n if job.log>=1:\\n logging.info(\\\"Creating Graph:\\\"+title)\\n \\n if job.titleOverride !=\\\"None\\\":\\n plt.title(title,fontsize=job.fontSize)\\n \\n if job.showGridLines:\\n plt.grid(b=True, which='major', color='r', linestyle='--')\\n \\n if not job.removeAllLegends:\\n labs=job.Y1headers\\n ax.legend(p1, labs)\\n \\n if \\\"(\\\" and \\\")\\\" in job.outputFilename:\\n job.outputFilename=job.outputFilename.split(\\\"(\\\")[0]+\\\".jpg\\\"\\n plt.savefig(os.path.join(job.outputDir,job.outputFilename),dpi=my_dpi)\\n plt.close(\\\"all\\\")\",\n \"def generate_plots(self, headers: [str], barplot_name: str, barplot_data: [int],\\n lineplot_name: str, multi_data: [[int]]):\\n self.export_data(barplot_name, headers, barplot_data)\\n title = 'Total IRTs (' + str(C.MAX_ITERATIONS) + ' Steps)'\\n self.barplot(barplot_name, y_label='Total IRT', img_title=title)\\n self.lineplot(lineplot_name, headers, multi_data, img_title='IRT Paths')\",\n \"def plot_rates(save_dir, formation_rate, merger_rate, detection_rate, redshifts, chirp_masses, show_plot = False, mu0=0.035, muz=-0.23, sigma0=0.39, sigmaz=0., alpha=0):\\n # sum things up across binaries\\n total_formation_rate = np.sum(formation_rate, axis=0)\\n total_merger_rate = np.sum(merger_rate, axis=0)\\n total_detection_rate = np.sum(detection_rate, axis=0)\\n \\n # and across redshifts\\n cumulative_detection_rate = np.cumsum(total_detection_rate)\\n detection_rate_by_binary = np.sum(detection_rate, axis=1)\\n\\n ###########################\\n #Start plotting\\n\\n # set some constants for the plots\\n plt.rc('font', family='serif')\\n fs = 20\\n lw = 3\\n\\n fig, axes = plt.subplots(2, 2, figsize=(20, 20))\\n\\n axes[0,0].plot(redshifts, total_formation_rate, lw=lw)\\n axes[0,0].set_xlabel('Redshift', fontsize=fs)\\n axes[0,0].set_ylabel(r'Formation rate $[\\\\rm \\\\frac{\\\\mathrm{d}N}{\\\\mathrm{d}Gpc^3 \\\\mathrm{d}yr}]$', fontsize=fs)\\n\\n axes[0,1].plot(redshifts, total_merger_rate, lw=lw)\\n axes[0,1].set_xlabel('Redshift', fontsize=fs)\\n axes[0,1].set_ylabel(r'Merger rate $[\\\\rm \\\\frac{\\\\mathrm{d}N}{\\\\mathrm{d}Gpc^3 \\\\mathrm{d}yr}]$', fontsize=fs)\\n\\n axes[1,0].plot(redshifts[:len(cumulative_detection_rate)], cumulative_detection_rate, lw=lw)\\n axes[1,0].set_xlabel('Redshift', fontsize=fs)\\n axes[1,0].set_ylabel(r'Cumulative detection rate $[\\\\rm \\\\frac{\\\\mathrm{d}N}{\\\\mathrm{d}yr}]$', fontsize=fs)\\n\\n axes[1,1].hist(chirp_masses, weights=detection_rate_by_binary, bins=25, range=(0, 50))\\n axes[1,1].set_xlabel(r'Chirp mass, $\\\\mathcal{M}_c$', fontsize=fs)\\n axes[1,1].set_ylabel(r'Mass distribution of detections $[\\\\rm \\\\frac{\\\\mathrm{d}N}{\\\\mathrm{d}\\\\mathcal{M}_c \\\\mathrm{d}yr}]$', fontsize=fs)\\n\\n #########################\\n #Plotvalues\\n\\n # Add text upper left corner\\n axes[0,0].text(0.05,0.8, \\\"mu0=%s \\\\nmuz=%s \\\\nsigma0=%s \\\\nsigmaz=%s \\\\nalpha=%s\\\"%(mu0,muz,sigma0,sigmaz,alpha), transform=axes[0,0].transAxes, size = fs) \\n\\n for ax in axes.flatten():\\n ax.tick_params(labelsize=0.9*fs)\\n\\n # Save and show :)\\n plt.savefig(save_dir +'Rate_Info'+\\\"mu0%s_muz%s_alpha%s_sigma0%s_sigmaz%s\\\"%(mu0,muz,alpha,sigma0, sigmaz)+'.png', bbox_inches='tight') \\n if show_plot:\\n plt.show()\\n else:\\n plt.close()\",\n \"def radial_graph(self):\\n \\n if self['M_RADIAL']['intens'] != None:\\n name = self['name']\\n id = self._getGraphId()\\n figname = 'RADIAL_%s.eps' % id\\n sxlabel = 'Pixel Radius' ; sylabel = 'Intens' \\n title = 'Radial profile, %s' % (name,)\\n y = self['M_RADIAL']['intens']\\n x = self['M_RADIAL']['radii']\\n xy = ((x,y),)\\n Plot(xy,figname,sxlabel,sylabel,title)\\n self['figures']['radial'] = figname\\n else : pass\",\n \"def plot_tiltres(setup, mtilt, ytilt, yfit, slit=None, outfile=None, show_QA=False, out_dir=None):\\n\\n plt.rcdefaults()\\n plt.rcParams['font.family']= 'times new roman'\\n\\n # Outfil\\n method = inspect.stack()[0][3]\\n if (outfile is None) and (not show_QA):\\n outfile = qa.set_qa_filename(setup, method, slit=slit, out_dir=out_dir)\\n\\n # Setup\\n plt.figure(figsize=(8, 4.0))\\n plt.clf()\\n ax = plt.gca()\\n\\n # Scatter plot\\n res = (mtilt-ytilt) - yfit\\n ax.scatter(mtilt, res)\\n\\n rms = np.std(res)\\n ax.text(0.90, 0.90, 'Slit {:d}: RMS (pix) = {:0.5f}'.format(slit, rms),\\n transform=ax.transAxes, size='large', ha='right', color='black')\\n # Label\\n ax.set_xlabel('Row')\\n ax.set_ylabel('Residual (pix)')\\n\\n # Finish\\n plt.tight_layout(pad=0.2, h_pad=0.0, w_pad=0.0)\\n if show_QA:\\n plt.show()\\n else:\\n plt.savefig(outfile, dpi=400)\\n plt.close()\\n\\n plt.rcdefaults()\\n\\n return\",\n \"def make_posterior_plots(self, combined=False):\\n import matplotlib.pyplot as plt\\n plt.rcParams['text.usetex'] = True\\n\\n if combined:\\n outdir = os.path.join(self.outdir, 'CombinedPosteriors')\\n maintitle = self.make_main_title(end='Posteriors')\\n else:\\n outdir = os.path.join(self.outdir, 'IndividualPosteriors')\\n maintitle = self.make_main_title(end='Posterior')\\n mkdir(outdir)\\n\\n for injkey in self.values.keys():\\n for fhkey in self.values[injkey].keys():\\n # Set up multi-plot if needed\\n if combined:\\n num_rows = self.get_num_rows(\\n data=self.values[injkey][fhkey],\\n omit_metric=False\\n )\\n plt.figure(figsize=(20, 5*num_rows+2))\\n subplotnum = 1\\n else:\\n subplotnum = None\\n # Loop through the systematics\\n for systkey in self.values[injkey][fhkey].keys():\\n fittitle = self.make_fit_title(\\n fhkey=fhkey,\\n trials=self.num_trials\\n )\\n systunits = self.values[injkey][fhkey][systkey]['units']\\n if systkey == 'metric_val':\\n xlabel = self.tex_axis_label(\\n self.values[injkey][fhkey][systkey]['type']\\n )\\n else:\\n xlabel = self.tex_axis_label(systkey)\\n if not systunits == 'dimensionless':\\n xlabel += r' (%s)'%self.tex_axis_label(systunits)\\n # Specify the subplot, if necessary\\n if combined:\\n plt.subplot(num_rows, 4, subplotnum)\\n self.make_1d_hist_plot(\\n data=np.array(\\n self.values[injkey][fhkey][systkey]['vals']\\n ),\\n xlabel=xlabel,\\n title=maintitle+r'\\\\\\\\'+fittitle,\\n ylabel='Number of Trials',\\n subplotnum=subplotnum\\n )\\n # Add the details i.e. injected/fiducial lines and priors\\n plt.ylim(0, 1.35*plt.ylim()[1])\\n if not systkey == 'metric_val':\\n self.add_inj_fid_lines(\\n injkey=injkey,\\n systkey=systkey,\\n fhkey=fhkey\\n )\\n self.add_prior_region(\\n injkey=injkey,\\n systkey=systkey,\\n fhkey=fhkey\\n )\\n plt.legend(\\n loc='upper left',\\n fontsize=12,\\n framealpha=1.0\\n )\\n plt.subplots_adjust(\\n left=0.10,\\n right=0.90,\\n top=0.85,\\n bottom=0.11\\n )\\n # Advance the subplot number, if necessary\\n if combined:\\n subplotnum += 1\\n # Else, save/close this plot\\n else:\\n self.save_plot(\\n fhkey=fhkey,\\n outdir=outdir,\\n end='%s_posterior'%systkey\\n )\\n plt.close()\\n # Save the whole canvas, if necessary\\n if combined:\\n plt.suptitle(maintitle+r'\\\\\\\\'+fittitle, fontsize=36)\\n plt.tight_layout()\\n plt.subplots_adjust(top=0.9)\\n self.save_plot(\\n fhkey=fhkey,\\n outdir=outdir,\\n end='posteriors'\\n )\\n plt.close()\",\n \"def plot_analysis(opt):\\n LOG.debug(\\\"Plotting GetLLM analysis.\\\")\\n mdl_analysis = opt.subnode in mdl_subnodes\\n\\n ps.set_style(\\\"standard\\\", MANUAL_STYLE)\\n xmin = min(opt.xplot_xmin, opt.yplot_xmin)\\n xmax = max(opt.xplot_xmax, opt.yplot_xmax)\\n\\n gs = gridspec.GridSpec(2, 1, height_ratios=[1, 1])\\n ax_x = plt.subplot(gs[0])\\n ax_y = None\\n ir_pos = None\\n\\n paths = opt.path.split(',')\\n\\n if opt.label == 'None':\\n if mdl_analysis:\\n labels = [\\\"mo_\\\" + opt.path.rsplit('/', 1)[-1], \\\"me_\\\" + opt.path.rsplit('/', 1)[-1]]\\n else:\\n labels = paths\\n else:\\n labels = opt.label.split(',')\\n\\n for idx, path in enumerate(paths):\\n data_x, data_y = get_data(path, opt.mainnode, opt.subnode)\\n plot_data(ax_x, data_x, labels, idx, opt.change_marker)\\n\\n if ir_pos is None:\\n ir_pos = get_irpos(data_x, opt.accel)\\n\\n if data_y is not None:\\n if ax_y is None:\\n ax_x.axes.get_xaxis().set_visible(False)\\n ax_y = plt.subplot(gs[1])\\n plot_data(ax_y, data_y, labels, idx, opt.change_marker)\\n\\n ax_x.set_xlim(xmin, xmax)\\n ax_x.set_ylim(opt.xplot_ymin, opt.xplot_ymax)\\n set_yaxis_label(ax_x, 'x', opt.subnode)\\n\\n if ax_y is not None:\\n ax_y.set_xlim(xmin, xmax)\\n ax_y.set_ylim(opt.yplot_ymin, opt.yplot_ymax)\\n set_yaxis_label(ax_y, 'y', opt.subnode)\\n ps.set_xaxis_label(ax_y)\\n if ir_pos:\\n ps.show_ir(ir_pos, ax_y, mode='outside')\\n ps.show_ir(ir_pos, ax_x, mode='lines')\\n else:\\n ax_x.axes.get_xaxis().set_visible(True)\\n ps.set_xaxis_label(ax_x)\\n if ir_pos:\\n ps.show_ir(ir_pos, ax_x, mode='outside')\\n\\n if int(opt.legendh) > 12:\\n show_legend(ax_x, int(opt.legendx), int(opt.legendy))\\n return gs\",\n \"def plot(self, **kwargs):\\n\\n # get colors\\n colors = kwargs.get(\\\"colors\\\", GW_OBSERVATORY_COLORS)\\n\\n # get Result samples\\n self._samples = {\\n label: value.posterior\\n for label, value in self.results.items()\\n if isinstance(value, Result)\\n }\\n\\n # get Grid posteriors\\n self._grids = {\\n label: [value, value.ln_evidence] # store grid and log evidence\\n for label, value in self.results.items()\\n if isinstance(value, Grid)\\n }\\n\\n # apply offsets for slightly nicer plots axes\\n self.parameter_offsets = {parameter: 0.0 for parameter in self.parameters}\\n if len(self._grids) == 0 and len(self._samples) == 1:\\n for label in self._samples:\\n for parameter in self.parameters:\\n srange = [\\n np.min(self._samples[label][parameter]),\\n np.max(self._samples[label][parameter]),\\n ]\\n label_suffix = \\\"\\\"\\n\\n # offset values\\n median = np.median(self._samples[label][parameter])\\n relwidth = np.abs((srange[1] - srange[0]) / median)\\n\\n if relwidth < 1e-4:\\n offsetstr = f\\\"{median:.4e}\\\"\\n a, b = offsetstr.split(\\\"e\\\")\\n\\n if np.abs(int(b)) < 3:\\n offsetstr = f\\\"{median:.4f}\\\"\\n offset = float(offsetstr)\\n else:\\n offset = float(offsetstr)\\n offsetstr = a + rf\\\"\\\\!\\\\times\\\\!10^{{{int(b)}}}\\\"\\n\\n self.parameter_offsets[parameter] = offset\\n\\n self._samples[label][parameter] -= offset\\n label_suffix = rf\\\" [${{\\\\scriptstyle {offsetstr}}}$]\\\"\\n\\n self.latex_labels[parameter] += label_suffix\\n\\n colordicts = []\\n for j, res in enumerate([self._samples, self._grids]):\\n colordicts.append({})\\n for i, key in enumerate(res):\\n if key in colors:\\n colordicts[-1][key] = colors[key]\\n elif key.lower() == \\\"joint\\\":\\n # if using \\\"Joint\\\" as the multi-detector analysis key, set the color to black\\n colordicts[-1][key] = \\\"k\\\"\\n else:\\n # use PESummary color cycle\\n colordicts[-1][key] = list(colorcycle)[\\n (j * 2 + i) % len(colorcycle)\\n ]\\n\\n # store original keywords arguments\\n origkwargs = kwargs.copy()\\n\\n # plot samples\\n fig = None\\n if len(self._samples) > 0:\\n kwargs[\\\"colors\\\"] = list(colordicts[0].values())\\n if self._num_parameters == 1:\\n fig = self._1d_plot_samples(**kwargs)\\n elif self._num_parameters == 2 and self.plottype != \\\"corner\\\":\\n fig = self._2d_plot_samples(**kwargs)\\n else:\\n fig = self._nd_plot_samples(**kwargs)\\n\\n # restore keywords\\n kwargs = origkwargs\\n\\n if len(self._grids) > 0:\\n kwargs[\\\"colors\\\"] = list(colordicts[1].values())\\n if fig is not None and \\\"fig\\\" not in kwargs:\\n kwargs[\\\"fig\\\"] = fig\\n if self._num_parameters == 1:\\n fig = self._1d_plot_grid(**kwargs)\\n elif self._num_parameters == 2 and self.plottype != \\\"corner\\\":\\n fig = self._2d_plot_grid(**kwargs)\\n else:\\n fig = self._nd_plot_grid(**kwargs)\\n\\n # add further figure information\\n if self._num_parameters == 1:\\n ax = fig.gca()\\n\\n # set figure bounds if outside defaults\\n if self.parameters[0] in DEFAULT_BOUNDS:\\n _set_axes_limits(ax, self.parameters[0], axis=\\\"x\\\")\\n\\n # add injection values\\n if self.injection_parameters is not None:\\n if self.injection_parameters[self.parameters[0]] is not None:\\n ax.axvline(\\n (\\n self.injection_parameters[self.parameters[0]]\\n - self.parameter_offsets[self.parameters[0]]\\n ),\\n color=kwargs.get(\\\"injection_color\\\", \\\"k\\\"),\\n linewidth=1,\\n )\\n elif self._num_parameters == 2:\\n if \\\"triangle\\\" in self.plottype:\\n a1, a2, a3 = fig[1:]\\n order = [\\\"x\\\", \\\"y\\\"] if self.plottype == \\\"triangle\\\" else [\\\"y\\\", \\\"x\\\"]\\n params = (\\n self.parameters[:2]\\n if self.plottype == \\\"triangle\\\"\\n else self.parameters[1::-1]\\n )\\n\\n # set figure bounds if outside defaults\\n for param, axes, axis in zip(params, [[a1, a2], [a2, a3]], order):\\n for ax in axes:\\n _set_axes_limits(ax, param, axis=axis)\\n\\n self.fig = fig\\n return self.fig\",\n \"def plot_evaluation(values, info, measures = ['Dice','Jaccard', 'TPR', 'TNR', '1-GCE', 'VS', 'RI', 'ARI', 'MI', '1-VOI', 'ICC','1/(1+PBD)', 'KAP', 'AUC', '1/(1+HD)', '1/(1+AVD)', 'MHD' ], colourmap=None, outfile='polar_results.png'):\\n _min = info['minimum']\\n _max = info['maximum']\\n if colourmap is None:\\n colourmap = [[86./255.,180./255.,233./255.] for ii in range(values.shape[0])]\\n else:\\n # normalize colourmap values between 0 and 1\\n colourmap = (colourmap-_min)/(_max-_min)\\n # apply cividis, returns the RBG1 values for cividis, for dots\\n colourmap = [[cm.cividis(ii)] for ii in colourmap] \\n\\n # elements of the circle\\n N = len(measures)\\n # evenly space measures around circle\\n x_as = [n / float(N) * 2 * pi for n in range(N)] \\n\\n # Set color of axes\\n plt.rc('axes', linewidth=0.5, edgecolor=\\\"#888888\\\")\\n\\n # Create polar plot\\n fig = plt.figure(figsize = (11,9.5))\\n gs = gridspec.GridSpec(1, 3, width_ratios=[17,2,1])\\n ax = plt.subplot(gs[0], polar=True)\\n \\n # Set position of y-labels\\n ax.set_rlabel_position(0)\\n\\n # Set color and linestyle of grid\\n ax.xaxis.grid(True, color=\\\"#888888\\\", linestyle='solid', linewidth=0.5)\\n ax.yaxis.grid(True, color=\\\"#888888\\\", linestyle='solid', linewidth=0.5)\\n\\n # Set yticks\\n plt.yticks([0.2, 0.4, 0.6, 0.8, 1.0], [\\\"0.2\\\", \\\"0.4\\\", \\\"0.6\\\", \\\"0.8\\\", \\\"1.0\\\"], fontsize=15)\\n pos=ax.get_rlabel_position()\\n ax.set_rlabel_position(pos+0.4*360./float(len(measures)))\\n\\n # Plot data\\n for ii in np.arange(values.shape[0]):\\n xx = np.asarray(x_as) + np.random.randn(len(x_as))*np.diff(x_as)[0]/15.\\n data_norm = None\\n if info['logplot']:\\n data_norm = matplotlib.colors.LogNorm(vmin=_min, vmax=_max)\\n sc = ax.scatter(xx, values[ii,:], 23, color=colourmap[ii]*len(xx), norm=data_norm, zorder=3) \\n\\n # Fill area\\n # close the circle\\n median = list(np.median(values, axis=0))\\n median += median[:1]\\n upper = list(np.percentile(values, 75, axis=0))\\n upper += upper[:1]\\n lower = list(np.percentile(values, 25, axis=0))\\n lower += lower[:1]\\n x_as += x_as[:1]\\n ax.plot(x_as, median, color=[86./255.,180./255.,233./255.], zorder=5)\\n ax.fill_between(x_as, upper, lower, zorder=4, color=[86./255.,180./255.,233./255.], alpha=0.3)\\n\\n # Set number of radial axes and remove labels\\n plt.xticks(x_as[:-1], [])\\n\\n # Set axes limits\\n plt.ylim(0, 1)\\n\\n # Draw ytick labels to make sure they fit properly\\n for i in range(N):\\n angle_rad = i / float(N) * 2 * pi-0.05\\n text_size = 21\\n if i in {3,8}:\\n ax.text(angle_rad, 1.15, measures[i]+\\\"\\\\n(m=%0.2f)\\\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\\\"center\\\")\\n elif i in {0}:\\n ax.text(angle_rad, 1.25, measures[i]+\\\"\\\\n(m=%0.2f)\\\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\\\"center\\\")\\n elif i in {1,5,7}:\\n ax.text(angle_rad, 1.29, measures[i]+\\\"\\\\n(m=%0.2f)\\\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\\\"center\\\")\\n elif i in {4}:\\n ax.text(angle_rad, 1.32, measures[i]+\\\"\\\\n(m=%0.2f)\\\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\\\"top\\\")\\n elif i in {10}:\\n ax.text(angle_rad, 1.26, measures[i]+\\\"\\\\n(m=%0.2f)\\\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\\\"center\\\")\\n elif i in {6}:\\n ax.text(angle_rad, 1.25, measures[i]+\\\"\\\\n(m=%0.2f)\\\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\\\"center\\\")\\n elif i in {9}:\\n ax.text(angle_rad, 1.18, measures[i]+\\\"\\\\n(m=%0.2f)\\\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\\\"center\\\")\\n else:\\n ax.text(angle_rad, 1.22, measures[i]+\\\"\\\\n(m=%0.2f)\\\" %median[i], size=text_size, horizontalalignment='center', verticalalignment=\\\"center\\\")\\n\\n # colorbar location on figure\\n cbaxes = plt.subplot(gs[2])\\n\\n # log scaling option\\n norm = None\\n if info['logplot']:\\n norm = matplotlib.colors.LogNorm(vmin=_min,vmax=_max)\\n\\n img = plt.imshow(np.array([[_min,_max]]), aspect='auto', cmap=\\\"cividis\\\", norm=norm)\\n img.set_visible(False)\\n\\n # initialize colorbar\\n cbar = plt.colorbar(cax = cbaxes)\\n\\n # ticks and label\\n c_values = cbar.get_ticks().tolist()\\n \\n ticklabels = [\\\"\\\" for ii in c_values]\\n if _min < np.min(c_values):\\n c_values = [_min] + c_values\\n ticklabels = [\\\"%0.1f %s\\\" %(np.min(c_values), info['unit'])] + ticklabels\\n else:\\n ticklabels[0] = \\\"%0.1f %s\\\" %(np.min(c_values), info['unit'])\\n\\n if _max > np.max(c_values):\\n c_values = c_values + [_max]\\n ticklabels = ticklabels + [\\\"%0.1f %s\\\" %(np.max(c_values), info['unit'])]\\n else:\\n ticklabels[-1] = \\\"%0.1f %s\\\" %(np.max(c_values), info['unit'])\\n \\n cbar.set_ticks(c_values)\\n cbar.set_ticklabels(ticklabels)\\n cbaxes.yaxis.set_minor_formatter(matplotlib.ticker.NullFormatter())\\n cbar.ax.set_ylabel(info[\\\"label\\\"], labelpad=-20)\\n \\n # font sizes for colorbar\\n cbar.ax.yaxis.label.set_size(19)\\n cbar.ax.tick_params(labelsize=14)\\n\\n # Save and show polar plot \\n plt.savefig(outfile)\\n if info['display']:\\n plt.show()\\n plt.clf()\\n plt.close('all')\",\n \"def walkplot(cons):\\n # Call always after cons.runn()!\\n if not hasattr(cons, \\\"outplot\\\"):\\n print(\\\"Consortium must run before analyzing the output of the run!\\\")\\n return\\n global plt\\n if not plt:\\n import matplotlib.pyplot as plt\\n\\n # keep original inputs\\n original_metplots = dcp(cons.mets_to_plot)\\n original_outplot = dcp(cons.outplot)\\n cons.outplot = \\\"tmp.png\\\"\\n mets = [k for k in cons.media]\\n # loop over metabolites, plot them and let the user close the window\\n for m in range(0, len(mets), 4):\\n cons.mets_to_plot = [mets[m], mets[m + 1], mets[m + 2], mets[m + 3]]\\n plot_comm(cons)\\n plt.show()\\n print(\\\"Image number\\\", m / 4)\\n\\n # clean temporary files, return to orginal parameters\\n plt.close(\\\"all\\\")\\n os.remove(cons.outplot)\\n cons.mets_to_plot = original_metplots\\n cons.outplot = original_outplot\\n return\",\n \"def app_SN_combined_moisture_gradient(self, dfs, phase_dirs, sizer_val, styler_val):\\n\\n print('Currently plotting plot_SN_combined_moisture_gradients')\\n\\n for df, direc in zip(dfs, phase_dirs):\\n self.plotter.plot_SN_combined_moisture_gradients(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['01_combined_plots'],\\n sizer=self.formatter.sizer[sizer_val]['3x1_partial_width'],\\n styler=self.formatter.styler[styler_val],\\n xscale=self.xscale_var.get()\\n )\\n\\n print('Done\\\\n')\",\n \"def app_SN_combined_series_moist_vs_temp(self, dfs, phase_dirs, sizer_val, styler_val):\\n\\n print('Currently plotting plot_SN_combined_series_moist_vs_temp')\\n\\n for df, direc in zip(dfs, phase_dirs):\\n # this iterates one or multiple times\\n self.plotter.plot_SN_combined_series_moist_vs_temp(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['08_time_series_moisture_vs_temperature'],\\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\\n styler=self.formatter.styler[styler_val],\\n )\\n self.plotter.plot_SN_combined_series_moist_vs_temp(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['08_time_series_moisture_vs_temperature'],\\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\\n styler=self.formatter.styler[styler_val],\\n xaxis_type='datetime',\\n )\\n self.plotter.plot_SN_combined_series_moist_vs_temp(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['08_time_series_moisture_vs_temperature'],\\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\\n styler=self.formatter.styler[styler_val],\\n normalized=True,\\n )\\n\\n print('Done\\\\n')\",\n \"def plot_reion_properties(rank, size, comm, reion_ini_files, gal_ini_files,\\n model_tags, reion_plots, output_dir, output_format):\\n\\n # Check to see if the output directory exists.\\n if rank == 0:\\n if not os.path.exists(output_dir):\\n os.makedirs(output_dir)\\n print(\\\"Made output directory {0}\\\".format(output_dir))\\n\\n MC_dir = \\\"{0}/MC\\\".format(output_dir)\\n os.makedirs(MC_dir)\\n print(\\\"Made directory {0}\\\".format(MC_dir))\\n\\n # First calculate all the properties and statistics we need.\\n reion_data = generate_data(rank, size, comm, reion_ini_files,\\n gal_ini_files, reion_plots, output_dir,\\n model_tags, output_format)\\n\\n # Gather all the fractions onto the master process.\\n # This will be used for many different plots. \\n master_mass_frac = collective.collect_hist_across_tasks(rank, comm, \\n reion_data[\\\"mass_frac_allmodels\\\"]) \\n master_mass_frac = comm.bcast(master_mass_frac, root = 0)\\n\\n # Then find out what we need and plot em!\\n if reion_plots[\\\"history\\\"] and rank == 0:\\n\\n \\n duration_z, duration_t, reion_completed = \\\\\\n calc_duration(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"],\\n master_mass_frac, reion_plots[\\\"duration_definition\\\"])\\n\\n for model_number in range(len(master_mass_frac)):\\n print(\\\"Model {0}: Start {1:.2f} \\\\tMid {2:.2f}\\\\tEnd {3:.2f}\\\\t\\\"\\n \\\"dz {4:.2f}\\\\tdt {5:.1f}Myr\\\\tReion Completed {6}\\\" \\\\\\n .format(model_number, duration_z[model_number][0],\\n duration_z[model_number][1], duration_z[model_number][-1],\\n duration_z[model_number][0]-duration_z[model_number][-1],\\n duration_t[model_number][-1]-duration_t[model_number][0],\\n reion_completed[model_number]))\\n\\n print(\\\"Plotting the reionization history.\\\")\\n reionplot.plot_history(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"t_bigbang_allmodels\\\"],\\n master_mass_frac,\\n model_tags, output_dir, \\\"history\\\",\\n output_format)\\n\\n\\n\\n if reion_plots[\\\"nion\\\"]:\\n\\n master_nion = collective.collect_hist_across_tasks(rank, comm, \\n reion_data[\\\"nion_allmodels\\\"])\\n\\n if rank == 0:\\n print(\\\"Plotting the ionizing emissivity.\\\")\\n reionplot.plot_nion(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"t_bigbang_allmodels\\\"],\\n master_nion,\\n reion_data[\\\"nion_factor_allmodels\\\"], \\n model_tags, output_dir, \\\"nion\\\", output_format)\\n\\n if reion_plots[\\\"ps_fixed_XHI\\\"]:\\n k, P21, PHII = determine_ps_fixed_XHI(rank, size, comm,\\n reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n master_mass_frac, \\n reion_data[\\\"XHII_fbase_allmodels\\\"],\\n reion_data[\\\"XHII_precision_allmodels\\\"],\\n reion_data[\\\"density_fbase_allmodels\\\"],\\n reion_data[\\\"density_precision_allmodels\\\"],\\n reion_data[\\\"GridSize_allmodels\\\"],\\n reion_data[\\\"boxsize_allmodels\\\"],\\n reion_data[\\\"first_snap_allmodels\\\"],\\n reion_plots[\\\"fixed_XHI_values\\\"])\\n\\n if rank == 0:\\n print(\\\"Plotting PS at fixed neutral fraction.\\\")\\n reionplot.plot_ps_fixed_XHI(k, P21, PHII,\\n reion_plots[\\\"fixed_XHI_values\\\"],\\n model_tags, output_dir, \\\"ps_fixed_XHI\\\",\\n output_format)\\n\\n if reion_plots[\\\"contours\\\"] and rank == 0:\\n # tau is used for multiple plots. So check if we need to calculate it.\\n try:\\n tau_allmodels\\n except NameError:\\n tau_allmodels = calc_tau(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"helium_allmodels\\\"],\\n master_mass_frac)\\n\\n # For the contours, only plot the optical depth at the highest z.\\n tau_highz = []\\n for model_number in range(len(tau_allmodels)):\\n tau_highz.append(tau_allmodels[model_number][0])\\n\\n duration_z, duration_t, reion_completed = \\\\\\n calc_duration(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"],\\n master_mass_frac, reion_plots[\\\"duration_definition\\\"])\\n\\n print(\\\"Plotting contours of constant tau.\\\")\\n reionplot.plot_tau_contours(tau_highz, reion_completed,\\n reion_plots[\\\"alpha_beta_limits\\\"],\\n output_dir, \\\"tau_contours\\\", output_format)\\n\\n print(\\\"Plotting contours of constant reionization duration.\\\")\\n reionplot.plot_duration_contours(duration_t, reion_completed,\\n reion_plots[\\\"alpha_beta_limits\\\"],\\n output_dir, \\\"duration_contours\\\",\\n output_format)\\n\\n if reion_plots[\\\"optical_depth\\\"] and rank == 0:\\n # tau is used for multiple plots. So check if we need to calculate it.\\n try:\\n tau_allmodels\\n except NameError:\\n tau_allmodels = calc_tau(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"helium_allmodels\\\"],\\n master_mass_frac)\\n\\n print(\\\"Plotting the optical depth.\\\")\\n reionplot.plot_tau(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"], \\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"t_bigbang_allmodels\\\"],\\n tau_allmodels,\\n model_tags, output_dir, \\\"optical_depth\\\",\\n output_format)\\n\\n if reion_plots[\\\"optical_depth\\\"] and reion_plots[\\\"history\\\"] and rank == 0:\\n print(\\\"Plotting the combined optical depth/ionization history.\\\")\\n reionplot.plot_combined_history_tau(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"], \\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"t_bigbang_allmodels\\\"],\\n master_mass_frac, tau_allmodels, \\n model_tags, output_dir,\\n \\\"history_tau\\\", output_format)\\n\\n if reion_plots[\\\"optical_depth\\\"] and reion_plots[\\\"nion\\\"] and rank == 0:\\n print(\\\"Plotting the combined optical depth/ionizing emissivity.\\\")\\n reionplot.plot_combined_nion_tau(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"t_bigbang_allmodels\\\"],\\n master_nion,\\n reion_data[\\\"nion_factor_allmodels\\\"],\\n tau_allmodels, model_tags, output_dir,\\n \\\"nion_tau\\\", output_format)\\n\\n if reion_plots[\\\"ps_scales\\\"] or reion_plots[\\\"ps_scales_beta\\\"]:\\n print(\\\"Gathering the 21cm Power Spectra across processors\\\")\\n k, P21, PHII = gather_ps(rank, size, comm,\\n reion_data[\\\"k_allmodels\\\"],\\n reion_data[\\\"P21_allmodels\\\"],\\n reion_data[\\\"PHII_allmodels\\\"],\\n reion_data[\\\"first_snap_allmodels\\\"],\\n reion_data[\\\"last_snap_allmodels\\\"])\\n\\n if rank == 0:\\n print(\\\"Plotting the large scale power as a function of small \\\"\\n \\\"scale.\\\")\\n\\n if reion_plots[\\\"ps_scales_beta\\\"]:\\n calc_beta = True\\n else:\\n calc_beta = False \\n\\n # Now that we have all the PS on the master rank, calculate the\\n # amplitude at the specified scales.\\n scale_power_dict = calc_scale_power(k, P21, PHII,\\n reion_data[\\\"z_array_reion_allmodels\\\"], \\n reion_plots[\\\"small_scale_def\\\"],\\n reion_plots[\\\"large_scale_def\\\"],\\n reion_plots[\\\"small_scale_err\\\"],\\n reion_plots[\\\"large_scale_err\\\"],\\n calc_beta=calc_beta)\\n\\n k_small_scale = scale_power_dict[\\\"k_small_scale\\\"]\\n k_large_scale = scale_power_dict[\\\"k_large_scale\\\"]\\n\\n P21_small_scale = scale_power_dict[\\\"P21_small_scale\\\"]\\n P21_large_scale = scale_power_dict[\\\"P21_large_scale\\\"]\\n\\n PHII_small_scale = scale_power_dict[\\\"PHII_small_scale\\\"]\\n PHII_large_scale = scale_power_dict[\\\"PHII_large_scale\\\"]\\n\\n if reion_plots[\\\"ps_scales\\\"]:\\n reionplot.plot_ps_scales(P21_small_scale,\\n P21_large_scale, master_mass_frac, \\n reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_plots[\\\"fixed_XHI_values\\\"],\\n reion_plots[\\\"ps_scales_z\\\"],\\n reion_plots[\\\"small_scale_def\\\"],\\n reion_plots[\\\"large_scale_def\\\"],\\n reion_plots[\\\"small_scale_err\\\"],\\n reion_plots[\\\"large_scale_err\\\"],\\n model_tags, output_dir, \\\"ps_scales\\\",\\n output_format)\\n\\n if reion_plots[\\\"ps_scales_beta\\\"]:\\n\\n P21_beta = scale_power_dict[\\\"P21_beta\\\"]\\n P21_beta_error = scale_power_dict[\\\"P21_beta_error\\\"]\\n PHII_beta = scale_power_dict[\\\"PHII_beta\\\"]\\n\\n reionplot.plot_ps_beta(P21_beta, P21_beta_error,\\n reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"t_bigbang_allmodels\\\"],\\n reion_plots[\\\"small_scale_def\\\"],\\n reion_plots[\\\"large_scale_def\\\"],\\n model_tags, output_dir,\\n \\\"ps_scales_beta\\\", output_format)\\n\\n\\n\\n if reion_plots[\\\"slices_fixed_XHI\\\"] and rank == 0:\\n print(\\\"Plotting slices at fixed XHI fractions.\\\")\\n reionplot.plot_slices_XHI(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n master_mass_frac, \\n reion_data[\\\"XHII_fbase_allmodels\\\"],\\n reion_data[\\\"XHII_precision_allmodels\\\"],\\n reion_data[\\\"GridSize_allmodels\\\"],\\n reion_data[\\\"boxsize_allmodels\\\"],\\n reion_data[\\\"first_snap_allmodels\\\"],\\n reion_plots[\\\"fixed_XHI_values\\\"],\\n reion_plots[\\\"cut_slice\\\"],\\n reion_plots[\\\"cut_thickness\\\"],\\n model_tags, output_dir, \\\"slices_XHI\\\",\\n output_format)\\n\\n\\n if reion_plots[\\\"bubble_size\\\"] and rank == 0:\\n print(\\\"Determining bubble sizes at fixed XHI.\\\")\\n reionplot.determine_bubble_size(reion_data[\\\"z_array_reion_allmodels\\\"],\\n master_mass_frac,\\n reion_data[\\\"first_snap_allmodels\\\"],\\n reion_data[\\\"GridSize_allmodels\\\"],\\n reion_data[\\\"boxsize_allmodels\\\"],\\n reion_plots[\\\"fixed_XHI_values\\\"],\\n model_tags, output_dir)\\n\\n if reion_plots[\\\"zreion_dens_cross\\\"] and rank == 0:\\n print(\\\"Calculating the zreion-density cross correlation.\\\")\\n k, crosspspec, crosscorr, bias = \\\\\\n zreion_dens_cross(reion_data[\\\"density_fbase_allmodels\\\"],\\n reion_data[\\\"density_precision_allmodels\\\"],\\n reion_data[\\\"zreion_path_allmodels\\\"],\\n reion_data[\\\"GridSize_allmodels\\\"],\\n reion_data[\\\"boxsize_allmodels\\\"],\\n reion_data[\\\"last_snap_allmodels\\\"])\\n\\n reionplot.plot_zreion_dens_cross(k, crosscorr, bias, model_tags,\\n output_dir, \\\"zreion_dens_crosscorr\\\",\\n output_format)\\n\\n if reion_plots[\\\"dens_ion_contours\\\"] and rank == 0:\\n print(\\\"Plotting contours of density-ionization.\\\")\\n reionplot.plot_dens_reion_contours(master_mass_frac,\\n reion_data[\\\"XHII_fbase_allmodels\\\"],\\n reion_data[\\\"XHII_precision_allmodels\\\"],\\n reion_data[\\\"density_fbase_allmodels\\\"],\\n reion_data[\\\"density_precision_allmodels\\\"],\\n reion_data[\\\"GridSize_allmodels\\\"],\\n reion_data[\\\"first_snap_allmodels\\\"],\\n reion_plots[\\\"fixed_XHI_values\\\"],\\n model_tags, output_dir,\\n \\\"dens_ion_contours\\\", output_format)\\n\\n if reion_plots[\\\"dens_zreion_contours\\\"] and rank == 0:\\n print(\\\"Plotting contours of density-zreion.\\\")\\n reionplot.plot_dens_zreion_contours(reion_data[\\\"density_fbase_allmodels\\\"],\\n reion_data[\\\"density_precision_allmodels\\\"],\\n reion_data[\\\"zreion_path_allmodels\\\"],\\n reion_data[\\\"GridSize_allmodels\\\"],\\n reion_data[\\\"last_snap_allmodels\\\"],\\n model_tags, output_dir,\\n \\\"dens_zreion_contours\\\", output_format)\",\n \"def plot_uv(self):\\n self.current_plot = 'uv'\\n self.ax_zoomed = False\\n \\n uu = self.uv.d_uv_data['UU']*1e6\\n vv = self.uv.d_uv_data['VV']*1e6\\n xx = self.uv.d_array_geometry['STABXYZ'][:,0]\\n yy = self.uv.d_array_geometry['STABXYZ'][:,1]\\n pmax, pmin = np.max([uu, vv])*1.1, np.min([uu,vv])*1.1\\n\\n \\n fig = self.sp_fig\\n plt.subplot(121, aspect='equal')\\n ax = plt.plot(xx, yy, 'bo')\\n for i in range(len(xx)):\\n plt.text(xx[i], yy[i], self.uv.d_array_geometry['ANNAME'][i].strip('Stand').strip('Tile'))\\n\\n plt.title(\\\"Antenna positions\\\")\\n plt.xlabel(\\\"X [m]\\\")\\n plt.ylabel(\\\"Y [m]\\\")\\n \\n plt.subplot(122, aspect='equal')\\n ax = plt.plot(uu, vv, 'b.')\\n plt.title(\\\"UV data\\\")\\n plt.xlabel(\\\"UU [$\\\\\\\\mu s$]\\\")\\n plt.ylabel(\\\"VV [$\\\\\\\\mu s$]\\\")\\n plt.xlim(pmin, pmax)\\n plt.ylim(pmin, pmax)\\n return fig, ax\",\n \"def plot_lollipop(clinvar_path_count):\\n os.chdir(\\\"/Users/Files/nogit/generisk/lollipop/figure\\\")\\n app = '/Users/files/work/bin/lollipops'\\n for i in x.itertuples(False, None):\\n # uid, variants, gn\\n os.system(\\\"%s -domain-labels=fit -U %s -o %s.svg %s\\\" % (app, i[0], i[2], i[1]))\\n # os.system(\\\"rsvg-convert %s.svg -o %s_rsvg.png\\\"%(i[2],i[2]))\\n os.system(\\\"convert -density 500 -units pixelsperinch %s.svg %s.png\\\" % (i[2], i[2]))\",\n \"def plot_profiles(self, fig=0, title=''):\\n plot_input.plot_profiles(self, fig, title)\",\n \"def plot_dataset(\\n self,\\n out_dir: str = None,\\n therm_frac: int = 0.,\\n num_chains: int = None,\\n ridgeplots: bool = True,\\n profile: bool = False,\\n ):\\n tdict = {}\\n dataset = self.get_dataset(therm_frac)\\n for key, val in dataset.data_vars.items():\\n t0 = time.time()\\n if np.std(val.values.flatten()) < 1e-2:\\n continue\\n\\n if len(val.shape) == 2: # shape: (chain, draw)\\n val = val[:num_chains, :]\\n\\n if len(val.shape) == 3: # shape: (chain, leapfrogs, draw)\\n val = val[:num_chains, :, :]\\n\\n fig, ax = plt.subplots(constrained_layout=True, figsize=set_size())\\n _ = val.plot(ax=ax)\\n if out_dir is not None:\\n io.check_else_make_dir(out_dir)\\n out_file = os.path.join(out_dir, f'{key}_xrPlot.png')\\n fig.savefig(out_file, dpi=400, bbox_inches='tight')\\n plt.close('all')\\n plt.clf()\\n\\n if profile:\\n tdict[key] = time.time() - t0\\n io.log(f'time spent plotting {key}: {tdict[key]}')\\n\\n if out_dir is not None:\\n out_dir = os.path.join(out_dir, 'ridgeplots')\\n io.check_else_make_dir(out_dir)\\n\\n if ridgeplots:\\n make_ridgeplots(dataset, num_chains=num_chains, out_dir=out_dir)\\n\\n return tdict\",\n \"def plot_rose(ext_data, plot_label=None):\\n result = ext_data.copy(deep=False)\\n sectors = len(result)\\n fig = plt.figure(figsize=(12, 12))\\n ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=True)\\n ax.set_theta_zero_location('N')\\n ax.set_theta_direction(-1)\\n ax.set_thetagrids(np.arange(0, 360, 360.0/sectors))\\n sector_mid_points = []\\n widths = []\\n for i in result.index:\\n angular_pos_start = (np.pi / 180.0) * float(i.split('-')[0])\\n angular_pos_end = (np.pi / 180.0) * float(i.split('-')[-1])\\n if angular_pos_start < angular_pos_end:\\n sector_mid_points.append((angular_pos_start+angular_pos_end)/2.0)\\n widths.append(angular_pos_end-angular_pos_start - (np.pi / 180))\\n else:\\n sector_mid_points.append((np.pi + (angular_pos_start + angular_pos_end)/2.0) % 360)\\n widths.append(2*np.pi - angular_pos_start + angular_pos_end - (np.pi / 180))\\n max_contour = (ext_data.max() + ext_data.std())\\n contour_spacing = max_contour / 10\\n num_digits_to_round = 0\\n while contour_spacing*(10**num_digits_to_round) <= 1:\\n num_digits_to_round += 1\\n if 0.5 < contour_spacing < 1:\\n contour_spacing = 1\\n levels = np.arange(0, max_contour, round(contour_spacing, num_digits_to_round))\\n ax.set_rgrids(levels, labels=[str(i) for i in levels], angle=0)\\n ax.bar(sector_mid_points, result, width=widths, bottom=0.0, color=COLOR_PALETTE.primary,\\n edgecolor=[COLOR_PALETTE.primary_35 for i in range(len(result))], alpha=0.8)\\n ax.legend([plot_label])\\n plt.close()\\n return ax.get_figure()\",\n \"def plotBatch(inp,output='spectra_plot.pdf',comparisons=None,classify=False,normalize=False,normrange=[0.9,1.4],layout=[2,2],basecolors=['k','m'],legend=[],fontscale=0.7,classify_kwargs={},plot_kwargs={},**kwargs):\\n\\n# alt keyword check\\n for k in ['file','filename']: \\n if kwargs.get(k,'') != '': output = kwargs[k]\\n for k in ['legends','labels']: \\n if kwargs.get(k,'') != '': legend = kwargs[k]\\n\\n# force input into a list\\n if isinstance(inp,list): inputlist = copy.deepcopy(inp)\\n else: inputlist = [inp]\\n\\n# if input is a string of filenames, read in each file to a spectrum object\\n if isinstance(inputlist[0],str):\\n# try a glob search string \\n files = glob.glob(os.path.normpath(inputlist[0]))\\n if len(files) > 1 or (len(files) == 1 and inputlist[0].find('*') != -1):\\n inputlist = files\\n# try reading in files into Spectrum object\\n try:\\n splist = [splat.Spectrum(file = f) for f in inputlist]\\n except:\\n raise ValueError('\\\\nCould not read in list of files {} - make sure the full path is specified and the files are correctly formatted'.format(inputlist))\\n\\n# if filenames, read in each file to a spectrum object\\n elif isinstance(inputlist[0],splat.Spectrum):\\n splist = copy.deepcopy(inputlist)\\n else:\\n raise ValueError('\\\\nInput should be list of splat.Spectrum objects or filenames')\\n\\n# normalize if desired\\n if normalize==True:\\n tmp = [sp.normalize(normrange) for sp in splist]\\n\\n# comparison files are present\\n complist = []\\n if comparisons != None:\\n comp = copy.deepcopy(comparisons)\\n if not isinstance(comp,list): comp = [comp]\\n if isinstance(comp[0],str):\\n try:\\n complist = [splat.Spectrum(file = f) for f in comp]\\n except:\\n print('\\\\nCould not read in comparison files: ignoring comparisons')\\n if isinstance(comp[0],splat.Spectrum):\\n complist = comp\\n if len(complist) < len(splist):\\n while len(complist) < len(splist):\\n complist.append(complist[-1])\\n# normalize\\n if normalize==True:\\n tmp = [sp.normalize(normrange) for sp in complist]\\n\\n# set comparison files to be standards for spectral classification\\n# overrules input comparison sample\\n if classify == True:\\n complist = []\\n base_kwargs={\\n 'return_standard': True,\\n 'method': 'kirkpatrick',\\n }\\n base_kwargs.update(classify_kwargs)\\n for sp in splist:\\n complist.append(splat.classifyByStandard(sp,**base_kwargs))\\n\\n# prep for plotting\\n plotlist = []\\n clist = []\\n for i,sp in enumerate(splist):\\n if len(complist) == len(splist):\\n plotlist.append([sp,complist[i]])\\n clist.extend(basecolors)\\n else:\\n plotlist.append([sp])\\n clist.extend(basecolors[0])\\n\\n# manage legends\\n if len(legend) != 0:\\n if not isinstance(legend,list): legend = [legend]\\n if len(legend) < (len(splist)+len(complist)):\\n# guess: just left out the comparison legends \\n if len(complist) > 0 and len(legend) == len(splist):\\n legtmp = []\\n for i,l in enumerate(legend):\\n legtmp.extend([l,'{}'.format(complist[i].name)])\\n legend = legtmp\\n else:\\n# otherwise: pad the remaining legends with the last legend (pairs) \\n while len(legend) < (len(splist)+len(complist)):\\n if len(complist)>0:\\n legend.extend([legend[-2],legend[-1]])\\n else:\\n legend.extend([legend[-1]])\\n if len(legend) > (len(splist)+len(complist)):\\n legend = legend[0:(len(splist)+len(complist))]\\n else:\\n legend = []\\n for i,sp in enumerate(splist):\\n l = []\\n if 'name' in list(sp.__dict__.keys()): l.append(sp.name)\\n else: l.append(os.path.basename(sp.filename))\\n if len(complist)>0:\\n if 'name' in list(complist[i].__dict__.keys()): l.append(complist[i].name)\\n else: l.append(os.path.basename(complist[i].filename))\\n legend.extend(l)\\n\\n# generate plot\\n base_kwargs={\\n 'multiplot': True,\\n 'multipage': True,\\n 'legends': legend,\\n 'colors': clist,\\n 'layout': layout,\\n 'fontscale': fontscale,\\n 'output': output,\\n }\\n base_kwargs.update(plot_kwargs)\\n fig = plotSpectrum(plotlist,**base_kwargs)\\n\\n return fig\",\n \"def multiple(folder_name: str,\\r\\n min_plant_pixels: int = MIN_PLANT_SIZE,\\r\\n output_options = [['rows',\\r\\n 'centers',\\r\\n 'row_ids',\\r\\n 'distances'],\\r\\n \\r\\n ['rows',\\r\\n 'centers',\\r\\n 'row_ids',\\r\\n 'numbers'],\\r\\n \\r\\n ['dirt',\\r\\n 'ditches',\\r\\n 'rows',\\r\\n 'clusters',\\r\\n 'centers',\\r\\n 'row_ids',\\r\\n 'numbers',\\r\\n 'lines']\\r\\n ]) -> None:\\r\\n\\r\\n # Go to the specified folder\\r\\n ls = listdir(folder_name)\\r\\n ls = [join(folder_name, i) for i in ls]\\r\\n\\r\\n # Check if the folder exists\\r\\n if join(folder_name, 'Analysis') in ls:\\r\\n\\r\\n # If it does, rename the old folder\\r\\n new_name = join(folder_name, 'Analysis')\\r\\n while new_name in ls:\\r\\n new_name += '_old'\\r\\n \\r\\n rename(join(folder_name,'Analysis'), new_name)\\r\\n\\r\\n # Create new folders inside the given directory\\r\\n mkdir(join(folder_name, 'Analysis'))\\r\\n mkdir(join(folder_name, 'Analysis/Images'))\\r\\n mkdir(join(folder_name, 'Analysis/Data'))\\r\\n \\r\\n # Gather the images to be analysed\\r\\n co = 0\\r\\n pics = [j for j in ls if isfile(j)]\\r\\n le = len(pics)\\r\\n\\r\\n # Analyze each of the pictures\\r\\n for i in pics:\\r\\n\\r\\n # Make the field\\r\\n field = just_field(i, min_plant_pixels)\\r\\n\\r\\n # Measure the field and save results\\r\\n print('Saving data...\\\\n')\\r\\n ruler = Ruler(field)\\r\\n \\r\\n ruler.output_distances(\\r\\n join(folder_name,\\r\\n 'Analysis/Data/{}_Distances.csv'.format(basename(i).split('.')[0])\\r\\n ) \\r\\n )\\r\\n \\r\\n ruler.output_row_info(\\r\\n join(folder_name,\\r\\n 'Analysis/Data/{}_Rows.csv'.format(basename(i).split('.')[0])\\r\\n )\\r\\n )\\r\\n\\r\\n # Make and save visuals\\r\\n print('Saving pictures...\\\\n')\\r\\n for k in range(len(output_options)):\\r\\n output_options[k]\\r\\n img = field.make_visual(ruler, output_options[k])\\r\\n img.save(\\r\\n join(folder_name,\\r\\n 'Analysis/Images/{}_Visual_{}.png'.format(basename(i).split('.')[0], k + 1)))\\r\\n\\r\\n # Increment the progress meter\\r\\n co += 1\\r\\n print('Completed {}/{} images\\\\n\\\\n'.format(co, le))\",\n \"def main(fpath):\\n\\t# Load results data\\n\\twith open(fpath) as f:\\n\\t\\tlines = f.readlines()\\n\\n\\tresults = []\\n\\tfor line in lines:\\n\\t\\tif not line.startswith(\\\"//\\\"):\\n\\t\\t\\tresults.append(json.loads(line))\\n\\n\\t# Format relevent data\\n\\tresults = sorted(results, key=lambda k: k['data_lens'][\\\"mean\\\"])\\n\\t# x = [np.log(x[\\\"block_lens\\\"][\\\"mean\\\"]) for x in results]\\n\\tx = [x[\\\"data_lens\\\"][\\\"mean\\\"] for x in results]\\n\\ty = [x[\\\"mean\\\"] for x in results]\\n\\tyy = [x[\\\"block_lens\\\"][\\\"mean\\\"] for x in results]\\n\\n\\n\\t# Plot graphs\\n\\tplt.figure(figsize=(14,5))\\n\\tplt.subplot(1,2,1)\\n\\tplt.title('Ratio of Total Block Size to Primary Data Size Against Primary Data Size')\\n\\tplt.ylabel('Total Block Size / Primary Data Size')\\n\\t# plt.xlabel('log( Primary Data Size )')\\n\\tplt.xlabel('Primary Data Size (chars)')\\n\\tplt.plot(x, y)\\n\\n\\tplt.subplot(1,2,2)\\n\\tplt.title('Total Block Size Against Primary Data Size')\\n\\tplt.ylabel('Total Block Size (chars)')\\n\\tplt.xlabel('Primary Data Size (chars)')\\n\\tplt.plot(x, yy)\\n\\n\\n\\tplt.show()\",\n \"def plot_sector_ratio(sec_ratio, wdir, sec_ratio_dist, col_names, boom_dir_1=-1, boom_dir_2=-1):\\n radians = np.radians(utils._get_dir_sector_mid_pts(sec_ratio_dist.index))\\n fig = plt.figure(figsize=(10, 10))\\n ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=True)\\n ax.set_theta_zero_location('N')\\n ax.set_theta_direction(-1)\\n ax.set_thetagrids(utils._get_dir_sector_mid_pts(sec_ratio_dist.index))\\n ax.plot(np.append(radians, radians[0]), sec_ratio_dist['Mean_Sector_Ratio'].append(sec_ratio_dist.iloc[0]),\\n color=COLOR_PALETTE.primary, linewidth=4)\\n # Get max and min levels and set chart axes\\n max_level = sec_ratio_dist['Mean_Sector_Ratio'].max() + 0.05\\n min_level = sec_ratio_dist['Mean_Sector_Ratio'].min() - 0.1\\n ax.set_ylim(min_level, max_level)\\n # Add boom dimensions to chart, if required\\n width = np.pi / 108\\n radii = max_level\\n annotate = False\\n annotation_text = '* Plot generated using '\\n if boom_dir_1 >= 0:\\n boom_dir_1_rad = np.radians(boom_dir_1)\\n ax.bar(boom_dir_1_rad, radii, width=width, bottom=min_level, color=COLOR_PALETTE.fourth)\\n if boom_dir_2 == -1:\\n annotation_text += '{} (top mounted) divided by {} ({}° boom)'.format(col_names[1], col_names[0],\\n boom_dir_1)\\n annotate = True\\n if boom_dir_2 >= 0:\\n boom_dir_2_rad = np.radians(boom_dir_2)\\n ax.bar(boom_dir_2_rad, radii, width=width, bottom=min_level, color=COLOR_PALETTE.fifth)\\n if boom_dir_1 == -1:\\n annotation_text += '{} ({}° boom) divided by {} (top mounted)'.format(col_names[1], boom_dir_2,\\n col_names[0])\\n annotate = True\\n if boom_dir_2 >= 0 and boom_dir_1 >= 0:\\n annotation_text += '{} ({}° boom) divided by {} ({}° boom)'.format(col_names[1], boom_dir_2,\\n col_names[0], boom_dir_1)\\n annotate = True\\n if annotate:\\n ax.annotate(annotation_text, xy=(0.5, 0.035), xycoords='figure fraction', horizontalalignment='center')\\n ax.scatter(np.radians(wdir), sec_ratio, color=COLOR_PALETTE.secondary, alpha=0.3, s=1)\\n plt.close()\\n return ax.get_figure()\",\n \"def run_and_plot(self):\\n self.raw_processing()\\n self.data_averaging_and_cleaning()\\n\\n print(self.organized_names)\\n print(self.organized_film)\\n print(self.organized_plank)\\n\\n height = self.organized_film\\n bars = tuple(self.organized_names.copy())\\n y_pos = np.arange(len(bars))\\n\\n plt.bar(y_pos, height)\\n plt.xticks(y_pos, bars)\\n plt.xlabel('TH% in 100ul water/TH mixture')\\n plt.ylabel('CFU/mL count')\\n plt.title('Experiment 2.5 (Sucrose Concentration) 7 Aug 2018')\\n\\n plt.show()\\n\\n height2 = self.organized_plank\\n\\n plt.bar(y_pos, height2)\\n plt.xticks(y_pos, bars)\\n plt.xlabel('TH% in 100ul water/TH mixture')\\n plt.ylabel('Proportion of Biofilm CFUs to Planktonic CFUs')\\n plt.title('Experiment 2.5 (Sucrose Concentration) 7 Aug 2018')\\n\\n plt.show()\",\n \"def plot_data(\\n self,\\n out_dir: str = None,\\n flags: AttrDict = None,\\n therm_frac: float = 0.,\\n params: AttrDict = None,\\n ):\\n plot_data(self.data, out_dir, flags,\\n therm_frac=therm_frac, params=params)\",\n \"def main():\\n font = {'family' : 'normal',\\n 'weight' : 'normal',\\n 'size' : 18}\\n\\n matplotlib.rc('font', **font)\\n\\n ###Plot overviews\\n\\n# plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\\\"12co_combined_peak_full.png\\\",\\n# show_shells=False,title=r\\\"Combined $^{12}$CO Peak T$_{MB}$\\\",\\n# dist=orion_dist, vmin=None, vmax=None, scalebar_color='white',\\n# scalebar_pc=1.,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325)\\n \\n plot_overview(plotname=\\\"../paper/figs/12co_nroonly_peak_full_shells.png\\\", show_shells=True,\\n dist=orion_dist, vmin=None, vmax=None, scalebar_color='black', scale_factor = 1.,\\n title=r\\\"\\\", shells_highlight=best_shells, circle_style='dotted', circle_linewidth=1.5,\\n scalebar_pc=1. #,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325\\n )\\n\\n # plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\\\"12co_combined_mom0_cometary.png\\\",\\n # show_shells=False, title=r\\\"Combined Integrated $^{12}$CO\\\",\\n # dist=orion_dist, scalebar_color='white', pmax=93., mode='mom0',\\n # scale_factor=1./1000,\\n # scalebar_pc=0.2,recenter=True, ra=83.99191, dec=-5.6611303, radius=0.117325)\\n\\n # plot_overview(plotname=\\\"12co_nroonly_mom0_cometary.png\\\", show_shells=False,\\n # dist=orion_dist, scalebar_color='white', pmax=93., mode='mom0',\\n # scale_factor=1./1000, title=r\\\"NRO Integrated $^{12}$CO\\\",\\n # scalebar_pc=0.2,recenter=True, ra=83.99191, dec=-5.6611303, radius=0.117325)\\n\\n # plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\\\"12co_combined_peak_full_shells.png\\\",\\n # show_shells=True, shells_highlight=shells_score3, title=r\\\"Combined $^{12}$CO Peak T$_{MB}$\\\",\\n # dist=orion_dist, vmin=None, vmax=None, scalebar_color='white', circle_style='dotted',\\n # scalebar_pc=1.,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325)\\n\\n # return\\n\\n mips_l1641_file = '../catalogs/MIPS_L1641a_24um.fits'\\n mips_onc_file = '../catalogs/MIPS_ONC_24um.fits'\\n\\n irac1_l1641_file = '../catalogs/IRAC_L1641_ch1_merged_clean.fits'\\n irac1_onc_file = '../catalogs/IRAC_ONC_ch1_merged_clean.fits'\\n\\n irac2_l1641_file = '../catalogs/IRAC_L1641_ch2_merged_clean.fits'\\n irac2_onc_file = '../catalogs/IRAC_ONC_ch2_merged_clean.fits'\\n\\n irac4_l1641_file = '../catalogs/IRAC_L1641_ch4_merged_clean_northup.fits'\\n irac4_onc_file = '../catalogs/IRAC_ONC_ch4_merged_clean_northup.fits'\\n\\n planck_herschel_file = '../catalogs/planck_herschel.fits'\\n\\n region_file = '../shell_candidates/AllShells.reg'\\n vrange_file = '../shell_candidates/AllShells_vrange.txt'\\n shell_list = get_shells(region_file=region_file, velocity_file=vrange_file)\\n\\n obaf_file = 'stars_obaf.txt'\\n yso_file = \\\"../catalogs/spitzer_orion.fit\\\"\\n\\n obaf = ascii.read(obaf_file)\\n obaf_ra, obaf_dec, obaf_label = np.array(obaf['RA']), np.array(obaf['DEC']), np.array([sp.strip(\\\"b'\\\") for sp in obaf['SP_TYPE']])\\n yso = fits.open(yso_file)[1].data\\n yso_ra, yso_dec, yso_label = yso['RAJ2000'], yso['DEJ2000'], yso['Cl']\\n\\n # for nshell in range(19,43):\\n # shell = shell_list[nshell-1]\\n # ra, dec, radius = shell.ra.value, shell.dec.value, shell.radius.value\\n\\n # #Check whether shell is in each mips image coverage.\\n # l1641_xy = WCS(mips_l1641_hdu).all_world2pix(ra, dec, 0)\\n \\n # if (l1641_xy[0] >= 0) & (l1641_xy[0] <= mips_l1641_hdu.shape[1]) & \\\\\\n # (l1641_xy[1] >= 0) & (l1641_xy[1] <= mips_l1641_hdu.shape[0]):\\n # hdu = mips_l1641_hdu\\n # else:\\n # hdu = mips_onc_hdu\\n\\n # plot_stamp(map=hdu, ra=ra, dec=dec, radius=radius, circle_color='red',\\n # pad_factor=1.5, contour_map=None, contour_levels=5., source_ra=None, source_dec=None, source_lists=None, \\n # source_colors='cyan', plotname='{}shell{}_stamp.png'.format('MIPS',nshell), return_fig=False,\\n # stretch='linear', plot_simbad_sources=False, dist=orion_dist, cbar_label=r'counts',\\n # auto_scale=True, auto_scale_mode='min/max', auto_scale_pad_factor=1., vmin=0, vmax=3000)\\n\\n\\n #cube_file = '../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits'\\n cube_file = '../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits'\\n ir_l1641_hdu = fits.open(irac4_l1641_file)[0]\\n ir_onc_hdu = fits.open(irac4_onc_file)[0]\\n\\n spec_cube = SpectralCube.read(cube_file)\\n ra_grid = spec_cube.spatial_coordinate_map[1].to(u.deg).value\\n dec_grid = spec_cube.spatial_coordinate_map[0].to(u.deg).value\\n vel_grid = spec_cube.spectral_axis\\n pad_factor = 1.5\\n\\n #plot_overview(show_shells=True)\\n #plot_overview(plotname=\\\"12co_nro_peak.png\\\", show_shells=False)\\n #plot_overview(cube=\\\"/Volumes/Untitled/13co_pix_2.cm.fits\\\", plotname=\\\"13co_combined_peak.png\\\", show_shells=False)\\n #return\\n #channel_vmax = [12.9, 14]\\n for nshell in range(17,18):\\n shell = shell_list[nshell-1]\\n ra, dec, radius = shell.ra.value, shell.dec.value, shell.radius.value\\n\\n l1641_xy = WCS(ir_l1641_hdu).wcs_world2pix(ra, dec, 0)\\n #print(l1641_xy)\\n if (l1641_xy[0] >= 0) & (l1641_xy[0] <= ir_l1641_hdu.shape[1]) & \\\\\\n (l1641_xy[1] >= 0) & (l1641_xy[1] <= ir_l1641_hdu.shape[0]):\\n ir_hdu = ir_l1641_hdu\\n else:\\n ir_hdu = ir_onc_hdu\\n\\n #Extract sub_cube around shell.\\n subcube_mask = (abs(ra_grid - ra) < radius * pad_factor) &\\\\\\n (abs(dec_grid - dec) < radius * pad_factor)\\n sub_cube = spec_cube.with_mask(subcube_mask).minimal_subcube().spectral_slab(shell.vmin, shell.vmax)\\n\\n #Integrate between vmin and vmax.\\n mom0_hdu = sub_cube.moment0().hdu\\n\\n # mask_inshell = (abs(ra_grid - ra) < radius) &\\\\\\n # (abs(dec_grid - dec) < radius)\\n # subcube_inshell = spec_cube.with_mask(mask_inshell).minimal_subcube().spectral_slab(shell.vmin, shell.vmax)\\n # mom0_hdu_inshell = subcube_inshell.moment0().hdu\\n\\n #Calculate contour levels.\\n empty_channel = spec_cube.closest_spectral_channel(500*u.Unit('m/s'))\\n sigma = np.nanstd(spec_cube[empty_channel][subcube_mask]).value\\n #print(\\\"sigma: {}\\\".format(sigma))\\n delta_vel = (sub_cube.spectral_extrema[1] - sub_cube.spectral_extrema[0]).value\\n #print(\\\"delta_vel: {}\\\".format(delta_vel))\\n mom0_sigma = sigma * delta_vel\\n #print(mom0_sigma) \\n #contour_levels = np.linspace(5.*mom0_sigma, np.nanmax(mom0_hdu_inshell.data), 12)\\n contour_levels = np.linspace(28.*mom0_sigma, 45.*mom0_sigma, 6 )\\n\\n #Get source coordinates.\\n\\n\\n # plot_stamp(map=ir_hdu, ra=ra, dec=dec, radius=radius, circle_color='red',\\n # pad_factor=pad_factor, contour_map=mom0_hdu, contour_levels=contour_levels, contour_color='white',\\n # plotname='{}shell{}_{}{}to{}_stamp.png'.format('8µm', nshell, \\\"12CO\\\", shell.vmin.value, shell.vmax.value),\\n # return_fig=False,\\n # stretch='linear', plot_simbad_sources=False, dist=orion_dist,\\n # auto_scale=True, auto_scale_mode='median', auto_scale_pad_factor=0.8, auto_scale_nsigma=4.,\\n # cbar_label=\\\"Counts\\\", cmap='inferno',\\n # source_ra=[obaf_ra, yso_ra], source_dec=[obaf_dec, yso_dec],\\n # source_colors=['white', 'red'], source_markers=['*', 'None'], source_sizes=[300,50],\\n # source_labels=[obaf_label, yso_label], dpi=300\\n # )\\n\\n #cube_file = \\\"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\\\"\\n \\n \\n # plot_channels(cube=cube_file, ra=ra, dec=dec, radius=radius,\\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\\n # plotname='12co_channels_shell'+str(nshell)+'.png', chan_step=2, plot_simbad_sources=False,\\n # vmin=None, vmax=None, max_chans=12,\\n # #cbar_label=\\\"Counts\\\",\\n # source_ra=[obaf_ra, yso_ra], source_dec=[obaf_dec, yso_dec],\\n # source_colors=['white', 'red'], source_markers=['*', '+'], source_sizes=[200,15], dpi=300)\\n\\n # angle = 90*u.deg\\n # pv = plot_pv(cube=cube_file, ra_center=shell.ra, dec_center=shell.dec,\\n # vel=[shell.vmin - 1*u.km/u.s, shell.vmax + 1*u.km/u.s], length=shell.radius*4.,\\n # width=7.5*u.arcsec, angle=angle,\\n # pad_factor=1., plotname='12co_pv_shell'+str(nshell)+'_angle'+str(angle.value)+'.png',\\n # stretch='linear', auto_scale=True, dpi=900.)\\n \\n\\n\\n #simbad_brightstars(output='stars_obaf.txt', output_format='ascii', replace_ra='deg')\\n\\n\\n #movie(test=False, labels=False) \\n\\n #cube_file = '../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits'\\n # region_file = '../nro_maps/SouthShells.reg'\\n # N = 2 # Number of shell candidates to plot\\n # shell_list = get_shells(region_file=region_file)\\n\\n # cube_file = \\\"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\\\"\\n # #cube_file = \\\"../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits\\\"\\n\\n # for n in range(1,2):\\n # shell = shell_list[n]\\n # for deg in np.linspace(0, 180, 13):\\n # angle = deg*u.deg\\n # pv = plot_pv(cube=cube_file, ra_center=shell.ra, dec_center=shell.dec,\\n # vel=[4*u.km/u.s, 8*u.km/u.s], length=shell.radius*2.*4.,\\n # width=7.5*u.arcsec, angle=105*u.deg,\\n # pad_factor=1., plotname='12co_pv_shell'+str(n+1)+'_angle'+str(angle.value)+'morev.png', return_subplot=True,\\n # stretch='linear', auto_scale=True)\\n\\n # cube_file = \\\"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\\\"\\n # for n in range(N):\\n # shell = shell_list[n]\\n # plot_channels(cube=cube_file, ra=shell.ra.value, dec=shell.dec.value, radius=shell.radius.value,\\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\\n # plotname='12co_channels_shell'+str(n+1)+'.png', chan_step=2, plot_simbad_sources=True, simbad_color='blue')\\n\\n # cube_file = \\\"../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits\\\"\\n # for n in range(N):\\n # shell = shell_list[n]\\n # plot_channels(cube=cube_file, ra=shell.ra.value, dec=shell.dec.value, radius=shell.radius.value,\\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\\n # plotname='13co_channels_shell'+str(n+1)+'.png', chan_step=2, plot_simbad_sources=True, simbad_color='blue')\",\n \"def cloudy_hii_radial_hyd(props=['ne'],cols=['b'],model_name = '',**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n if p.add:\\n ax = plt.gca()\\n else:\\n fig,ax = plt.subplots(figsize=(8,6))\\n\\n for prop,col in zip(props,cols):\\n hyd = pd.read_table(p.d_cloudy_test + '%s.hyd' % model_name,skiprows=1,\\\\\\n names=['depth','Te','nH','ne','HI/H','HII/H','H2/H','H2+/H','H3+/H','H-/H'])\\n if '/' in prop:\\n try:\\n ax2.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'o',ms=5,color=col)\\n ax2.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'-',lw=1,color=col,label=prop)\\n except:\\n print('no twinx axis, starting a new one')\\n ax2 = ax.twinx()\\n ax2.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'o',ms=5,color=col)\\n ax2.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'-',lw=1,color=col,label=prop)\\n else:\\n ax.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'o',ms=5,color=col)\\n ax.plot(hyd['depth']/c.pc.to('cm'),hyd[prop],'-',lw=1,color=col,label=prop)\\n\\n ax.set_xlabel('Depth [pc]')\\n ax.set_ylabel('cm$^{-3}$')\\n ax.legend()\\n ax2.legend()\\n\\n if p.savefig:\\n if not os.path.isdir(p.d_plot + 'cloudy/'): os.mkdir(p.d_plot + 'cloudy/') \\n plt.savefig(p.d_plot + 'cloudy/%s_hyd.png' % (model_name), format='png', dpi=300, facecolor='w')\",\n \"def plot_alleles(folder):\\n\\n abs_alt,perc_alt = parse_geno_file(folder,False)\\n\\n strain_matcher = re.compile('(.*) \\\\(.*\\\\)') ## regex to get strain name from radio button click\\n strain_matcher2 = re.compile('(.*)-(.*)')\\n \\n fig, ax = plt.subplots()\\n l, = plt.plot(perc_alt['MC'],perc_alt[S],'bs')\\n ax.set_ylabel('Alternate Allele Percentage (MC)')\\n ax.set_xlabel('Alternate Allele Percentage (MC)')\\n \\n rax1 = plt.axes([0.92, 0.1, 0.08, 0.8])\\n radio1 = RadioButtons(rax1, ('MC (Sand)','CL (Sand)','CM (Sand)','CN (Sand)','TI (Sand)','DC (Sand)','MS (Sand)','CV (Sand)','PN (Rock)','AC (Rock)','LF (Rock)','MP (Rock)','MZ (Rock)','Sand-MC','Rock-MC','Sand-MZ','Rock-MZ','Rock-Sand'), active=0)\\n\\n rax2 = plt.axes([0.92, 0.9, 0.08, 0.1])\\n radio2 = RadioButtons(rax2, ('%', 'Abs'), active=0)\\n\\n #for strain in perc_alt.keys():\\n #print strain\\n \\n #ylabel = plt.axes([1,1,0.08,0.08])\\n\\n def update1(strain):\\n if strain not in [\\\"Rock-MZ\\\",\\\"Sand-MC\\\",\\\"Rock-MC\\\",\\\"Sand-MZ\\\",\\\"Rock-Sand\\\"]:\\n match = re.match(strain_matcher,strain)\\n strain = match.group(1)\\n global base\\n base = 'MC'\\n else:\\n match = re.match(strain_matcher2,strain)\\n strain = match.group(1)\\n #global base \\n base = match.group(2)\\n\\n #print D\\n if(D == \\\"%\\\"):\\n l.set_xdata(perc_alt[base])\\n l.set_ydata(perc_alt[strain])\\n ax.set_ylabel('Alternate Allele Percentage (%s)'%(strain))\\n ax.set_xlabel('Alternate Allele Percentage (%s)'%(base))\\n else:\\n l.set_xdata(abs_alt[base])\\n l.set_ydata(abs_alt[strain])\\n ax.set_ylabel('Alternate Allele Absolute (%s)'%(strain))\\n ax.set_xlabel('Alternate Allele Absolute (%s)'%(base))\\n\\n ax.relim()\\n ax.autoscale()\\n fig.canvas.draw_idle()\\n global S \\n #print S\\n S = strain\\n\\n\\n def update2(data):\\n if(data == '%'):\\n l.set_xdata(perc_alt[base])\\n l.set_ydata(perc_alt[S])\\n ax.relim()\\n ax.autoscale()\\n ax.set_ylabel('Alternate Allele Percentage (%s)'%(S))\\n ax.set_xlabel('Alternate Allele Percentage (%s)'%(base))\\n fig.canvas.draw_idle()\\n if(data == 'Abs'):\\n l.set_xdata(abs_alt[base])\\n l.set_ydata(abs_alt[S])\\n ax.relim()\\n ax.autoscale()\\n ax.set_ylabel('Alternate Allele Absolute (%s)'%(S))\\n ax.set_xlabel('Alternate Allele Absolute (%s)'%(base))\\n fig.canvas.draw_idle()\\n \\n global D\\n D = data\\n\\n radio1.on_clicked(update1)\\n radio2.on_clicked(update2)\\n plt.show()\",\n \"def createPrettyPlots(self, inputDir, outputDir, fnExtension = 'png'):\\n number_of_entries_per_row = 4\\n number_of_files_per_column = 2\\n imageWidth = 200 # 1600 org is four times as large\\n imageHeight = 150 # 1200\\n nTmessage(\\\"Updating index files for input directory: %s\\\" % inputDir)\\n if os.path.exists(outputDir):\\n# nTmessage(\\\"Removing output directory: %s\\\" % outputDir)\\n shutil.rmtree(outputDir)\\n # end if\\n# nTmessage(\\\"Creating output directory: %s\\\" % outputDir)\\n os.mkdir(outputDir)\\n# nTdebug(\\\"Doing copyCingHtmlJsAndCssToDirectory\\\")\\n copyCingHtmlJsAndCssToDirectory(outputDir) \\n# htmlDir = os.path.join(cingRoot, \\\"HTML\\\")\\n fnMatchPattern = '*.' + fnExtension\\n image_fn_list = glob(os.path.join(inputDir,fnMatchPattern)) \\n inputDirBase = os.path.basename(inputDir)\\n# nTdebug(\\\"Got relative part of inputDir: %s\\\" % inputDirBase) # e.g. plotTrend\\n image_code_list = []\\n for image_fn in image_fn_list:\\n _root, image_code, _ext = nTpath(image_fn)\\n image_code_list.append(image_code)\\n # end for \\n ## Get the number of files required for building an index\\n number_of_images_all_present = len(image_code_list)\\n number_of_images_per_file = number_of_entries_per_row * number_of_files_per_column\\n ## Number of files with indexes in google style\\n number_of_files = int(number_of_images_all_present / number_of_images_per_file)\\n if number_of_images_all_present % number_of_images_per_file:\\n number_of_files += 1\\n # end if\\n nTmessage(\\\"Creating %s pages for %s image codes\\\" % (number_of_files, number_of_images_all_present))\\n# nTmessage(\\\"Generating %s index html files\\\" % (number_of_files))\\n\\n file_name = os.path.join (self.base_dir, \\\"data\\\", self.results_base, \\\"indexPplot.html\\\")\\n file_content = open(file_name, 'r').read()\\n old_string = r\\\"<!-- INSERT NEW TITLE HERE -->\\\"\\n new_string = capitalizeFirst( inputDirBase )\\n file_content = string.replace(file_content, old_string, new_string)\\n old_string = r\\\"<!-- INSERT NEW FOOTER HERE -->\\\"\\n file_content = string.replace(file_content, old_string, self.htmlFooter)\\n old_string = r\\\"<!-- INSERT GOOGLE ANALYTICS TEMPLATE HERE -->\\\"\\n file_content = string.replace(file_content, old_string, GOOGLE_ANALYTICS_TEMPLATE)\\n old_string = r\\\"<!-- INSERT GOOGLE PLUS ONE TEMPLATE HERE -->\\\"\\n file_content = string.replace(file_content, old_string, GOOGLE_PLUS_ONE_TEMPLATE)\\n ## Count will track the number of entries done per index file\\n images_done_per_file = 0\\n ## Following variable will track all done sofar\\n images_done_all = 0\\n ## Tracking the number in the current row. Set for the rare case that there\\n ## are no entries at all. Otherwise it will be initialize on first pass.\\n num_in_row = 0\\n ## Tracking the index file number\\n file_id = 1\\n ## Text per row in an index file to insert\\n insert_text = ''\\n ## Repeat for all entries plus a dummy pass for writing the last index file\\n for image_code in image_code_list + [ None ]:\\n ## Finish this index file\\n ## The last index file will only be written once...\\n if images_done_per_file == number_of_images_per_file or images_done_all == number_of_images_all_present:\\n begin_image_count = number_of_images_per_file * (file_id - 1) + 1\\n end_image_count = min(number_of_images_per_file * file_id,\\n number_of_images_all_present)\\n# nTdebug(\\\"begin_image_count, end_image_count, number_of_images_all_present: %5d %5d %5d\\\" % (\\n# begin_image_count, end_image_count, number_of_images_all_present))\\n # image_code is just the base name of the file name.\\n new_string = \\\"Images: %s-%s of %s.\\\" % (\\n begin_image_count,\\n end_image_count,\\n number_of_images_all_present\\n )\\n old_string = r\\\"<!-- INSERT NEW RESULT STRING HERE -->\\\" \\n new_file_content = string.replace(file_content, old_string, new_string)\\n # Always end the row by adding dummy columns\\n if num_in_row != number_of_entries_per_row:\\n insert_text += (number_of_entries_per_row - num_in_row) * 2 * r\\\"<td> </td>\\\" + r\\\"</tr>\\\"\\n # end if\\n ## Create the new index file from the example one by replacing a string\\n ## with the new content.\\n old_string = r\\\"<!-- INSERT NEW ROWS HERE -->\\\"\\n new_file_content = string.replace(new_file_content, old_string, insert_text)\\n\\n first_string = '<a href=\\\"index_%s.html\\\">First < <</a>' % 1\\n final_string = '<a href=\\\"index_%s.html\\\">Last > ></a>' % number_of_files\\n prev_string = ''\\n if file_id > 1:\\n prev_string = '<a href=\\\"index_%s.html\\\">Previous <</a>' % ( file_id - 1)\\n # end if\\n next_string = ''\\n if file_id < number_of_files:\\n next_string = '<a href=\\\"index_%s.html\\\">> Next</a>' % ( file_id + 1)\\n # end if\\n first_link = max(1, file_id - number_of_files_per_column)\\n last_link = min(number_of_files, file_id + number_of_files_per_column - 1)\\n links_string = ''\\n for link in range(first_link, last_link + 1):\\n ## List link but don't include a link out for the current file_id\\n if link == file_id:\\n links_string += ' <B>%s</B>' % link\\n else:\\n links_string += ' <a href=\\\"index_%s.html\\\">%s</a>' % (\\n link, link)\\n # end if\\n # end for\\n old_string = r\\\"<!-- INSERT NEW LINKS HERE -->\\\"\\n new_string = 'Result pages: ' + ' '.join([first_string, prev_string, links_string, next_string, final_string])\\n new_file_content = string.replace(new_file_content, old_string, new_string)\\n ## Make the first index file name still index.html\\n new_file_name = os.path.join( outputDir, 'index_%s.html' % file_id)\\n if not file_id:\\n new_file_name = os.path.join( outputDir, '/index.html' )\\n # end if \\n writeTextToFile(new_file_name, new_file_content) \\n images_done_per_file = 0\\n num_in_row = 0\\n insert_text = \\\"\\\"\\n file_id += 1\\n # end for\\n ## Build on current index file\\n ## The last iteration will not execute this block because of this clause\\n if images_done_all < number_of_images_all_present:\\n images_done_all += 1\\n images_done_per_file += 1\\n ## Get the html code right by abusing the formatting chars.\\n ## as in sprintf etc.\\n imageRelUrl = os.path.join( '..', inputDirBase, image_code + '.' + fnExtension)\\n tmp_string = \\\"\\\"\\\"\\n<td> <a href=\\\"%(imageRelUrl)s\\\"> <img SRC=\\\"%(imageRelUrl)s\\\" border=\\\"0\\\" width=\\\"%(imageWidth)s\\\" height=\\\"%(imageHeight)s\\\"> </a> </td>\\\"\\\"\\\" % dict(\\n imageRelUrl=imageRelUrl, imageWidth=imageWidth, imageHeight=imageHeight)\\n num_in_row = images_done_per_file % number_of_entries_per_row\\n if num_in_row == 0:\\n num_in_row = number_of_entries_per_row\\n # end if\\n if num_in_row == 1:\\n # Start new row\\n tmp_string = \\\"\\\\n<tr>\\\" + tmp_string\\n elif (num_in_row == number_of_entries_per_row):\\n # End this row\\n tmp_string = tmp_string + \\\"\\\\n</tr>\\\"\\n # end if\\n insert_text += tmp_string\\n # end if\\n # end if\\n index_file_first = 'index_1.html'\\n index_file = os.path.join(outputDir, 'index.html')\\n ## Assume that a link that is already present is valid and will do the job\\n# nTdebug('Symlinking: %s %s' % (index_file_first, index_file))\\n symlink(index_file_first, index_file)\",\n \"def ex1_plots(instance, destination, prefix, save, animate):\\n \\n plts = ukf_plots(instance, destination, prefix, save, animate)\\n\\n truths = truth_parser(instance)\\n nan_array= nan_array_parser(instance, truths, instance.base_model)\\n #obs, obs_key = obs_parser(instance, True)\\n obs_key = obs_key_parser(instance, True)\\n preds = preds_parser(instance, True)\\n #forecasts = forecasts_parser(instance, True)\\n \\n ukf_params = instance.ukf_params\\n index2 = ukf_params[\\\"index2\\\"]\\n \\n \\\"remove agents not in model to avoid wierd plots\\\"\\n #obs *= nan_array\\n truths *= nan_array\\n preds *= nan_array\\n #forecasts*= nan_array\\n \\n \\\"indices for unobserved agents\\\"\\n not_index2 = np.array([i for i in np.arange(truths.shape[1]) if i not in index2])\\n plts.pair_frame(truths, preds, obs_key, 10, destination)\\n plts.error_hist(truths[::instance.sample_rate,index2], \\n preds[::instance.sample_rate,index2],\\\"Observed Errors\\\")\\n if len(not_index2)>0:\\n plts.error_hist(truths[::instance.sample_rate, not_index2], \\n preds[::instance.sample_rate, not_index2],\\\"Unobserved Errors\\\")\\n \\n #plts.path_plots(obs[::instance.sample_rate] , \\\"Observed\\\")\\n plts.path_plots(preds[::instance.sample_rate], \\\"Predicted\\\")\\n plts.path_plots(truths, \\\"True\\\")\\n #plts.path_plots(forecasts[::instance.sample_rate], \\\"Forecasts\\\")\\n\\n if animate:\\n #plts.trajectories(truths, \\\"plots/\\\")\\n plts.pair_frames(truths, preds, obs_key,\\n truths.shape[0], \\\"../../plots/\\\")\",\n \"def plot_files(n=15):\\n lod = read_files(n)\\n\\n for i in range(len(lod)):\\n plt.plot(range(len(lod[i])), lod[i])\\n\\n plt.show()\",\n \"def plot_training_progress(model_output_path):\\n try:\\n results = load_results(model_output_path)\\n except FileNotFoundError:\\n print('monitor.csv file is not found!')\\n\\n results['l_moving_avg_100'] = results['l'].rolling(window=100).mean()\\n results['r_moving_avg_100'] = results['r'].rolling(window=100).mean()\\n results['t_per_M'] = results['t'] / 1000\\n\\n fig, axs = plt.subplots()\\n results.plot(\\n ax=axs,\\n x='t_per_M', y='r_moving_avg_100',\\n title='Training Progress',\\n xlabel='Million Steps',\\n ylabel='Mean Reward'\\n )\\n return results\",\n \"def plot_Cmd_AngVel_EulerAng(data_fcs, data_vel, data_att, dest_folder=None):\\n \\n # Variables assignment\\n t_fcs = data_fcs[:,0]\\n delta_a = data_fcs[:,18]\\n delta_e = data_fcs[:,6]\\n delta_r = data_fcs[:,9]\\n delta_t = data_fcs[:,20]\\n \\n t_vel = data_vel[:,0]\\n p_rad = data_vel[:,4]\\n q_rad = data_vel[:,5]\\n r_rad = data_vel[:,6]\\n \\n t_att = data_att[:,0]\\n phi_rad = data_att[:,1]\\n the_rad = data_att[:,2]\\n psi_rad = data_att[:,3]\\n \\n fig = plt.figure(figsize=(12.3,15))\\n \\n \\n # Commands\\n ax1a = fig.add_subplot(3,1,1)\\n ax1a.plot(t_fcs, delta_a, ls='solid', color='r', label=r'$\\\\delta_a$')\\n ax1a.plot(t_fcs, delta_e, ls='solid', color='g', label=r'$\\\\delta_e$')\\n ax1a.plot(t_fcs, delta_r, ls='solid', color='b', label=r'$\\\\delta_r$')\\n \\n ax1a.set_title(\\\"Commands\\\") \\n ax1a.set_xlabel(r'$t$ (s)')\\n ax1a.set_ylabel(r'$\\\\delta_a$ , $\\\\delta_e$ , $\\\\delta_r$ (°)')\\n ax1a.set_ylim(ymin=-1+np.floor(min(list(delta_a)+list(delta_e)+list(delta_r))),\\n ymax=1+np.ceil(max(list(delta_a)+list(delta_e)+list(delta_r))))\\n \\n \\n ax1b = ax1a.twinx()\\n ax1b.plot(t_fcs, delta_t, ls='solid', color='0.65', label=r'$\\\\delta_t$')\\n \\n ax1b.set_ylabel(r'$\\\\delta_t$')\\n ax1b.set_ylim(ymax=1, ymin=-0.05)\\n \\n handlesa, labelsa = ax1a.get_legend_handles_labels()\\n handlesb, labelsb = ax1b.get_legend_handles_labels()\\n ax1a.legend(handlesa+handlesb, labelsa+labelsb, ncol=4, loc='best')\\n \\n\\n # Angular velocities\\n ax2 = fig.add_subplot(3,1,2)\\n \\n ax2.plot(t_vel, (180/np.pi)*p_rad, color='r', label=r'$p$')\\n ax2.plot(t_vel, (180/np.pi)*q_rad, color='g', label=r'$q$')\\n ax2.plot(t_vel, (180/np.pi)*r_rad, color='b', label=r'$r$')\\n \\n ax2.set_title(\\\"Angular velocities\\\") \\n ax2.set_xlabel(r'$t$ (s)')\\n ax2.set_ylabel(r'$p$ , $q$ , $r$ (°/s)')\\n \\n handles, labels = ax2.get_legend_handles_labels()\\n ax2.legend(handles, labels, ncol=3, loc='best')\\n \\n \\n # Euler angles\\n ax3a = fig.add_subplot(3,1,3)\\n \\n ax3a.plot(t_att, (180/np.pi)*phi_rad, color='r', label=r\\\"$\\\\phi$\\\")\\n ax3a.plot(t_att, (180/np.pi)*the_rad, color='g', label=r\\\"$\\\\theta$\\\")\\n \\n ax3a.set_title(\\\"Euler angles\\\") \\n ax3a.set_xlabel(r'$t$ (s)')\\n ax3a.set_ylabel(r'$\\\\phi$ , $\\\\theta$ (°)')\\n \\n \\n ax3b = ax3a.twinx()\\n ax3b.plot(t_att, (180/np.pi)*psi_rad, color='b', label=r\\\"$\\\\psi$\\\")\\n \\n ax3b.set_ylabel(r'$\\\\psi$ (°)')\\n \\n handlesa, labelsa = ax3a.get_legend_handles_labels()\\n handlesb, labelsb = ax3b.get_legend_handles_labels()\\n ax3b.legend(handlesa+handlesb, labelsa+labelsb, ncol=3, loc='best')\\n \\n plt.tight_layout()\\n \\n \\n # Export\\n if dest_folder != None:\\n plt.savefig(dest_folder+'plot_Cmd_AngVel_EulerAng.pdf')\",\n \"def do_jet_pt_plots(tree, output_dir, cut=''):\\n for logz, normx in product([True, False], [True, False]):\\n make_2d_plot(tree, 'httL1', HTT_L1_STR, NB_HTT, HTT_MIN, HTT_MAX, 'pt', PT_L1_STR, NB_PT, PT_MIN, PT_MAX,\\n os.path.join(output_dir, 'pt_httL1.pdf'), logz=logz, normx=normx,\\n cut=cut, title=TITLE, diagonal_line=True)\\n make_2d_plot(tree, 'httL1', HTT_L1_STR, NB_HTT, HTT_MIN, HTT_MAX, 'ptRef', PT_REF_STR, NB_PT, PT_MIN, PT_MAX,\\n os.path.join(output_dir, 'ptRef_httL1.pdf'), logz=logz, normx=normx,\\n cut=cut, title=TITLE, diagonal_line=True)\\n make_2d_plot(tree, 'httRef', HTT_REF_STR, NB_HTT, HTT_MIN, HTT_MAX, 'pt', PT_L1_STR, NB_PT, PT_MIN, PT_MAX,\\n os.path.join(output_dir, 'pt_httRef.pdf'), logz=logz, normx=normx,\\n cut=cut, title=TITLE, diagonal_line=True)\\n make_2d_plot(tree, 'httRef', HTT_REF_STR, NB_HTT, HTT_MIN, HTT_MAX, 'ptRef', PT_REF_STR, NB_PT, PT_MIN, PT_MAX,\\n os.path.join(output_dir, 'ptRef_httRef.pdf'), logz=logz, normx=normx,\\n cut=cut, title=TITLE, diagonal_line=True)\",\n \"def plot_balance_list_output(balance_list, path, nframes=4):\\n import matplotlib\\n font = {'size' : 15, 'weight': 'normal'}\\n matplotlib.rc('font', **font)\\n\\n nplots=len(balance_list)\\n ncols=2\\n nrows=int(np.ceil(nframes/ncols))\\n _, axes = plt.subplots(nrows, ncols, figsize=(25, 5*nrows))\\n for n in range(nframes):\\n i = int(np.floor(n / ncols))\\n j=n % ncols\\n r_p = []\\n for k in range(len(balance_list[n])-1):\\n r_p.append(np.abs(balance_list[n][k]-balance_list[n][k+1])/balance_list[n][k])\\n\\n axes[i,j].plot(balance_list[n], label='balance', color='b')\\n axes[i,j].set_title('Outer loop # '+ str(n))\\n # axes[i,j].set_yscale('log')\\n # axes[i,j].set_xscale('log')\\n axes[i,j].grid(True)\\n axes[i,j].set_ylabel('Balance norm')\\n # axes[i,j].legend()\\n axes[i,j].set_ylim([0, 10])\\n # ax_2=axes[i,j].twinx()\\n # ax_2.plot(r_p, 'g')\\n # ax_2.set_yscale('log')\\n # ax_2.set_ylabel('relative change')\\n\\n plt.savefig(path,transparent=True, dpi=400)\",\n \"def plot_overview(cube=nro_12co,\\n region_file='../shell_candidates/AllShells.reg', mode='peak', plotname='12co_peak_shells.png',\\n interactive=False, show_shells=True, shells_highlight=None, dist=orion_dist, vmin=None, vmax=None,\\n scalebar_color=\\\"white\\\", scalebar_pc = 1., scale_factor=1., pmin=0.25,\\n pmax=99.75, cbar_label=r\\\"Peak T$_{\\\\rm MB}$ [K]\\\",\\n circle_color='white', circle_linewidth=1, circle_style=\\\"solid\\\", return_fig=False, show=True,\\n title=r\\\"$^{12}$CO Peak T$_{MB}$\\\", recenter=False, ra=None, dec=None, radius=None):\\n try:\\n cube = SpectralCube.read(cube)\\n except ValueError:\\n pass\\n\\n if mode == \\\"peak\\\":\\n image = (cube.max(axis=0) * scale_factor).hdu\\n \\n\\n if mode == \\\"mom0\\\":\\n image = (cube.moment0() * scale_factor).hdu\\n\\n\\n\\n fig = FITSFigure(image)\\n if show:\\n fig.show_colorscale(cmap='viridis', vmin=vmin, vmax=vmax, pmin=pmin,\\n pmax=pmax, interpolation='none')\\n fig.tick_labels.set_yformat(\\\"dd:mm\\\")\\n fig.tick_labels.set_xformat(\\\"hh:mm\\\")\\n #fig.hide_yaxis_label()\\n #fig.hide_ytick_labels()\\n plt.title(title)\\n plt.xlabel(\\\"RA (J2000)\\\")\\n plt.ylabel(\\\"DEC (J2000)\\\")\\n\\n if show_shells:\\n shell_list = get_shells(region_file=region_file)\\n for i, shell in enumerate(shell_list):\\n if shells_highlight:\\n if i+1 in shells_highlight:\\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle='solid', edgecolor=circle_color,\\n facecolor='none', linewidth=3)\\n else:\\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle=circle_style, edgecolor=circle_color,\\n facecolor='none', linewidth=circle_linewidth)\\n else:\\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle=circle_style, edgecolor=circle_color,\\n facecolor='none', linewidth=circle_linewidth)\\n\\n #RECENTER\\n if recenter:\\n fig.recenter(ra, dec, radius)\\n\\n\\n #SCALEBAR\\n fig.add_scalebar(206265 * scalebar_pc / (dist.to(u.pc).value * 3600), color=scalebar_color)\\n fig.scalebar.set_label(\\\"{} pc\\\".format(scalebar_pc))\\n\\n fig.add_colorbar()\\n cb = fig.colorbar\\n cb.set_axis_label_text(cbar_label)\\n\\n if return_fig:\\n return fig\\n else:\\n fig.save(plotname, dpi=600)\",\n \"def basic_stats_and_plots():\\n \\n basename = sys.argv[1]\\n ops = (\\\"two_opt\\\", \\\"twoh_opt\\\", \\\"three_opt\\\", \\\"three_opt_broad\\\", \\\"swap\\\", \\\"swap_adj\\\")\\n opfs = {\\n \\\"two_opt\\\": tsp.two_opt,\\n \\\"twoh_opt\\\": tsp.twoh_opt,\\n \\\"three_opt\\\": tsp.three_opt,\\n \\\"three_opt_broad\\\": tsp.three_opt_broad,\\n \\\"swap\\\": tsp.swap_two,\\n \\\"swap_adj\\\": tsp.swap_adj\\n }\\n \\n lengths = range(6, 11)\\n for length in lengths:\\n stddev = []\\n gini = []\\n nneighbours = []\\n prop_unique = []\\n for op in ops:\\n filename = os.path.join(basename,\\n \\\"tsp_length_%d_%s\\\" % (length, op),\\n \\\"TP_row0.dat\\\")\\n print op, length\\n x = np.genfromtxt(filename)\\n # stats to get:\\n stddev.append(np.std(x))\\n gini.append(random_walks.gini_coeff(x))\\n nneighbours.append(np.sum(x > 0))\\n mu, sigma = rw_experiment_with_op(length, opfs[op])\\n prop_unique.append((mu, sigma))\\n\\n gini_barchart(length, gini, ops)\\n stddev_barchart(length, stddev, ops)\\n plot_gini_v_nneighbours(length, gini, nneighbours, ops)\\n plot_stddev_v_nneighbours(length, stddev, nneighbours, ops)\\n plot_gini_v_prop_unique(length, gini, prop_unique, ops)\\n plot_stddev_v_prop_unique(length, stddev, prop_unique, ops)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77768505","0.69358486","0.6893516","0.6873988","0.6526698","0.62730706","0.61070305","0.6070563","0.6070449","0.5956038","0.5923547","0.5919201","0.5887804","0.5874542","0.5859539","0.58339554","0.5830068","0.58292556","0.5784595","0.5765463","0.57374895","0.57303447","0.5716146","0.5670726","0.5642362","0.563532","0.5625996","0.5623595","0.561812","0.5617648","0.5607168","0.5605671","0.5597418","0.5585267","0.5579868","0.55750036","0.5573499","0.556152","0.5557731","0.5551387","0.5540348","0.5539002","0.5537704","0.5528813","0.5524984","0.55229145","0.55221224","0.55203414","0.5519005","0.55077","0.5498151","0.54953307","0.5492744","0.54900074","0.54884106","0.5487497","0.5486338","0.54678154","0.54622513","0.5450708","0.5447351","0.544547","0.5438171","0.5423321","0.5423225","0.5420166","0.54191387","0.54165024","0.54130524","0.5411816","0.54076314","0.54026645","0.54006475","0.5384616","0.5378671","0.5366795","0.5366687","0.536605","0.5362122","0.5353845","0.53527397","0.5352232","0.5344992","0.53316015","0.5323427","0.53174025","0.53162956","0.53091174","0.5307539","0.53050065","0.5302314","0.5298295","0.5294585","0.5289216","0.52870154","0.5285496","0.52832603","0.5279203","0.5272577","0.5270607"],"string":"[\n \"0.77768505\",\n \"0.69358486\",\n \"0.6893516\",\n \"0.6873988\",\n \"0.6526698\",\n \"0.62730706\",\n \"0.61070305\",\n \"0.6070563\",\n \"0.6070449\",\n \"0.5956038\",\n \"0.5923547\",\n \"0.5919201\",\n \"0.5887804\",\n \"0.5874542\",\n \"0.5859539\",\n \"0.58339554\",\n \"0.5830068\",\n \"0.58292556\",\n \"0.5784595\",\n \"0.5765463\",\n \"0.57374895\",\n \"0.57303447\",\n \"0.5716146\",\n \"0.5670726\",\n \"0.5642362\",\n \"0.563532\",\n \"0.5625996\",\n \"0.5623595\",\n \"0.561812\",\n \"0.5617648\",\n \"0.5607168\",\n \"0.5605671\",\n \"0.5597418\",\n \"0.5585267\",\n \"0.5579868\",\n \"0.55750036\",\n \"0.5573499\",\n \"0.556152\",\n \"0.5557731\",\n \"0.5551387\",\n \"0.5540348\",\n \"0.5539002\",\n \"0.5537704\",\n \"0.5528813\",\n \"0.5524984\",\n \"0.55229145\",\n \"0.55221224\",\n \"0.55203414\",\n \"0.5519005\",\n \"0.55077\",\n \"0.5498151\",\n \"0.54953307\",\n \"0.5492744\",\n \"0.54900074\",\n \"0.54884106\",\n \"0.5487497\",\n \"0.5486338\",\n \"0.54678154\",\n \"0.54622513\",\n \"0.5450708\",\n \"0.5447351\",\n \"0.544547\",\n \"0.5438171\",\n \"0.5423321\",\n \"0.5423225\",\n \"0.5420166\",\n \"0.54191387\",\n \"0.54165024\",\n \"0.54130524\",\n \"0.5411816\",\n \"0.54076314\",\n \"0.54026645\",\n \"0.54006475\",\n \"0.5384616\",\n \"0.5378671\",\n \"0.5366795\",\n \"0.5366687\",\n \"0.536605\",\n \"0.5362122\",\n \"0.5353845\",\n \"0.53527397\",\n \"0.5352232\",\n \"0.5344992\",\n \"0.53316015\",\n \"0.5323427\",\n \"0.53174025\",\n \"0.53162956\",\n \"0.53091174\",\n \"0.5307539\",\n \"0.53050065\",\n \"0.5302314\",\n \"0.5298295\",\n \"0.5294585\",\n \"0.5289216\",\n \"0.52870154\",\n \"0.5285496\",\n \"0.52832603\",\n \"0.5279203\",\n \"0.5272577\",\n \"0.5270607\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6287042"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":21292,"cells":{"query":{"kind":"string","value":"Plot profiles for each output/step0X folder on same figure"},"document":{"kind":"string","value":"def plot_directory_profiles(path, outname=None, show=True, xscale=1, yscale=1,\n xval='x', adjustRadial=True):\n outdirs = np.sort(os.listdir(path))\n plt.figure()\n\n #labels=['homogeneous','1D layering', '3D tomography'] #xscale=1e-3, yscale=1e2\n for i,outdir in enumerate(outdirs):\n pointsFile = os.path.join(path, outdir, 'points.h5')\n #print(pointsFile)\n #x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile, output='cyl',adjustRadial=adjustRadial)\n #x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile)\n #Load data\n\n x,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n #Y = uz / yscale\n if xval == 'x':\n X = x / xscale\n Y1 = ux / yscale\n elif xval == 'r':\n X = np.hypot(x,y) / xscale\n ur_fem = np.hypot(ux,uy)\n Y1 = ur_fem / yscale\n if adjustRadial: #fix sign from hypot square root\n ur_fem = pu.radial2negative(Y1)\n\n x_fem = X #/ xscale #double scaling!\n ur_fem = Y1 #/ yscale\n uz_fem = uz / yscale\n\n #print(pointsFile)\n print(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max())\n\n l, = plt.plot(x_fem,uz_fem,'.-',lw=3,label=outdir)\n #l, = plt.plot(x_fem,uz_fem,'.-',lw=2,label=labels[i]) #for 3d heterogeneity example\n plt.plot(x_fem,ur_fem,'.--',lw=3, mfc='w',color=l.get_color()) #mfc='none' transparent\n\n # Annotate\n plt.axhline(color='k',lw=0.5)\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n plt.legend()\n\n #NOTE: custom annotations for 3d heterogeneity\n #plt.title('Elastic Heterogeneity Effects')\n #plt.legend([l1,l2,l3],['homogeneous','1D layering', '3D tomography'])\n\n if outname: plt.savefig(outname)\n if show: plt.show()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def plot_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2014/output',\n\t\t\t\tsteps=['step01','step02'],\n\t\t\t\t#labels='',\n\t\t\t\tshow=True,\n\t\t\t\txscale=1e3,\n\t\t\t\tyscale=1e-2):\n\tplt.figure()\n\t#path = '/Users/scott/Desktop/elastic'\n\n\t# Deep source\n\t#labels = ['no APMB', 'APMB']\n\t#if labels == '':\n\tlabels = steps\n\tdeep = {}\n\t#uzmax = 0.824873455364\n\t# NOT sure why hardcoded...\n\tuzmax = 1\n\tfor i,outdir in enumerate(steps):\n\t\tpointsFile = os.path.join(path, outdir, 'points.h5')\n\t\tprint(pointsFile)\n\t\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n\n\t\tX = x / xscale\n\t\tY1 = ux / yscale\n\n\t\tx_fem = X #/ xscale #double scaling!\n\t\tur_fem = Y1 #/ yscale\n\t\tuz_fem = uz / yscale\n\n\t\t#print(pointsFile)\n\t\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\n\n\t\t#normalize\n\t\tuz_fem = uz_fem / uzmax\n\t\tur_fem = ur_fem / uzmax\n\t\tx_fem = x_fem / 30.0\n\n\t\tl, = plt.plot(x_fem,uz_fem,'o-',ms=4,lw=4,label=labels[i])\n\t\tplt.plot(x_fem,ur_fem,'o--',ms=4,lw=4,color=l.get_color()) #mfc='none' transparent\n\t\tdeep[outdir] = uz_fem/uz_fem\n\n\t'''\n\t# Shallow Source\n\tshallow = {}\n\tuzmax = 0.949652827795\n\tfor i,outdir in enumerate(['step11','step12']):\n\t\tpointsFile = os.path.join(path, outdir, 'points.h5')\n\n\t\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n\n\t\tX = x / xscale\n\t\tY1 = ux / yscale\n\n\t\tx_fem = X #/ xscale #double scaling!\n\t\tur_fem = Y1 #/ yscale\n\t\tuz_fem = uz / yscale\n\n\t\t#print(pointsFile)\n\t\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\n\n\t#normalize\n\tuz_fem = uz_fem / uzmax\n\tur_fem = ur_fem / uzmax\n\tx_fem = x_fem / 20.0\n\n\t\tl, = plt.plot(x_fem,uz_fem,'.-', mfc='w', lw=4,label=labels[i])\n\t\tplt.plot(x_fem,ur_fem,'.--',lw=4, mfc='w',color=l.get_color()) #mfc='none' transparent\n\n\t\tshallow[outdir] = uz_fem/ur_fem\n\t'''\n\n\t# Annotate\n\tplt.axhline(color='k',lw=0.5)\n\t#plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n\t#plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n\tplt.legend()\n\tplt.grid()\n\t#plt.ylim(-0.5, 3.5)\n\t#plt.savefig('deep.png',bbox_inches='tight')\n\t#plt.savefig('shallow.png',bbox_inches='tight')\n\n\t# normalized\n\tplt.ylim(-0.5, 4)\n\tplt.xlim(0,10)\n\tplt.xlabel('Normalized Radial Distance [R / D]')\n\tplt.ylabel('Normalized Displacement [U / Uz_max]')\n\t#plt.savefig('normalized_deep.png',bbox_inches='tight')\n\tplt.savefig('normalized_shallow.png',bbox_inches='tight')\n\n\n\t# Plot ratios of uz versus NOTE: this plot is confusing,,, just keep ratio of uz_max to ur_max\n\t'''\n\tplt.figure()\n\tplt.plot(x_fem, deep['step01'], label='Deep no APMB')\n\tplt.plot(x_fem, deep['step02'], label='Deep w/ APMB')\n\tplt.plot(x_fem, shallow['step11'], label='Shallow no APMB')\n\tplt.plot(x_fem, shallow['step12'], label='Shallow w/ APMB')\n\tplt.xlabel('Distance [km]') #NOTE: maybe plot normailzed X-axis (R-d)\n\t#plt.xlabel('Normalized Distance [R/d]')\n\tplt.ylabel('Ratio [Uz/Ur]')\n\tplt.title('Ratio of vertical to radial displacement')\n\tplt.legend()\n\tplt.show()\n\t'''","def plot(profiler, outdir):\n # go through the outputs of all morphisms\n for cur_name, cur_output in profiler.profile.items():\n cur_outdir = os.path.join(outdir, cur_name)\n if not os.path.exists(cur_outdir):\n os.makedirs(cur_outdir)\n\n ProfilePlotter.plot_morphism_output(cur_output, cur_outdir)","def run_plots(self):\n # load the files\n self.pre_dark_file = os.path.join(self.input_dir, 'step_lastframe.fits')\n self.post_dark_file = os.path.join(self.input_dir, 'step_dark_current.fits')\n self.jump_file = os.path.join(self.input_dir, 'step_jump.fits')\n self.rate_file = os.path.join(self.input_dir, 'step_rate.fits')\n self.ramp_file = glob.glob(os.path.join(self.input_dir, '*.fits'))[0]\n\n # plots\n self.plot_jump_flags_image()\n self.plot_groupdq_flags(pixel=[884, 550])\n self.plot_ramps_pre_post_correction(pixel=[884, 550])","def plot_morphism_output(data, outdir):\n\n # show the distributions for each variable separately\n for col in data.columns:\n ProfilePlotter._plot_1d(data[col], outfile = os.path.join(outdir, col + \".pdf\"))\n\n # later, maybe also show 2d plots etc.","def plot_profiles(self, fig=0, title=''):\n plot_input.plot_profiles(self, fig, title)","def plot_directory_numex(path, vals, param='density', outname=None, show=True,\n xscale=1e-3,yscale=1e2):\n #vals = arange(2300.0, 2800.0, 50.0)\n outdirs = np.sort(os.listdir(path))\n plt.figure()\n\n # Plot surface profiles for each parameter\n for val,outdir in zip(vals,outdirs):\n pointsFile = os.path.join(path, outdir, 'points.h5')\n print(pointsFile)\n x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile, output=True, adjustRadial=True)\n x_fem = x_fem / xscale\n ur_fem = ur_fem / yscale\n uz_fem = uz_fem / yscale\n l, = plt.plot(x_fem,uz_fem,'.-',label=str(val))\n plt.plot(x_fem,ur_fem,'.-',color=l.get_color())\n\n # Annotate\n plt.axhline(color='k') #zero displacement line\n plt.title(param)\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n plt.legend()\n\n if outname: plt.savefig(outname)\n if show: plt.show()","def create_plots(self):\n if not os.path.exists(self.output_folder):\n os.makedirs(self.output_folder)\n self.sse_plot()\n self.avg_sse_plot()","def make_plots(self):\n import os\n os.system('rm schelling*.png')\n file_name = 'schelling_000.png'\n title = 'Initial Population'\n self.plot(title=title, file_name=file_name)\n n_unhappy = 999\n counter = 0\n while n_unhappy > 0 and counter < 100:\n counter += 1\n print counter\n n_unhappy = self.move_unhappy()\n file_name = 'schelling_%03g.png'%(counter)\n title = 'Step %03g'%(counter)\n self.plot(title=title, file_name=file_name)","def plot_one_directory(args, dirnames, figname):\n logdir = args.logdir\n num = len(ATTRIBUTES)\n fig, axes = subplots(num, figsize=(13,4*num))\n\n for (dd, cc) in zip(dirnames, COLORS):\n A = np.genfromtxt(join(logdir, dd, 'log.txt'), \n delimiter='\\t', \n dtype=None, \n names=True)\n x = A['Iterations']\n\n for (i,attr) in enumerate(ATTRIBUTES):\n axes[i].plot(x, A[attr], '-', lw=lw, color=cc, label=dd)\n axes[i].set_ylabel(attr, fontsize=ysize)\n axes[i].tick_params(axis='x', labelsize=tick_size)\n axes[i].tick_params(axis='y', labelsize=tick_size)\n axes[i].legend(loc='best', ncol=2, prop={'size':legend_size})\n\n axes[0].set_ylim([-10,10])\n axes[1].set_ylim([-10,10])\n axes[2].set_ylim([0,10])\n axes[3].set_ylim([0,10])\n\n plt.tight_layout()\n plt.savefig(figname)","def ex1_plots(instance, destination, prefix, save, animate):\n \n plts = ukf_plots(instance, destination, prefix, save, animate)\n\n truths = truth_parser(instance)\n nan_array= nan_array_parser(instance, truths, instance.base_model)\n #obs, obs_key = obs_parser(instance, True)\n obs_key = obs_key_parser(instance, True)\n preds = preds_parser(instance, True)\n #forecasts = forecasts_parser(instance, True)\n \n ukf_params = instance.ukf_params\n index2 = ukf_params[\"index2\"]\n \n \"remove agents not in model to avoid wierd plots\"\n #obs *= nan_array\n truths *= nan_array\n preds *= nan_array\n #forecasts*= nan_array\n \n \"indices for unobserved agents\"\n not_index2 = np.array([i for i in np.arange(truths.shape[1]) if i not in index2])\n plts.pair_frame(truths, preds, obs_key, 10, destination)\n plts.error_hist(truths[::instance.sample_rate,index2], \n preds[::instance.sample_rate,index2],\"Observed Errors\")\n if len(not_index2)>0:\n plts.error_hist(truths[::instance.sample_rate, not_index2], \n preds[::instance.sample_rate, not_index2],\"Unobserved Errors\")\n \n #plts.path_plots(obs[::instance.sample_rate] , \"Observed\")\n plts.path_plots(preds[::instance.sample_rate], \"Predicted\")\n plts.path_plots(truths, \"True\")\n #plts.path_plots(forecasts[::instance.sample_rate], \"Forecasts\")\n\n if animate:\n #plts.trajectories(truths, \"plots/\")\n plts.pair_frames(truths, preds, obs_key,\n truths.shape[0], \"../../plots/\")","def initial_plots(runs):\n for run in runs.keys():\n meta = runs[run]\n plot_pdfs(meta)\n plot_priorsamps(meta)\n plot_ivals(meta)\n# if meta.truNz is not None:\n# plot_true(meta)\n timesaver(meta,'iplot',meta.key)","def plot(model, results, filename):\n\n # c = model.compartments.get_one(id='c')\n #\n # rna_1 = model.species_types.get_one(id='rna_1').species.get_one(compartment=c)\n # rna_2 = model.species_types.get_one(id='rna_2').species.get_one(compartment=c)\n # rna_3 = model.species_types.get_one(id='rna_3').species.get_one(compartment=c)\n #\n pops = results.get('populations')\n time = pops.index\n pop_rna_1 = pops['rna_1[c]']\n pop_rna_2 = pops['rna_2[c]']\n pop_rna_3 = pops['rna_3[c]']\n\n pop_atp = pops['atp[c]']\n pop_gtp = pops['gtp[c]']\n pop_utp = pops['ctp[c]']\n pop_ctp = pops['utp[c]']\n\n pop_amp = pops['amp[c]']\n pop_gmp = pops['gmp[c]']\n pop_ump = pops['cmp[c]']\n pop_cmp = pops['ump[c]']\n\n print(pop_rna_1, pop_atp, pop_gtp, pop_utp, pop_ctp)\n\n fig1, axes1 = pyplot.subplots(nrows=3, ncols=1)\n\n axes1[0].plot(time / 3600, pop_rna_1)\n axes1[0].plot(time / 3600, pop_rna_2)\n axes1[0].plot(time / 3600, pop_rna_3)\n axes1[0].set_xlim((time[0] / 3600, time[-1] / 3600))\n axes1[0].set_ylim((0., 10.0))\n axes1[0].legend(loc='upper right')\n\n axes1[1].plot(time / 3600, pop_atp)\n axes1[1].plot(time / 3600, pop_gtp)\n axes1[1].plot(time / 3600, pop_utp)\n axes1[1].plot(time / 3600, pop_ctp)\n axes1[1].set_xlim((time[0] / 3600, time[-1] / 3600))\n # axes1[1].set_ylim((0., 10.0))\n axes1[1].legend(loc='upper right')\n\n axes1[2].plot(time / 3600, pop_amp)\n axes1[2].plot(time / 3600, pop_gmp)\n axes1[2].plot(time / 3600, pop_ump)\n axes1[2].plot(time / 3600, pop_cmp)\n axes1[2].set_xlim((time[0] / 3600, time[-1] / 3600))\n # axes1[2].set_ylim((0., 10.0))\n axes1[2].legend(loc='upper right')\n\n fig1.savefig(filename.format('species'))\n pyplot.close(fig1)","def plot_parcles_run(k, v):\n\n L.info(f'Received Input: {v}')\n\n L.info(f\"Plotting results from: {v['filepath']}\")\n\n plotpath = Path(__file__).parent.parent / 'plots'\n filename = v['id'] + '.png'\n plotfile = str(plotpath / filename) \n\n plotTrajectoriesFile(v['filepath'], mode='2d', show_plt=False)\n f = plt.gcf()\n f.savefig(plotfile)\n\n L.info(f'Saved plot to: {plotfile}')","def generate_plots(path):\n videos = glob(path + '/*.mkv')\n print(path, len(videos), videos)\n\n if len(videos) == 0:\n return\n else:\n videos = videos[0]\n\n metadata_list = glob(path + '/metadata.txt')\n #print(path, len(metadata_list), metadata_list)\n\n if len(metadata_list) == 0:\n return \n\n P = Preprocessor()\n P.import_video(str(videos))\n P.read_metadata(path)\n P.preprocess()\n Im = P.frames_processed\n if len(Im) == 0:\n print(len(Im))\n return\n\n z_start = P.z_start\n z_end = P.z_end\n\n mean, cov = analyze_image(Im)\n\n window_size = 10\n mean_smoothed = smoothing.mean_moving_average(mean, window_size)\n cov_smoothed = smoothing.cov_moving_average(cov, window_size)\n\n c = CubicFitRotated()\n c.fit(mean=mean_smoothed, cov=cov_smoothed, z_start=z_start, z_end=z_end)\n\n try:\n os.mkdir(path + '/analysis')\n path += '/analysis'\n except OSError:\n pass\n\n\n plots.plot_mean(mean, z_start, z_end).savefig(path + '/beam_center.png')\n plots.plot_beta(cov, z_start, z_end).savefig(path + '/sigma_squared.png')\n\n export.export_mean(mean = mean, filename = path + '/center.csv', z_start = z_start, z_end = z_end)\n export.export_cov(cov = cov, filename = path + '/cov.csv', z_start = z_start, z_end = z_end)\n\n plt.close('all')","def plot_sample(self):\n print(u'plot_sample()')\n data_set = self.data_sets[1]\n scenario = u'Greedy Search'\n titles = [u'Collaborative Filtering', u'Content-based']\n fig, axes = plt.subplots(1, 2, figsize=(10, 5))\n for i, rec_type in enumerate(data_set.missions):\n graph = data_set.folder_graphs + rec_type + '_' + str(15) + u'.txt'\n for strategy in Strategy.strategies:\n m = data_set.missions[rec_type][graph][strategy][scenario]\n m.compute_stats()\n ppl.plot(axes[i], np.arange(STEPS_MAX + 1),\n m.stats, label=strategy, linewidth=2)\n axes[i].set_xlabel(u'#Hops')\n axes[i].set_ylabel(u'Success Ratio')\n axes[i].set_ylim(0, 85)\n axes[i].set_xlim(0, STEPS_MAX * 1.01)\n axes[i].set_title(titles[i])\n ppl.legend(axes[i], loc=0)\n\n\n # plt.suptitle(u'Greedy Search on the BookCrossing for N=15',\n # size='xx-large', x=0.5)\n fig.subplots_adjust(left=0.08, right=0.97, top=0.9)\n\n plt.savefig('plots/sample.png')\n plt.savefig('plots/sample.pdf')","def plot_visualization(path_results, x_data, y_data, variant_mode, nb_classes, signal_test, args):\n\n\t#path_tsne = path_results + \"/Visualization/train/\" + str(args.step) + \"_2d.csv\"\n\t#data_frame = pd.read_csv(path_tsne)\n\t\n\tpath_maping = path_results + \"/Maping/\" + str(args.subject).split(\".txt\")[0] + \"/\"\n\tfilename = path_maping + \"maping_\" + str(args.step) + \"_\" + str(args.subject).split(\".txt\")[0] + \"_stick\" + str(args.stick) + \".png\"\n\n\tprint(\"path_save maping\", path_maping)\n\n\tif not os.path.exists(path_maping):\n\t\tos.makedirs(path_maping)\n\n\t#print(\"path_tsne\", path_tsne)\n\n\tlabel_maping = np.array([10])\n\n\tx_data = np.concatenate((x_data,signal_test),axis=0)\n\ty_data = np.concatenate((y_data,label_maping),axis=0)\n\n\tprint(\"x_data concatenate\",x_data.shape)\n\tprint(\"y_data concatenate\",y_data.shape)\n\n\tdata_frame = tsne_2d(x_data, y_data)\n\n\t\n\t\n\tgroups = data_frame.groupby('label')\n\n\tcluster_names, cluster_colors = get_target_names_dr(nb_classes, args.mode, args, variant_mode)\n\n\tfig = plt.figure(figsize=(20, 10))\n\tax = fig.add_subplot(111)\n\tax.margins(0.05) # Optional, just adds 5% padding to the autoscaling\n\tfor name, group in groups:\n\t\t\n\t\tif cluster_names[name] == str(args.subject):\n\t\t\tax.scatter(group.x, group.y, marker='D', s=150, edgecolors = 'face',label=cluster_names[name], color=cluster_colors[name])\n\t\telse:\n\t\t\tax.scatter(group.x, group.y, marker='o', label=cluster_names[name], color=cluster_colors[name])\n\n\tax.legend(numpoints=1) #show legend with only 1 point\n\tplt.savefig(filename) #save the plot","def plot(data, filenames, game, destination, num_interplt):\n if isinstance(filenames, str):\n plt.plot(data[:,0], data[:,1], label=filenames)\n ax = plt.gca()\n ax.xaxis.get_major_formatter().set_powerlimits((0,1))\n plt.xlabel('# of steps')\n plt.ylabel('Cumulative reward')\n plt.title('{}'.format(game))\n plt.legend()\n figname = '{}_{}.png'.format(game, datetime_random_str())\n plt.savefig('{}/{}'.format(destination, figname))\n print('Images saved as {}/{}'.format(destination, figname))\n plt.close()\n else:\n print('{} results have been found.'.format(len(filenames)))\n agents = []\n for i in range(len(filenames)):\n # :-24 is to remove the previous datetime string\n # :-30 is to remove the train label\n agents.append(filenames[i][:-30])\n uni_agents = np.unique(np.array(agents))\n print('Game result from agent: {}'.format(uni_agents))\n fig = plt.figure()\n for agent in uni_agents:\n i_data = []\n for i in range(len(agents)):\n if agent == agents[i]:\n i_data.append(data[i])\n i_data = calculate_interpolation(np.array(i_data), num_interplt)\n plot_mean_standard_error(i_data, agent)\n plt.legend()\n ax = plt.gca()\n ax.xaxis.get_major_formatter().set_powerlimits((0,1))\n plt.xlabel('# of steps')\n plt.ylabel('Cumulative reward')\n plt.title('{}'.format(game))\n figname = '{}_{}.png'.format(game, datetime_random_str())\n plt.savefig('{}/{}'.format(destination, figname))\n plt.close()\n print('Images saved as {}/{}'.format(destination, figname))","def plot_pipeline(differences_dir, plots_dir_intonation, num_quantiles = 31):\n perf_list = ['54363310_1939750539', '540791114_1793842568']\n difference_path_list = [os.path.join(differences_dir, perf_list[i] + \".npy\") for i in range(len(perf_list))]\n comparisons_list = [np.load(path) for _, path in enumerate(difference_path_list)]\n num_samples = 10000\n # quantile indices\n q_indices = (np.linspace(0, 1, num_quantiles)*(num_samples-1)).astype(np.int32)\n plt.style.use('ggplot')\n labels = ['perf. A', 'perf. B']\n colors = ['blue', 'red']\n linestyles = ['dotted', 'dashed']\n grid = plt.GridSpec(2, 2)\n ax1 = plt.subplot(grid[1, 0])\n ax2 = plt.subplot(grid[1, 1])\n ax4 = plt.subplot(grid[0, :])\n ax4.plot(comparisons_list[0], color=colors[0], label=labels[0], linestyle=linestyles[0])\n ax4.plot(comparisons_list[1], color=colors[1], label=labels[1], linestyle=linestyles[1])\n ax4.set_title(\"Difference between MIDI and pYIN, two performances\")\n ax4.set_ylabel(\"Cents\")\n ax4.set_xlabel(\"Frames\")\n ax4.axhline(y=200, linestyle=\"solid\", linewidth=0.7, c=\"black\", zorder=2, label=\"thresh.\")\n ax4.axhline(y=-200, linestyle=\"solid\", linewidth=0.7, c=\"black\", zorder=2)\n ax4.legend(loc=\"upper right\")\n ax1.set_title(\"10k random sample of distances\")\n ax1.set_ylabel(r\"$|$Cents$|$\")\n ax1.set_xlabel(\"Frames sorted by distance\")\n ax2.set_title(\"Sample quantiles\")\n ax2.set_xlabel(\"Quantile indices\")\n # run analysis song by song\n for i, arr in enumerate(comparisons_list):\n # random sample so all arrays have the same size\n samples = np.random.choice(arr, num_samples, replace=True)\n # sort\n samples = np.sort(np.abs(samples))\n # discard the high values (might be due to misalignment, etc...)\n samples = samples[samples <= 200]\n samples = np.random.choice(samples, num_samples, replace=True)\n samples = np.sort(np.abs(samples))\n ax1.plot(samples, color=colors[i], linestyle=linestyles[i], label=labels[i])\n # get the quantiles\n samples = samples[q_indices]\n ax2.plot(samples, color=colors[i], linestyle=linestyles[i], label=labels[i])\n ax1.legend()\n ax2.legend()\n plt.tight_layout()\n plt.savefig(os.path.join(plots_dir_intonation, \"data processing pipeline.eps\"), format=\"eps\")\n plt.show()","def plot(path, subjects):\n transformToXYZmm = np.array([[-3.125, 0, 0, 81.250], [0, 3.125, 0, -115.625], [0, 0, 6, -54.000], [0, 0, 0, 1.000]])\n data = data_load.load_data(path, subjects)\n dimx = int(data[0][\"meta\"][\"dimx\"][0])\n dimy = int(data[0][\"meta\"][\"dimy\"][0])\n dimz = int(data[0][\"meta\"][\"dimz\"][0])\n coordToCol = data[0][\"meta\"][\"coordToCol\"][0][0]\n images = {}\n max_val = 0\n voxels = np.load(\"data/general_selected_500_1.npy\")\n directory = os.listdir(\"data/input/\")\n bar = pyprind.ProgBar(len(directory), title='Info extraction and Image Building')\n bar2 = pyprind.ProgBar(len(images.keys()), title='Saving Pictures')\n for file in directory:\n file_name = \"data/input/{}\".format(file)\n fh = open(file_name)\n activation_values = np.asarray(list(map(lambda x: float(x), filter(lambda x: x != '', fh.read().split(\",\")))))\n fh.close()\n plot_matrix = np.zeros((dimx, dimy, dimz))\n for x in range(dimx):\n for y in range(dimy):\n for z in range(dimz):\n indice = coordToCol[x][y][z]\n if indice != 0:\n if indice in list(voxels):\n voxel_indice = list(voxels).index(indice)\n value = activation_values[voxel_indice]\n if abs(value) > max_val:\n max_val = abs(value)\n plot_matrix[x][y][z] = value\n image = nib.Nifti1Image(plot_matrix, transformToXYZmm)\n images[file_name] = image\n bar.update(force_flush=True)\n print(bar)\n for image in images:\n plotting.plot_glass_brain(images[image], display_mode='ortho', vmax=max_val, plot_abs=False, threshold=None, colorbar=True, output_file=\"{}-wom1.png\".format(image))\n bar2.update(force_flush=True)\n print(bar2)","def app_SN_plot_all_active_sample(self, sample_list: List, phases):\n\n for sample in sample_list:\n sample_name = sample['sample_name']\n print(f'processing: {sample_name}')\n dfs, phase_dirs, sizer_val, styler_val = self.preprocessing_before_plotting(sample, phases=phases)\n\n self.app_SN_combined_master(dfs, phase_dirs, sizer_val, styler_val)\n self.app_SN_combined_temperature_series(dfs, phase_dirs, sizer_val, styler_val)\n self.app_SN_combined_temperature_gradient(dfs, phase_dirs, sizer_val, styler_val)\n self.app_SN_combined_moisture_series(dfs, phase_dirs, sizer_val, styler_val)\n self.app_SN_combined_moisture_gradient(dfs, phase_dirs, sizer_val, styler_val)\n self.app_SN_combined_series_moist_vs_temp(dfs, phase_dirs, sizer_val, styler_val)\n self.app_SN_separate_temperature_series(dfs, phase_dirs, sizer_val, styler_val)\n self.app_SN_separate_temperature_gradient(dfs, phase_dirs, sizer_val, styler_val)\n self.app_SN_separate_moisture_series(dfs, phase_dirs, sizer_val, styler_val)\n self.app_SN_separate_moisture_gradient(dfs, phase_dirs, sizer_val, styler_val)\n self.app_SN_separate_series_moist_vs_temp(dfs, phase_dirs, sizer_val, styler_val)\n self.app_SN_last_24h_plots(dfs, phase_dirs, sizer_val, styler_val)\n self.app_SN_hot_end_temperature(dfs, phase_dirs, sizer_val, styler_val)","def save_plots(self):\n pdir = os.path.splitext(self.filename)[0] + '_plots'\n if not os.path.exists(pdir):\n os.mkdir(pdir)\n\n for ii in range(self.uv.n_ant):\n fig, ax = self.plot_single_baseline_dual_pol(ii+1, ii+1)\n print \"Saving ant %i\"%ii\n plt.savefig(os.path.join(pdir, 'ant-%i.png'%ii))\n plt.clf()","def compare_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2013/output',\n\t\t\t\tsteps=['step01','step02'],\n\t\t\t\t#labels='',\n\t\t\t\tshow=True,\n\t\t\t\txscale=1e3,\n\t\t\t\tyscale=1e-2):\n\tplt.figure()\n\t#path = '/Users/scott/Desktop/elastic'\n\n\t# Deep source\n\tlabels = ['no APMB', 'APMB']\n\tdeep = {}\n\tuzmax = 0.824873455364\n\t# NOT sure why hardcoded...\n\tuzmax = 1\n\tfor i,outdir in enumerate(steps):\n\t\tpointsFile = os.path.join(path, outdir, 'points.h5')\n\n\t\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n\n\t\tX = x / xscale\n\t\tY1 = ux / yscale\n\n\t\tx_fem = X #/ xscale #double scaling!\n\t\tur_fem = Y1 #/ yscale\n\t\tuz_fem = uz / yscale\n\n\t\t#print(pointsFile)\n\t\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\n\n\t\t#normalize\n\t\tuz_fem = uz_fem / uzmax\n\t\tur_fem = ur_fem / uzmax\n\t\tx_fem = x_fem / 30.0\n\n\t\tl, = plt.plot(x_fem,uz_fem,'o-',ms=4,lw=4,label=labels[i])\n\t\tplt.plot(x_fem,ur_fem,'o--',ms=4,lw=4,color=l.get_color()) #mfc='none' transparent\n\t\tdeep[outdir] = uz_fem/uz_fem\n\n\n\t# Shallow Source\n\tshallow = {}\n\tuzmax = 0.949652827795 # Why?\n\tfor i,outdir in enumerate(['step11','step12']):\n\t\tpointsFile = os.path.join(path, outdir, 'points.h5')\n\n\t\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n\n\t\tX = x / xscale\n\t\tY1 = ux / yscale\n\n\t\tx_fem = X #/ xscale #double scaling!\n\t\tur_fem = Y1 #/ yscale\n\t\tuz_fem = uz / yscale\n\n\t\t#print(pointsFile)\n\t\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\n\n\t\t#normalize\n\t\tuz_fem = uz_fem / uzmax\n\t\tur_fem = ur_fem / uzmax\n\t\tx_fem = x_fem / 20.0\n\n\t\tl, = plt.plot(x_fem,uz_fem,'.-', mfc='w', lw=4,label=labels[i])\n\t\tplt.plot(x_fem,ur_fem,'.--',lw=4, mfc='w',color=l.get_color()) #mfc='none' transparent\n\n\t\tshallow[outdir] = uz_fem/ur_fem\n\n\t# Annotate\n\tplt.axhline(color='k',lw=0.5)\n\t#plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n\t#plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n\tplt.legend()\n\tplt.grid()\n\t#plt.ylim(-0.5, 3.5)\n\t#plt.savefig('deep.png',bbox_inches='tight')\n\t#plt.savefig('shallow.png',bbox_inches='tight')\n\n\t# normalized\n\tplt.ylim(-0.5, 4)\n\tplt.xlim(0,10)\n\tplt.xlabel('Normalized Radial Distance [R / D]')\n\tplt.ylabel('Normalized Displacement [U / Uz_max]')\n\t#plt.savefig('normalized_deep.png',bbox_inches='tight')\n\tplt.savefig('normalized_shallow.png',bbox_inches='tight')\n\n\n\t# Plot ratios of uz versus NOTE: this plot is confusing,,, just keep ratio of uz_max to ur_max\n\t'''\n\tplt.figure()\n\tplt.plot(x_fem, deep['step01'], label='Deep no APMB')\n\tplt.plot(x_fem, deep['step02'], label='Deep w/ APMB')\n\tplt.plot(x_fem, shallow['step11'], label='Shallow no APMB')\n\tplt.plot(x_fem, shallow['step12'], label='Shallow w/ APMB')\n\tplt.xlabel('Distance [km]') #NOTE: maybe plot normailzed X-axis (R-d)\n\t#plt.xlabel('Normalized Distance [R/d]')\n\tplt.ylabel('Ratio [Uz/Ur]')\n\tplt.title('Ratio of vertical to radial displacement')\n\tplt.legend()\n\tplt.show()\n\t'''","def plot_results(dir_path):\n results, labels, dx = get_results_labels(dir_path)\n\n colors = plt.cm.get_cmap('tab10', len(labels)+1)\n fig = plt.figure(figsize=(16, 9))\n for i, (label, result) in enumerate(zip(labels, results)):\n plt.plot(np.arange(result.shape[1]) * dx, np.mean(result, 0),\n color=colors(i), linewidth=2, label=label)\n plt.fill_between(np.arange(len(result[0])) * dx,\n np.mean(result, 0) - np.std(result, 0),\n np.mean(result, 0) + np.std(result, 0),\n alpha=0.25, color=colors(i))\n plt.title('Training Performance of Different Algorithms', fontsize=25)\n plt.ylabel('Cumulative return', fontsize=20)\n plt.xlabel('Steps', fontsize=20)\n plt.xlim([0, results[0].shape[1] * dx])\n plt.tick_params(labelsize=15)\n plt.ticklabel_format(axis='both', style='sci', scilimits=(-2, 2))\n plt.legend(fontsize=20)\n plt.grid(linestyle=':')\n plt.show()\n\n return fig","def generate_images(self, model, test_input, step, dst_dir):\n prediction = model(test_input)\n\n plt.figure(figsize=(12, 12))\n display_list = [test_input[0], prediction[0]]\n title = ['Input Image', 'Predicted Image']\n\n for i in range(2):\n plt.subplot(1, 2, i+1)\n plt.title(title[i])\n # getting the pixel values between [0, 1] to plot it.\n plt.imshow(display_list[i] * 0.5 + 0.5)\n plt.axis('off')\n filename = os.path.join(dst_dir, 'generated_imgs_at_step_{:06d}.png'.format(step))\n plt.savefig(filename)","def make_plots(self):\n n_rounds = self.run.n_rounds\n\n log.info('Making %d frames', n_rounds)\n args = [self._get_for_parallel(i) for i in range(n_rounds)]\n self.lbv.map(_plot_helper, args)","def _step_plot_closure(self, step_number):\n for image_name, image, clean_net_output in zip(self.images_names, self.images, self.clean_nets_outputs):\n plot_image_grid(image_name + \"_watermark_clean_{}\".format(step_number),\n [np.clip(torch_to_np(self.watermark_net_output), 0, 1),\n np.clip(torch_to_np(clean_net_output), 0, 1)])\n plot_image_grid(image_name + \"_learned_image_{}\".format(step_number),\n [np.clip(torch_to_np(self.watermark_net_output) * torch_to_np(self.mask_net_output) +\n (1 - torch_to_np(self.mask_net_output)) * torch_to_np(clean_net_output),\n 0, 1), image])","def visualize(self, paths, instance, during_analysis):\r\n xvalues = np.arange(self.data.shape[0])\r\n\r\n model_data = self.model_data_from_instance(instance=instance)\r\n\r\n residual_map = self.data - model_data\r\n chi_squared_map = (residual_map / self.noise_map) ** 2.0\r\n\r\n \"\"\"The visualizer now outputs images of the best-fit results to hard-disk (checkout `visualizer.py`).\"\"\"\r\n plot_profile_1d(\r\n xvalues=xvalues,\r\n profile_1d=self.data,\r\n title=\"Data\",\r\n ylabel=\"Data Values\",\r\n color=\"k\",\r\n output_path=paths.image_path,\r\n output_filename=\"data\",\r\n )\r\n\r\n plot_profile_1d(\r\n xvalues=xvalues,\r\n profile_1d=model_data,\r\n title=\"Model Data\",\r\n ylabel=\"Model Data Values\",\r\n color=\"k\",\r\n output_path=paths.image_path,\r\n output_filename=\"model_data\",\r\n )\r\n\r\n plot_profile_1d(\r\n xvalues=xvalues,\r\n profile_1d=residual_map,\r\n title=\"Residual Map\",\r\n ylabel=\"Residuals\",\r\n color=\"k\",\r\n output_path=paths.image_path,\r\n output_filename=\"residual_map\",\r\n )\r\n\r\n plot_profile_1d(\r\n xvalues=xvalues,\r\n profile_1d=chi_squared_map,\r\n title=\"Chi-Squared Map\",\r\n ylabel=\"Chi-Squareds\",\r\n color=\"k\",\r\n output_path=paths.image_path,\r\n output_filename=\"chi_squared_map\",\r\n )","def walkplot(cons):\n # Call always after cons.runn()!\n if not hasattr(cons, \"outplot\"):\n print(\"Consortium must run before analyzing the output of the run!\")\n return\n global plt\n if not plt:\n import matplotlib.pyplot as plt\n\n # keep original inputs\n original_metplots = dcp(cons.mets_to_plot)\n original_outplot = dcp(cons.outplot)\n cons.outplot = \"tmp.png\"\n mets = [k for k in cons.media]\n # loop over metabolites, plot them and let the user close the window\n for m in range(0, len(mets), 4):\n cons.mets_to_plot = [mets[m], mets[m + 1], mets[m + 2], mets[m + 3]]\n plot_comm(cons)\n plt.show()\n print(\"Image number\", m / 4)\n\n # clean temporary files, return to orginal parameters\n plt.close(\"all\")\n os.remove(cons.outplot)\n cons.mets_to_plot = original_metplots\n cons.outplot = original_outplot\n return","def save_plot(epoch_num, step, rewards, filepath):\n fig, ax = plt.subplots() \n ax.plot(range(0, epoch_num + 1, step), rewards)#,'.')\n ax.plot(range(0, epoch_num + 1, step), np.ones(len(range(0, epoch_num + 1, step)))*rewards[0], 'r')\n fig.savefig(filepath)\n plt.close(fig) # close the figure ","def main():\n import argparse\n import os\n parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n parser.add_argument('--dirs', help='List of log directories', nargs='*', default=['./log'])\n parser.add_argument('--num_timesteps', type=int, default=int(10e6))\n parser.add_argument('--xaxis', help='Varible on X-axis', default=X_TIMESTEPS)\n parser.add_argument('--task_name', help='Title of plot', default='Breakout')\n args = parser.parse_args()\n args.dirs = [os.path.abspath(folder) for folder in args.dirs]\n plot_results(args.dirs, args.num_timesteps, args.xaxis, args.task_name)\n plt.show()","def multi_plot(self, plottitle, gof_fileroot, indir, outdir,\n legends, num_stations):\n # Pick components and labels\n xtick_loc = XTICK_LOC_0_01\n xtick_label = XTICK_LABEL_0_01\n\n # Initialize data arrays\n periods = [[] for _ in range(len(gof_fileroot))]\n bias = [[] for _ in range(len(gof_fileroot))]\n m90 = [[] for _ in range(len(gof_fileroot))]\n p90 = [[] for _ in range(len(gof_fileroot))]\n sigma = [[] for _ in range(len(gof_fileroot))]\n sigma0 = [[] for _ in range(len(gof_fileroot))]\n\n bias_l = [[] for _ in range(len(gof_fileroot))]\n bias_h = [[] for _ in range(len(gof_fileroot))]\n conf_l = [[] for _ in range(len(gof_fileroot))]\n conf_h = [[] for _ in range(len(gof_fileroot))]\n\n # Read data from all input files\n for compnum in xrange(0, len(gof_fileroot)):\n filenamebase = os.path.join(indir, gof_fileroot[compnum])\n #print(\"Reading component files %s.*\" % (filenamebase))\n periods[compnum], bias[compnum] = self.read_data(\"%s.bias\" %\n (filenamebase),\n 0.01)\n periods[compnum], m90[compnum] = self.read_data(\"%s.m90\" %\n (filenamebase),\n 0.01)\n periods[compnum], p90[compnum] = self.read_data(\"%s.p90\" %\n (filenamebase),\n 0.01)\n periods[compnum], sigma[compnum] = self.read_data(\"%s.sigma\" %\n (filenamebase),\n 0.01)\n periods[compnum], sigma0[compnum] = self.read_data(\"%s.sigma0\" %\n (filenamebase),\n 0.01)\n\n # Compute bias and conf interval lower/upper bounds\n for i in xrange(0, len(bias[compnum])):\n bias_l[compnum].append(bias[compnum][i] - sigma0[compnum][i])\n bias_h[compnum].append(bias[compnum][i] + sigma0[compnum][i])\n conf_l[compnum].append(m90[compnum][i])\n conf_h[compnum].append(p90[compnum][i])\n\n num_periods = len(periods[0])\n for comp in periods:\n if len(comp) != num_periods:\n print(\"Number of data points unequal across components\")\n return\n\n # Construct baseline\n baseline = [0.0 for _ in periods[0]]\n\n # Find max, min values\n min_x = min([min(comp) for comp in periods])\n max_x = max([max(comp) for comp in periods])\n min_y = MIN_Y_AXIS\n max_y = MAX_Y_AXIS\n\n # Start plots\n num_plots = len(gof_fileroot)\n # Make 1 column of \"num_plots\" rows\n fig, axs = pylab.plt.subplots(num_plots, 1)\n # Set plot dims\n fig.set_size_inches(6, 10)\n\n #subplots_adjust(left=0.125)\n #subplots_adjust(right=0.9)\n #subplots_adjust(top=0.85)\n fig.subplots_adjust(hspace=0.4)\n fig.subplots_adjust(wspace=0.5)\n\n # Add subplots in a list\n subfigs = []\n for idx in range(0, num_plots):\n subfigs.append(axs[idx])\n\n # Now walk through each subfig\n for (subfig, subplot_title, cur_period,\n cur_bias, cur_bias_h, cur_bias_l,\n cur_conf_h, cur_conf_l) in zip(subfigs,\n legends,\n periods,\n bias,\n bias_h,\n bias_l,\n conf_h,\n conf_l):\n subfig.set_xlim(min_x, max_x)\n subfig.set_ylim(min_y, max_y)\n subfig.set_title(\"%s\" % subplot_title, size=10)\n subfig.plot(cur_period, cur_bias, color='red', label='_nolegend_')\n subfig.fill_between(cur_period, cur_bias_h,\n cur_bias_l, color='cyan',\n label='_nolegend_')\n subfig.fill_between(cur_period, cur_conf_h,\n cur_conf_l, color='yellow',\n label='_nolegend_')\n subfig.plot(cur_period, baseline, color='grey',\n label='_nolegend_')\n # Only put xlabel on bottom plot\n if legends.index(subplot_title) == len(gof_fileroot) - 1:\n subfig.set_xlabel(\"Period (sec)\", size=8)\n subfig.set_ylabel(\"ln (data/model)\", size=8)\n subfig.set_xscale('log')\n # Old way to do it\n # subfig.set_xticks(xtick_loc, xtick_label)\n subfig.set_xticks(xtick_loc)\n subfig.set_xticklabels(xtick_label)\n subfig.tick_params(labelsize=8)\n subfig.minorticks_on()\n\n fig.suptitle('%s\\nNumber of stations: %d' % (plottitle, num_stations),\n size=12)\n # Figure out output filename\n outfile = gof_fileroot[0]\n outfile = outfile[:outfile.rfind(\"-\")]\n outfile = os.path.join(outdir, \"gof-%s.png\" % (outfile))\n print(\"==> Created GoF plot: %s\" % (outfile))\n fig.savefig(outfile, format=\"png\",\n transparent=False, dpi=plot_config.dpi)\n pylab.close()","def plot_model(model, inputs, outputs, tss=90):\n mdl = np.load(model)\n sys = ss(mdl['A'], mdl['B'], mdl['C'], mdl['D'],1)\n gain_matrix = dcgain(sys).T\n num_i = len(inputs)\n num_o = len(outputs)\n fig, axs = plt.subplots(num_i,num_o, figsize=(3*len(outputs), 2*len(inputs)), facecolor='w', edgecolor='k')\n fig.suptitle('Step responce: '+model)\n T = np.arange(tss)\n for idx_i in range(num_i):\n for idx_o in range(num_o):\n ax = axs[idx_i][idx_o]\n t,y_step = step_response(sys,T, input=idx_i, output=idx_o)\n gain = round(gain_matrix[idx_i][idx_o],4)\n ax.plot(t, y_step,color='r')\n if idx_i == 0:\n ax.set_title(outputs[idx_o], rotation='horizontal', ha='center', fontsize=10)\n if idx_o == 0:\n ax.set_ylabel(inputs[idx_i], rotation=90, fontsize=10)\n ax.grid(color='k', linestyle='--', linewidth=0.5)\n ax.tick_params(axis='x', colors='red',size=0,labelsize=4)\n ax.tick_params(axis='y', colors='red',size=0,labelsize=4)\n ax.annotate(str(gain),xy=(.72,.8),xycoords='axes fraction')\n # fig.tight_layout()\n plt.show()","def combine_plot(qa_out_path,brain_path):\n \n #Get the scan volume of the brain.\n brain_ref = nib.load(brain_path)\n brain_ref_shape = brain_ref.shape[0:3]\n \n plots_list = ['Rotate_Z_axis_000000.png','Rotate_Z_axis_000001.png','Rotate_Z_axis_000002.png',\n 'Rotate_Y_axis_000000.png','Rotate_Y_axis_000001.png','Rotate_Y_axis_000002.png',\n 'Rotate_X_axis_000000.png','Rotate_X_axis_000001.png','Rotate_X_axis_000002.png']\n y_labels = [\"Rotate with Z axis\",\"Rotate with Y axis\",\"Rotate with X axis\"]\n x_labels = [\"angle=0\",\"angle=120\",\"angle=240\"]\n \n #Temporary list to store the image nparray:\n im_arr=[] \n \n fig= plt.figure()\n plt.title(f'QA_tractography. Scan volume = {brain_ref_shape} \\n\\n', fontsize=60,fontweight='bold')\n plt.xticks([])\n plt.yticks([])\n plt.axis(\"off\")\n\n j = 0\n for i in range(9):\n #Load in the nine images into a nparray one by one.\n im_arr = np.array(Image.open(qa_out_path + \"/\" + plots_list[i]))\n #Change the background of the image into black:\n im_arr = np.where(im_arr<=0.01, 255, im_arr) \n ax = fig.add_subplot(3,3,i+1)\n ax.imshow(im_arr,interpolation=\"none\",alpha=0.9)\n \n #Set the X labels and Y labels\n if i<3:\n ax.set_title(x_labels[i],fontsize=60,fontweight='bold')\n if i % 3 == 0:\n ax.set_ylabel(y_labels[j],fontsize=60,fontweight='bold')\n j = j + 1\n plt.xticks([])\n plt.yticks([])\n \n fig.set_size_inches(40, 40, forward = True)\n fig.savefig(qa_out_path + \"/\" + 'qa_tractography.png', format='png')\n\n #Delete the Nine images which used to generate the qa_tractography.png \n for plot in plots_list:\n if os.path.exists(qa_out_path + \"/\" + plot):\n os.remove(qa_out_path + \"/\" + plot)\n else:\n print('No such file generated from streamlines window. Please check if the streamline.trk files is generated from the pipeline correctly or not')","def analyse_plots(plot_dict, data_dict) :\n for component in [ '_x', '_y' ] :\n z_pos = array.array( 'd' )\n trans_pos = array.array( 'd' )\n errors = array.array( 'd' )\n zeros = array.array( 'd' )\n\n plot = plot_dict['beam_positions'+component]\n\n for i in range( plot.GetXaxis().GetNbins()+2 ) :\n projection = plot.ProjectionY( \\\n 'profile'+component+'_pro_'+str(i), i, i )\n if projection.GetEntries() == 0 :\n continue\n\n pro_mean, pro_mean_err, pro_std, pro_std_err = \\\n scifi.fit_gaussian( projection )\n\n errors.append( pro_mean_err )\n trans_pos.append( pro_mean )\n z_pos.append( data_dict['station_positions'][ i-6 ] )\n zeros.append(0.0)\n\n position_graph = ROOT.TGraphErrors( len(zeros), z_pos, trans_pos, \\\n zeros, errors )\n position_graph.SetName('beam_profile'+component)\n plot_dict['beam_profile'+component] = position_graph\n\n profile_x = plot_dict['beam_profile_x']\n profile_y = plot_dict['beam_profile_y']\n\n up_x_func = ROOT.TF1( \"up_fit_x\", \"pol1\", -5000.0, 0.0 )\n up_y_func = ROOT.TF1( \"up_fit_y\", \"pol1\", -5000.0, 0.0 )\n down_x_func = ROOT.TF1( \"down_fit_x\", \"pol1\", 0.0, 5000.0 )\n down_y_func = ROOT.TF1( \"down_fit_y\", \"pol1\", 0.0, 5000.0 )\n\n up_fit_x = profile_x.Fit( 'up_fit_x', \"QSR\" )\n up_fit_y = profile_y.Fit( 'up_fit_y', \"QSR\" )\n down_fit_x = profile_x.Fit( 'down_fit_x', \"QSR\" )\n down_fit_y = profile_y.Fit( 'down_fit_y', \"QSR\" )\n\n plot_dict['beam_profile_x_up_fit'] = up_x_func\n plot_dict['beam_profile_y_up_fit'] = up_y_func\n plot_dict['beam_profile_x_down_fit'] = down_x_func\n plot_dict['beam_profile_y_down_fit'] = down_y_func\n\n\n up_beam_gra_x = up_x_func.GetParameter(1)\n up_beam_gra_x_err = up_x_func.GetParError(1)\n up_beam_gra_y = up_y_func.GetParameter(1)\n up_beam_gra_y_err = up_y_func.GetParError(1)\n\n up_beam_pos_x = data_dict['station_positions'][-1]*up_beam_gra_x + up_x_func.GetParameter(0)\n up_beam_pos_x_err = up_x_func.GetParError(0)\n up_beam_pos_y = data_dict['station_positions'][-1]*up_beam_gra_y + up_y_func.GetParameter(0)\n up_beam_pos_y_err = up_y_func.GetParError(0)\n\n up_beam_rot_x = math.atan( up_beam_gra_x )\n up_beam_rot_x_err = up_beam_gra_x_err # Approx linear\n up_beam_rot_y = math.atan( up_beam_gra_y )\n up_beam_rot_y_err = up_beam_gra_y_err # Approx linear\n\n\n\n down_beam_gra_x = down_x_func.GetParameter(1)\n down_beam_gra_x_err = down_x_func.GetParError(1)\n down_beam_gra_y = down_y_func.GetParameter(1)\n down_beam_gra_y_err = down_y_func.GetParError(1)\n\n down_beam_pos_x = data_dict['station_positions'][1]*down_beam_gra_x + down_x_func.GetParameter(0)\n down_beam_pos_x_err = down_x_func.GetParError(0)\n down_beam_pos_y = data_dict['station_positions'][1]*down_beam_gra_y + down_y_func.GetParameter(0)\n down_beam_pos_y_err = down_y_func.GetParError(0)\n\n down_beam_rot_x = math.atan( down_beam_gra_x )\n down_beam_rot_x_err = down_beam_gra_x_err # Approx linear\n down_beam_rot_y = math.atan( down_beam_gra_y )\n down_beam_rot_y_err = down_beam_gra_y_err # Approx linear\n\n\n# down_pos_x = down_beam_pos_x - data_dict['station_positions'][1]*up_beam_gra_x + up_x_func.GetParameter(0)\n# down_pos_x_err = math.sqrt( up_x_func.GetParError(0)**2 + down_beam_pos_x_err**2 )\n# down_pos_y = down_beam_pos_y - data_dict['station_positions'][1]*up_beam_gra_y + up_y_func.GetParameter(0)\n# down_pos_y_err = math.sqrt( up_y_func.GetParError(0)**2 + down_beam_pos_y_err**2 )\n\n length = TRACKER_SEPARATION\n down_pos_x = down_beam_pos_x - ( up_beam_pos_x + length*up_beam_gra_x )\n down_pos_x_err = math.sqrt( up_beam_pos_x_err**2 + down_beam_pos_x_err**2 + (length*up_beam_gra_x_err)**2 )\n down_pos_y = down_beam_pos_y - ( up_beam_pos_y + length*up_beam_gra_y )\n down_pos_y_err = math.sqrt( up_beam_pos_y_err**2 + down_beam_pos_y_err**2 + (length*up_beam_gra_y_err)**2 )\n\n down_rot_x = down_beam_rot_x - up_beam_rot_x\n down_rot_x_err = math.sqrt( down_beam_rot_x_err**2 + up_beam_rot_x_err**2 )\n down_rot_y = down_beam_rot_y - up_beam_rot_y\n down_rot_y_err = math.sqrt( down_beam_rot_y_err**2 + up_beam_rot_y_err**2 )\n\n\n print\n print \"Incoming Beam Misalignments:\"\n print\n print \"Displacement and rotation of beam with respect to upstream tracker:\"\n print\n print \"X Position = {0:0.3f} +/- {1:0.3f} mm\".format( up_beam_pos_x, up_beam_pos_x_err )\n print \"Y Position = {0:0.3f} +/- {1:0.3f} mm\".format( up_beam_pos_y, up_beam_pos_y_err )\n print\n print \"X Rotation = {0:0.3f} +/- {1:0.3f} mrad\".format( up_beam_rot_x*1000.0, up_beam_rot_x_err*1000.0 )\n print \"Y Rotation = {0:0.3f} +/- {1:0.3f} mrad\".format( up_beam_rot_y*1000.0, up_beam_rot_y_err*1000.0 )\n print\n\n print\n print \"Downstream Tracker Beam Misalignments:\"\n print\n print \"Displacement and rotation of beam with respect to downstream tracker:\"\n print\n print \"X Position = {0:0.3f} +/- {1:0.3f} mm\".format( down_beam_pos_x, down_beam_pos_x_err )\n print \"Y Position = {0:0.3f} +/- {1:0.3f} mm\".format( down_beam_pos_y, down_beam_pos_y_err )\n print\n print \"X Rotation = {0:0.3f} +/- {1:0.3f} mrad\".format( down_beam_rot_x*1000.0, down_beam_rot_x_err*1000.0 )\n print \"Y Rotation = {0:0.3f} +/- {1:0.3f} mrad\".format( down_beam_rot_y*1000.0, down_beam_rot_y_err*1000.0 )\n print\n\n print\n print \"Downstream Tracker Alignment:\"\n print\n print \"Displacement and rotation of between the two trackers:\"\n print\n print \"X Position = {0:0.3f} +/- {1:0.3f} mm\".format( down_pos_x, down_pos_x_err )\n print \"Y Position = {0:0.3f} +/- {1:0.3f} mm\".format( down_pos_y, down_pos_y_err )\n print\n print \"X Rotation = {0:0.3f} +/- {1:0.3f} mrad\".format( down_rot_x*1000.0, down_rot_x_err*1000.0 )\n print \"Y Rotation = {0:0.3f} +/- {1:0.3f} mrad\".format( down_rot_y*1000.0, down_rot_y_err*1000.0 )\n print","def __init__(self, output_directory: str, step: int = 100, **kwargs) -> None:\n self.directory = output_directory\n self.plot_front = Plot(title=\"Pareto front approximation\", **kwargs)\n self.last_front = []\n self.fronts = []\n self.counter = 0\n self.step = step\n\n if Path(self.directory).is_dir():\n LOGGER.warning(\"Directory {} exists. Removing contents.\".format(self.directory))\n for file in os.listdir(self.directory):\n os.remove(\"{0}/{1}\".format(self.directory, file))\n else:\n LOGGER.warning(\"Directory {} does not exist. Creating it.\".format(self.directory))\n Path(self.directory).mkdir(parents=True)","def output_results(self, filename):\n\n self.data.plot(title='Result of applying {} onto data set'.format(self.transformations[-1]))\n plt.savefig(\"results/{}.png\".format(filename))\n plt.close()","def plot_training_progress(model_output_path):\n try:\n results = load_results(model_output_path)\n except FileNotFoundError:\n print('monitor.csv file is not found!')\n\n results['l_moving_avg_100'] = results['l'].rolling(window=100).mean()\n results['r_moving_avg_100'] = results['r'].rolling(window=100).mean()\n results['t_per_M'] = results['t'] / 1000\n\n fig, axs = plt.subplots()\n results.plot(\n ax=axs,\n x='t_per_M', y='r_moving_avg_100',\n title='Training Progress',\n xlabel='Million Steps',\n ylabel='Mean Reward'\n )\n return results","def ex_plot_sequence(ax, path, fname, num_checkpoints, prefix=None, step=1, pause_time=0.01):\n\n if type(num_checkpoints) is tuple:\n if len(num_checkpoints) > 2:\n raise ValueError(\"Cannot accept more than 2 limits for num_checkpoints\")\n if num_checkpoints[0] == 0:\n n_min = 1\n else:\n n_min = int(num_checkpoints[0])\n n_max = int(num_checkpoints[1])\n else:\n n_min = 1\n n_max = int(num_checkpoints)\n\n # Check input arguments\n if type(path) is not list:\n path = [path]\n\n if type(fname) is not list:\n fname = [fname]\n\n # Iterate over all files and generate animations\n for p in path:\n for f in fname:\n for n in range(n_min, n_max, step):\n if prefix is not None:\n cname = '%s/%s/%s_epoch_%d.pkl' % (prefix, p, f, int(n))\n else:\n cname = '%s/%s_epoch_%d.pkl' % (p, f, int(n))\n solv = solver.Solver(None, None)\n solv.load_checkpoint(cname)\n title = '%s (epoch %d)' % (f, n)\n vis_solver.plot_model_first_layer(ax, solv.model, title=title)\n plt.pause(pause_time)\n plt.draw()","def plot_multi_outputs(X_list, gp,xlim,n_outputs):\r\n\r\n slices = GPy.util.multioutput.get_slices(X_list)\r\n fig = plt.figure(figsize=(15, 8))\r\n plt.subplots_adjust(hspace=0.)\r\n for i in range(1, n_outputs+1):\r\n ax = plt.subplot(n_outputs, 1, i)\r\n ax.tick_params(axis=\"both\", direction=\"in\", bottom=True, top=True, left=True, right=True)\r\n ax.tick_params(axis=\"both\", labelbottom=False)\r\n ax.set_xlim(xlim)\r\n ax.set_ylabel(f'Output {i}')\r\n gp.plot(plot_limits=xlim, ax=ax, fixed_inputs=[(1, i-1)], which_data_rows=slices[i-1], legend=False)\r\n ax.tick_params(axis=\"both\", labelbottom=True)\r\n plt.show()\r\n return","def Plot(self):\n\n ### Create the path names ###\n folder_string = self.params.folder+\"/plots/\"\n u_string = self.params.folder+\"/plots/u.pdf\"\n p_string = self.params.folder+\"/plots/p.pdf\"\n\n ### Check if folder exists ###\n if not os.path.exists(folder_string): os.makedirs(folder_string)\n\n ### Plot the x component of velocity ###\n plot(self.u_next[0],title=\"Velocity in the x Direction\")\n plt.savefig(u_string)\n plt.figure()\n\n ### Plot the pressure ###\n plot(self.p_next,title=\"Pressure\")\n plt.savefig(p_string)\n plt.show()","def plotting(self,job,input_zip,output_file,df,my_dpi):\n if len(job.Y2headers)>0:\n X1=df.loc[:,job.X1header].values\n X2=df.loc[:,job.X2header].values\n Y1=df.loc[:,job.Y1headers].values\n if (job.name.startswith(\"Morphine\") or job.name.startswith(\"Sarin\")) and os.path.exists(job.experimentalData):\n df2=pd.read_csv(job.experimentalData)\n Y2=np.array(df2.loc[:,job.Y2headers].values)\n X1=np.array(df2.loc[:,job.X1header].values[:Y2.shape[0]])\n Y1=np.array(df.loc[:,job.Y1headers].values[:Y2.shape[0]])\n X2=np.array(df.loc[:,job.X2header].values[:Y2.shape[0]])\n else:\n Y2=df.loc[:,job.Y2headers].values\n fig,ax = plt.subplots()\n fig.set_size_inches(w=job.imageWidth/my_dpi+3.1,h=job.imageHeight/my_dpi+1)\n \n if not os.path.exists(job.outputDir):\n os.mkdir(job.outputDir)\n \n if job.X1LowerBound and job.X1UpperBound:\n ax.set_xlim(job.X1LowerBound,job.X1UpperBound)\n elif job.X1LowerBound:\n ax.set_xlim(left=job.X1LowerBound)\n elif job.X1UpperBound:\n ax.set_xlim(right=job.X1UpperBound)\n\n if job.Y1LowerBound and job.Y1UpperBound:\n ax.set_ylim(job.Y1LowerBound,job.Y1UpperBound)\n elif job.Y1LowerBound:\n ax.set_ylim(bottom=job.Y1LowerBound)\n elif job.Y1UpperBound:\n ax.set_ylim(top=job.Y1UpperBound) \n \n ax.get_yaxis().set_major_locator(MaxNLocator(nbins=18,min_n_ticks=8))\n ax.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\n ax.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\n ax.set_xlabel(job.X1header,fontsize=job.fontSize)\n \n if job.Y1Label!=None:\n ax.set_ylabel(job.Y1Label,color=\"g\",fontsize=job.fontSize)\n else:\n ax.set_ylabel(job.Y1headers[0],color=\"g\",fontsize=job.fontSize)\n p1=ax.plot(X1,Y1,color=\"g\")\n\n ax2=ax.twinx()\n \n if job.Y2LowerBound and job.Y2UpperBound:\n ax2.set_ylim(job.Y2LowerBound,job.Y2UpperBound)\n elif job.Y2LowerBound:\n ax2.set_ylim(bottom=job.Y2LowerBound)\n elif job.Y2UpperBound:\n ax2.set_ylim(top=job.Y2UpperBound)\n \n ax2.get_yaxis().set_major_locator(MaxNLocator(nbins=18,min_n_ticks=8))\n ax2.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\n ax2.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\n ax2.set_xlabel(job.X1header,fontsize=job.fontSize)\n \n if job.Y2Label!=None:\n ax2.set_ylabel(job.Y2Label,color=\"b\",fontsize=job.fontSize)\n else:\n ax2.set_ylabel(job.Y2headers[0],color=\"b\",fontsize=job.fontSize)\n \n p2=ax2.plot(X2,Y2,color=\"b\")\n title=job.name+\"_\"\n title+=job.Y2headers[0]\n title = title + \"vs_\" + job.X1header\n \n if job.X2header != None and not job.X1header.lower() == job.X2header.lower():\n title = title + \"_\" + job.X2header\n # Override the constructed title if desired\n \n if job.titleOverride != None and not len(job.titleOverride)==0 and not job.titleOverride.lower() == \"None\".lower():\n title = job.titleOverride\n if job.log>=1:\n logging.info(\"Creating Graph:\"+title)\n \n if job.titleOverride !=\"None\":\n plt.title(title,fontsize=job.fontSize)\n \n if job.showGridLines:\n plt.grid(b=True, which='major', color='r', linestyle='--')\n \n if not job.removeAllLegends:\n p=p1+p2\n labs=[job.Y1headers[0],job.Y2headers[0]]\n ax.legend(p,labs)\n \n if \"(\" and \")\" in job.outputFilename:\n job.outputFilename=job.outputFilename.split(\"(\")[0]+\".jpg\"\n plt.savefig(os.path.join(job.outputDir,job.outputFilename),dpi=my_dpi)\n plt.close(\"all\")\n\n elif len(job.Y2headers)==0:\n X1=df.loc[:,job.X1header]\n Y1=df.loc[:,job.Y1headers]\n fig,ax = plt.subplots()\n fig.set_size_inches(w=job.imageWidth/my_dpi+3.1,h=job.imageHeight/my_dpi+1)\n \n if not os.path.exists(job.outputDir):\n os.mkdir(job.outputDir)\n \n if job.X1LowerBound and job.X1UpperBound:\n ax.set_xlim(job.X1LowerBound,job.X1UpperBound)\n elif job.X1LowerBound:\n ax.set_xlim(left=job.X1LowerBound)\n elif job.X1UpperBound:\n ax.set_xlim(right=job.X1UpperBound)\n\n if job.Y1LowerBound and job.Y1UpperBound:\n ax.set_ylim(job.Y1LowerBound,job.Y1UpperBound)\n elif job.Y1LowerBound:\n ax.set_ylim(bottom=job.Y1LowerBound)\n elif job.Y1UpperBound:\n ax.set_ylim(top=job.Y1UpperBound) \n \n ax.get_yaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=8))\n ax.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\n ax.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\n ax.set_xlabel(job.X1header,fontsize=job.fontSize)\n ax.set_ylabel(job.Y1headers[0],fontsize=job.fontSize)\n p=ax.plot(X1,Y1)\n title=job.name+\"_\"\n title = title + \"vs_\" + job.X1header\n \n if job.X2header != None and not job.X1header.lower() == job.X2header.lower():\n title = title + \"_\" + job.X2header\n \n # Override the constructed title if desired\n if job.titleOverride != None and not len(job.titleOverride)==0 and not job.titleOverride.lower() == \"None\".lower():\n title = job.titleOverride\n if job.log>=1:\n logging.info(\"Creating Graph:\"+title)\n \n if job.titleOverride !=\"None\":\n plt.title(title,fontsize=job.fontSize)\n \n if job.showGridLines:\n plt.grid(b=True, which='major', color='r', linestyle='--')\n \n if not job.removeAllLegends:\n labs=job.Y1headers\n plt.legend(p,labs)\n \n if \"(\" and \")\" in job.outputFilename:\n job.outputFilename=job.outputFilename.split(\"(\")[0]+\".jpg\"\n plt.savefig(os.path.join(job.outputDir,job.outputFilename),dpi=my_dpi)\n plt.close(\"all\")\n \n else:\n X1=df.loc[:,job.X1header]\n Y1=df.loc[:,job.Y1headers]\n fig,ax = plt.subplots()\n fig.set_size_inches(w=job.imageWidth/my_dpi+3.1,h=job.imageHeight/my_dpi+1)\n \n if not os.path.exists(job.outputDir):\n os.mkdir(job.outputDir)\n \n if job.X1LowerBound and job.X1UpperBound:\n ax.set_xlim(job.X1LowerBound,job.X1UpperBound)\n elif job.X1LowerBound:\n ax.set_xlim(left=job.X1LowerBound)\n elif job.X1UpperBound:\n ax.set_xlim(right=job.X1UpperBound)\n\n if job.Y1LowerBound and job.Y1UpperBound:\n ax.set_ylim(job.Y1LowerBound,job.Y1UpperBound)\n elif job.Y1LowerBound:\n ax.set_ylim(bottom=job.Y1LowerBound)\n elif job.Y1UpperBound:\n ax.set_ylim(top=job.Y1UpperBound) \n \n ax.get_yaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=8))\n ax.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\n ax.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\n ax.set_xlabel(job.X1header,fontsize=job.fontSize)\n ax.set_ylabel(job.Y1headers[0],fontsize=job.fontSize)\n p1=ax.plot(X1,Y1)\n title=job.name+\"_\"\n title = title + \"vs_\" + job.X1header\n \n if job.X2header != None and not job.X1header.lower() == job.X2header.lower():\n title = title + \"_\" + job.X2header\n \n # Override the constructed title if desired\n if job.titleOverride != None and not len(job.titleOverride)==0 and not job.titleOverride.lower() == \"None\".lower():\n title = job.titleOverride\n if job.log>=1:\n logging.info(\"Creating Graph:\"+title)\n \n if job.titleOverride !=\"None\":\n plt.title(title,fontsize=job.fontSize)\n \n if job.showGridLines:\n plt.grid(b=True, which='major', color='r', linestyle='--')\n \n if not job.removeAllLegends:\n labs=job.Y1headers\n ax.legend(p1, labs)\n \n if \"(\" and \")\" in job.outputFilename:\n job.outputFilename=job.outputFilename.split(\"(\")[0]+\".jpg\"\n plt.savefig(os.path.join(job.outputDir,job.outputFilename),dpi=my_dpi)\n plt.close(\"all\")","def plot_results(self):\n\n\n f1, ax1 = plt.subplots()\n h1, = ax1.plot(self.history[\"step\"], self.history[\"trainLoss\"],\\\n \"b-\", label=\"Loss - Train\")\n h2, = ax1.plot(self.history[\"step\"], self.history[\"validLoss\"],\\\n \"b.\", label=\"Loss - Validation\")\n\n ax1.set_ylabel(\"Loss\", color = \"blue\")\n ax1.tick_params(\"y\", color = \"blue\")\n ax1.yaxis.label.set_color(\"blue\")\n ax1.set_xlabel(\"Training Steps [{}]\".format(self.FLAGS.eval_every))\n\n ax2 = ax1.twinx()\n h3, = ax2.plot(self.history[\"step\"], self.history[\"trainAccr\"], \"r-\",\\\n label = \"Accuracy - Train\")\n h4, = ax2.plot(self.history[\"step\"], self.history[\"validAccr\"], \"r.\",\\\n label = \"Accuracy - Validation\")\n\n ax2.set_ylabel(\"Accuracy\", color = \"red\")\n ax2.tick_params(\"y\", color = \"red\")\n ax2.yaxis.label.set_color(\"red\")\n\n hds = [h1,h2,h3,h4]\n lbs = [l.get_label() for l in hds]\n ax1.legend(hds, lbs)\n f1.tight_layout()\n plt.savefig(\"trainingHistory.png\")\n\n plt.close(f1)\n #plt.show()","def PlotProfile():\n (metadata, data) = Parse('/tmp/sdcard-scalability.txt')\n gp = Gnuplot.Gnuplot(persist=1)\n gp('set data style impulses')\n gp('set xtics 1')\n gp('set pointsize 2')\n gp.clear()\n gp.xlabel('writer process')\n gp.ylabel('duration in second')\n gp.title(metadata.AsTitle())\n\n dataset = data[0]\n x = numpy.array(dataset.time, dtype='int_')\n d = Gnuplot.Data(x, dataset.data,\n title=dataset.name,\n with_='linespoints')\n gp.replot(d)\n gp.hardcopy('/tmp/%s-%s-%f.png' %\n (metadata.name, metadata.kernel, metadata.duration),\n terminal='png')","def plot_path_statistics( self, path_file=\"tse_ensemble.json\" ):\n from matplotlib import pyplot as plt\n with open(path_file,'r') as infile:\n data = json.load(infile)\n try:\n paths = data[\"transition_paths\"]\n except KeyError:\n paths = [data]\n total_product_indicator = np.zeros(len(paths[0][\"symbols\"]))\n total_reactant_indicator = np.zeros(len(paths[0][\"symbols\"]))\n self.nuc_mc.min_size_product = paths[0][\"min_size_product\"]\n self.nuc_mc.max_size_reactant = paths[0][\"max_size_reactant\"]\n for path in paths:\n product_indicator = []\n reactant_indicator = []\n reactant_indicator, product_indicator = self.get_basin_indicators(path)\n\n total_product_indicator += np.cumsum(product_indicator)/float( len(product_indicator) )\n total_reactant_indicator += np.cumsum(reactant_indicator)/float( len(reactant_indicator) )\n\n total_reactant_indicator /= float( len(paths) )\n total_product_indicator /= float( len(paths) )\n\n fig = plt.figure()\n ax = fig.add_subplot(1,1,1)\n ax.plot( total_product_indicator, label=\"Product\" )\n ax.plot( total_reactant_indicator, label=\"Reactant\" )\n ax.set_xlabel( \"MC sweeps\" )\n ax.set_ylabel( \"Indicator\" )\n ax.spines[\"right\"].set_visible(False)\n ax.spines[\"top\"].set_visible(False)\n ax.legend( frameon=False, loc=\"best\" )\n return fig","def plot_oneshot_task(pairs):\n fig,(ax1,ax2) = plt.subplots(2)\n ax1.matshow(pairs[0][0].reshape(300,300),cmap='gray')\n img = concat_images(pairs[1])\n ax1.get_yaxis().set_visible(False)\n ax1.get_xaxis().set_visible(False)\n ax2.matshow(img,cmap='gray')\n plt.xticks([])\n plt.yticks([])\n plt.show()","def plot_visco_profiles(pointsh5, skip=slice(None,None,1), xscale=1e3, yscale=1e-2, tscale=3.1536e7, adjustRadial=False, benchmark=[], title=None):\n\tplt.figure()\n\n\tcoords,data,number,times = pu.load_h5_visco(pointsh5)\n\n\t#x = 1e3*np.loadtxt(points,usecols=[0]) # output_points2.txt\n\t#y = np.zeros_like(x)\n\tx = coords[:,0]\n\ty = np.zeros_like(x)\n\n\t# NOTE: plot elastic solution by passing dictionary as showelastic\n\t# Plot analytic elastic solution (t=0)\n\t#print(benchmark)\n\tif len(benchmark)>=1:\n\t\tur = zeros_like(x)\n\t\tuz = np.zeros_like(x)\n\t\tfor b in benchmark:\n\t\t\turi,uzi = m.calc_mogi_dp(x,y,**params)\n\t\t\tur += uri\n\t\t\tuz += uzi\n\t\tplt.plot(x*xscale,uz*yscale,'ko',label='benchmark')\n\n\t# Convert units\n\t#ur = np.hypot(data[:,:,0], data[:,:,1]) #assume progiles are along EW profile\n\tur = data[:,:,0]\n\tuz = data[:,:,2]\n\tx = x / xscale\n\tur = ur / yscale #cm\n\tuz = uz / yscale #cm\n\ttimes = times / tscale\n\t#times = times / 8.64e4 #days\n\t#times = times / 31536000 #years\n\n\t#plots = np.arange(0,times.size,skip)\n\t#print(plots.size)\n\t#way to cycle through markers if plotting many lines\n\t#marker = itertools.cycle(['o','^','s','D']) #plot(marker=marker.next() iterates list)\n\t#way to use gradually changing colors from a colormap\n\t#color = plt.cm.jet(1.0*i/plots.size)\n\tindplots = np.arange(times.size-1)\n\tprint(indplots)\n\tindplots = indplots[skip]\n\tprint(indplots)\n\tfor i in indplots:\n\t\tline, = plt.plot(x, uz[i], color=plt.cm.jet(1.0*i/indplots[-1]), label='{:.1f}'.format(times[i]))\n\t\tplt.plot(x, ur[i], ls='dashed', color=line.get_color())\n\t#print uz[i]\n\t#print uz[i-1]\n\n\tif title:\n\t\tplt.title(title)\n\telse:\n\t\tplt.title(pointsh5)\n\n\tplt.axhline(color='k',linestyle='dashed')\n\tplt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n\tplt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n\tplt.show()\n\tplt.legend(title='{}'.format(get_unit(tscale)))\n\tplt.grid()","def xx_plot(epoch, model, features, filters, figname, fgal=0.5):\n # fetch Stripe 82 data\n X, Xcov = fetch_prepped_s82data(epoch, fgal, features, filters)\n Xcoadd, Xcoaddcov = fetch_prepped_s82data(epoch, fgal, features,\n filters, use_single=False)\n N = 20000\n X = X[:N]\n Xcov = Xcov[:N]\n Xcoadd = Xcoadd[:N]\n Xcoaddcov = Xcoaddcov[:N]\n\n # unpickle the XD model\n if type(model) == str: \n f = open(model, 'rb')\n model = cPickle.load(f)\n f.close()\n\n # Calculate the posteriors, draw samples\n a, m, v = model.posterior(X, Xcov)\n posts = np.zeros_like(X)\n for i in range(X.shape[0]):\n posts[i] = model.sample(a[i], m[i], v[i], size=1)\n\n lo = [0.01, 0.02, 0.06]\n hi = [0.99, 0.96, 0.98]\n idx = [0, 1, 4]\n bins = [100, 100, 300]\n label = ['psfmag $r$', 'modelmag $u-g$', 'modelmag $i-z$']\n N = len(idx)\n fs = 5\n lsize = 20\n f = pl.figure(figsize=(N * fs, 2 * fs))\n pl.subplots_adjust(wspace=0.3)\n for i in range(N):\n x = X[:, idx[i]]\n y = Xcoadd[:, idx[i]]\n p = posts[:, idx[i]]\n ind = (y > -999) & (Xcoaddcov[:, idx[i]][:, idx[i]] < 10.)\n x = x[ind]\n y = y[ind]\n p = p[ind]\n ax = pl.subplot(2, N, i + 1)\n v = np.sort(x)\n mn, mx = v[np.int(lo[i] * x.shape[0])], v[np.int(hi[i] * x.shape[0])]\n hist2d(x, y, ax=ax, bins=bins[i], plot_contours=True,\n plot_datapoints=True)\n pl.plot([mn, mx], [mn, mx], 'r', lw=2)\n pl.ylabel('Coadd ' + label[i], fontsize=lsize)\n pl.xlabel('Single Epoch ' + label[i], fontsize=lsize)\n pl.xlim(mn, mx)\n pl.ylim(mn, mx)\n ax = pl.subplot(2, N, i + 4)\n hist2d(p, y, ax=ax, bins=bins[i], plot_contours=True,\n plot_datapoints=True)\n pl.plot([mn, mx], [mn, mx], 'r', lw=2)\n pl.xlim(mn, mx)\n pl.ylim(mn, mx)\n pl.ylabel('Coadd ' + label[i], fontsize=lsize)\n pl.xlabel('XD Posterior ' + label[i], fontsize=lsize)\n f.savefig(figname, bbox_inches='tight')","def display_dataset(path, save, dset='sum'):\n # List datasets\n files_surf = os.listdir(path[0])\n files_surf.sort()\n files_deep = os.listdir(path[1])\n files_deep.sort()\n files_calc = os.listdir(path[2])\n files_calc.sort()\n\n # Corrected names\n files = os.listdir(r'Y:\\3DHistoData\\Subvolumes_2mm')\n files.sort()\n\n k = 0\n # Loop for displaying images\n for fsurf, fdeep, fcalc in zip(files_surf, files_deep, files_calc):\n # Load images\n im_surf = loadh5(path[0], fsurf, dset)\n im_deep = loadh5(path[1], fdeep, dset)\n im_calc = loadh5(path[2], fcalc, dset)\n # Create figure\n fig = plt.figure(dpi=300)\n ax1 = fig.add_subplot(131)\n ax1.imshow(im_surf, cmap='gray')\n plt.title(fsurf + ', Surface')\n ax2 = fig.add_subplot(132)\n ax2.imshow(im_deep, cmap='gray')\n plt.title('Deep')\n ax3 = fig.add_subplot(133)\n ax3.imshow(im_calc, cmap='gray')\n plt.title('Calcified')\n if save is not None:\n while files[k] == 'Images' or files[k] == 'MeanStd':\n k += 1\n\n # Save figure\n if not os.path.exists(save):\n os.makedirs(save, exist_ok=True)\n plt.tight_layout()\n fig.savefig(os.path.join(save, files[k]), bbox_inches=\"tight\", transparent=True)\n plt.close()\n\n # Save h5\n if not os.path.exists(save + '\\\\MeanStd\\\\'):\n os.makedirs(save + '\\\\MeanStd\\\\', exist_ok=True)\n\n h5 = h5py.File(save + \"\\\\MeanStd\\\\\" + files[k] + '.h5', 'w')\n h5.create_dataset('surf', data=im_surf)\n h5.create_dataset('deep', data=im_deep)\n h5.create_dataset('calc', data=im_calc)\n h5.close()\n else:\n plt.show()\n k += 1","def plot_profiles(self, parameters, fig=1):\n # Make sure the parameters are a list\n if isinstance(parameters, str) or isinstance(parameters, unicode):\n parameters = [parameters]\n \n # Decide how many subplots to create\n nrows = int(len(parameters) / 3)\n if len(parameters) % 3 > 0:\n nrows += 1\n \n # Initialize a figure for plotting\n width = 8\n height = 4 * nrows\n plt.figure(fig, figsize=(width, height))\n plt.clf()\n \n # Plot each parameter\n for parm in parameters:\n ax = plt.subplot(nrows, 3, parameters.index(parm)+1)\n self.plot_parameter(parm)\n \n plt.tight_layout()\n \n plt.show()","def problemFour(self):\n # Initialize plot figures\n\n plot_41 = plt.figure(figsize=(12, 15))\n plot_41.subplots_adjust(left=.1, right=.98, top=.98, bottom=.08)\n pitot = plot_41.add_subplot(1, 1, 1)\n plt.tick_params(labelsize=16)\n pitot.set_xlabel('$\\\\frac{(y-y_o)}{D}$', fontsize=24)\n pitot.set_ylabel('Turbulence Intensity', fontsize=24)\n pitot.grid(linewidth=1, color='gray', linestyle='--')\n plot_42 = plt.figure(figsize=(12, 15))\n plot_42.subplots_adjust(left=.09, right=.98, top=.98, bottom=.08)\n hot = plot_42.add_subplot(1, 1, 1)\n plt.tick_params(labelsize=16)\n hot.set_xlabel('$\\\\frac{(y-y_o)}{D}$', fontsize=24)\n hot.set_ylabel('Turbulence Intensity', fontsize=24)\n hot.grid(linewidth=1, color='gray', linestyle='--')\n # Get plot data from each file\n for file_loc in self.filenames:\n file = os.path.basename(file_loc).replace('.csv', '')\n index = self.filenames.index(file_loc)\n if 'calibration' not in file:\n self.hot_vel = self.data[file]['hot vel'].tolist()\n self.pitot_vel = self.data[file]['pitot vel'].tolist()\n hot_std = self.data[file]['hot std'].tolist()\n pitot_std = self.data[file]['pitot std'].tolist()\n self.y_pos = self.data[file]['y pos'].tolist()\n # Calc v_inf for hotwire and pitot velocity profiles\n v_inf_hot = statistics.mean([sum(self.hot_vel[:6])/len(self.hot_vel[:6]), sum(self.hot_vel[-6:])/len(self.hot_vel[-6:])])\n v_inf_pitot = statistics.mean([sum(self.pitot_vel[:6])/len(self.pitot_vel[:6]), sum(self.pitot_vel[-6:])/len(self.pitot_vel[-6:])])\n # Normalize velocity to the freestream velocity\n hot_nondim = [i / v_inf_hot for i in self.hot_vel]\n pitot_nondim = [i / v_inf_pitot for i in self.pitot_vel]\n # Normalize the y position with cylinder diameter\n y0_hot = self.y_pos[hot_nondim.index(min(hot_nondim))]\n y0_pitot = self.y_pos[pitot_nondim.index(min(pitot_nondim))]\n y_pos_nondim_hot = [(i - y0_hot) / self.cylinder_diam for i in self.y_pos]\n y_pos_nondim_pitot = [(i - y0_pitot) / self.cylinder_diam for i in self.y_pos]\n # Get turbulence intensity\n hot_turb = [i / v_inf_hot for i in hot_std]\n pitot_turb = [i / v_inf_pitot for i in pitot_std]\n # Find peaks\n peak1_h = y_pos_nondim_hot[hot_turb.index(max(hot_turb[:30]))]\n peak2_h = y_pos_nondim_hot[hot_turb.index(max(hot_turb[-30:]))]\n peak1_p = y_pos_nondim_pitot[pitot_turb.index(max(pitot_turb[:30]))]\n peak2_p = y_pos_nondim_pitot[pitot_turb.index(max(pitot_turb[-30:]))]\n print(file)\n print(peak1_h, peak2_h)\n print(peak1_p, peak2_p)\n # Plot the turbulence intensity\n pitot.plot(y_pos_nondim_pitot, pitot_turb, color=self.plot_color[index], label=f'{file}mm', linewidth=2)\n hot.plot(y_pos_nondim_hot, hot_turb, color=self.plot_color[index], label=f'{file}mm', linewidth=2)\n pitot.legend(loc='upper right', fontsize=18)\n hot.legend(loc='upper right', fontsize=18)\n plot_41.savefig(os.path.join(os.getcwd(), r'plots\\prob4_pitot'))\n plot_42.savefig(os.path.join(os.getcwd(), r'plots\\prob4_hot'))\n plt.draw()","def matplotlib_plot(self, output_dir: Union[str, Path]):\n keys2 = set.union(*[set(self.get_keys2(k)) for k in self.get_keys()])\n for key2 in keys2:\n keys = [k for k in self.get_keys() if key2 in self.get_keys2(k)]\n plt = self._plot_stats(keys, key2)\n p = Path(output_dir) / f\"{key2}.png\"\n p.parent.mkdir(parents=True, exist_ok=True)\n plt.savefig(p)","def plot_it(self, ui=None, res_dir=None):\r\n print_it(\"plotting results\")\r\n plt_profile(self.sun, PltOpts.DD.value, res_dir, SubDir.profiles.value)\r\n plt_profile(self.sun, PltOpts.DDD.value, res_dir, SubDir.profiles.value)\r\n plt_profile(self.planet, PltOpts.DD.value, res_dir,\r\n SubDir.profiles.value)\r\n plt_profile(self.planet, PltOpts.DDD.value, res_dir,\r\n SubDir.profiles.value)\r\n plt_profile_approx(res_dir, SubDir.profiles.value)\r\n plt_contact(self.sun, self.planet, PltOpts.DD.value, res_dir,\r\n SubDir.contacts.value)\r\n plt_contact(self.sun, self.planet, PltOpts.DDD.value, res_dir,\r\n SubDir.contacts.value)\r\n\r\n plt_3d(self.sun.x_axis, self.sun.y_axis, self.sun.press,\r\n self.sun.x_label, self.sun.y_label, 'pressure in MPa',\r\n 'contact_pressure_sun', res_dir, SubDir.pressures.value,\r\n 'contact_pressure_sun')\r\n plt_2d_scatt_line(self.sun.x_axis, self.pv, self.sun.x_axis, self.pv,\r\n self.sun.x_label,\r\n 'pv_rel in {}'.format(Unit.pvrel.value), 'pv_rel',\r\n res_dir, SubDir.energy.value, 'pv_rel')\r\n plt_2d_scatt_line(self.sun.x_axis, self.sun.e_akin, self.sun.x_axis,\r\n self.sun.e_akin, self.sun.x_label,\r\n 'e_akin in {}'.format(Unit.eakin.value), 'e_akin',\r\n res_dir, SubDir.energy.value, 'sun.e_akin')\r\n plt_2d_scatt_line(self.planet.x_axis, self.planet.e_akin,\r\n self.planet.x_axis, self.planet.e_akin,\r\n self.planet.x_label,\r\n 'e_akin in {}'.format(Unit.eakin.value), 'e_akin',\r\n res_dir,\r\n SubDir.energy.value, 'planet.e_akin')\r\n plt_energy_ring_on_ring(self, res_dir, SubDir.energy.value,\r\n 'e-akin-vs-pv-rel')","def compare_hist_2(results_dir_root):\n plot_style = [\n {'color': 'k', 'marker': 'none', 'lw': 1.5},\n {'color': 'r', 'marker': 'none', 'lw': 1.5}\n ]\n unwrap_levels = ['r08']\n\n fig, axes = plt.subplots(figsize=(8, 10), nrows=5, ncols=2, sharex=True,\n sharey=False)\n fig.subplots_adjust(left=0.1, bottom=0.08, right=0.98, top=0.98,\n hspace=0.05, wspace=0.15)\n\n print(axes.shape)\n\n results_dirs = [results_dir_root + '_0h', results_dir_root + '_4h']\n\n fig.text(0.5, 0.02, r'Baseline length (m)', ha='center')\n fig.text(0.01, 0.5, r'Baseline count per bin', va='center',\n rotation='vertical')\n\n # Loop over models\n for i in range(7, 8):\n models = ['ska1_v5', 'model%02i' % (i + 1)]\n # Loop over 0h or 4h\n for j in range(1):\n idx = 0\n ax = axes[i, j]\n for model in models:\n # Load saved psf results.\n filename = join(results_dirs[j], '%s_uv_hist.p' % model)\n print('-- Loading: %s' % filename)\n hist = pickle.load(open(filename, 'rb'))\n # Plot comparison of PSF profiles.\n for tel in hist:\n if tel == 'ska1_v5' or any(s in tel for s in unwrap_levels):\n style = plot_style[idx % len(plot_style)]\n x = hist[tel]['log']['hist_x']\n y = hist[tel]['log']['hist_n']\n cut_idx = np.argmax(x > 5e3)\n x = x[:cut_idx]\n y = y[:cut_idx]\n ax.plot(x, y, color=style['color'],\n linestyle='-',\n label=tel + ' max')\n idx += 1\n length_str = 'snapshot' if j == 0 else '4 hours'\n ax.text(0.02, 0.95, ('SKA1 v5 vs. Model %i\\n' % (i + 1)) + length_str,\n weight='bold',\n ha='left', va='top', transform=ax.transAxes,\n fontsize='small')\n # ax.legend(loc='best', fontsize='small', ncol=1)\n # ax.set_xlabel('Baseline length (m)')\n # ax.set_ylabel('Number of baselines per bin')\n ax.set_xlim(10, 1e4)\n if j == 1:\n ax.set_ylim(1.5e3)\n if j == 0:\n ax.set_ylim(5)\n ax.set_yscale('log')\n ax.set_xscale('log')\n # if i == 4:\n # ax.set_xlabel('Baseline length (m)')\n # ax.set_ylabel('Baseline count per bin')\n ax.grid()\n plt.show(True)\n fig.savefig(join('compare_hist_%s.png' %\n ('_'.join(unwrap_levels))))\n plt.close(fig)","def figure_1():\n exp_list = os.listdir(BASE_DATA_DIR)\n exp_list.remove(\"tmp\")\n\n # Draw common plots\n print(exp_list)\n data = get_data(exp_list[0])\n plt.figure(num=\"state 1\", figsize=[6.4, 4.8])\n plt.plot(\n data[\"time\"], data[\"cmd\"],\n **FORMATTING[\"command\"]\n )\n plt.plot(\n data[\"time\"], data[\"state\"][\"reference_system\"][:, 0],\n **FORMATTING[\"reference\"]\n )\n plt.ylabel(r\"$x_1$\")\n plt.xlabel(\"Time, sec\")\n\n plt.figure(num=\"state 2\", figsize=[6.4, 4.8])\n plt.plot(\n data[\"time\"], data[\"state\"][\"reference_system\"][:, 1],\n **FORMATTING[\"reference\"]\n )\n plt.ylabel(r\"$x_2$\")\n plt.xlabel(\"Time, sec\")\n\n plt.figure(num=\"control\")\n plt.ylabel(r\"$u$\")\n plt.xlabel(\"Time, sec\")\n\n def general_figures(exp):\n data = get_data(exp)\n plt.figure(num=\"state 1\")\n ax = plt.gca()\n ax.plot(\n data[\"time\"], data[\"state\"][\"main_system\"][:, 0],\n **FORMATTING[exp],\n )\n\n plt.figure(num=\"state 2\")\n plt.plot(\n data[\"time\"], data[\"state\"][\"main_system\"][:, 1],\n **FORMATTING[exp],\n )\n\n plt.figure(num=\"control\")\n plt.plot(\n data[\"time\"], data[\"control\"],\n **FORMATTING[exp],\n )\n\n for exp in exp_list:\n general_figures(exp)\n\n # Estimation error\n for exp in exp_list:\n data = get_data(exp)\n error = nla.norm(\n data[\"state\"][\"adaptive_system\"] - data[\"real_param\"],\n axis=1\n )\n plt.figure(num=\"Estimation error\")\n plt.plot(data[\"time\"], error, **FORMATTING[exp])\n plt.xlabel(\"Time, sec\")\n plt.ylabel(\"Error norm\")\n\n # Real parameter\n data = get_data(exp_list[0])\n plt.plot(data[\"time\"], data[\"real_param\"].squeeze())\n\n\n exp_list.remove(\"mrac-nullagent\")\n\n def eig_figures(exp, minmax):\n data = get_data(exp)\n if minmax == \"min\":\n eig = np.min(data[\"eigs\"], axis=1)\n elif minmax == \"max\":\n eig = np.max(data[\"eigs\"], axis=1)\n plt.plot(data[\"time\"], eig, **FORMATTING[exp])\n\n fig, (ax_min, ax_max) = plt.subplots(2, 1, num=\"Eigenvalues\", sharex=True)\n\n plt.subplot(211)\n plt.ticklabel_format(style=\"sci\", scilimits=(0, 0), useOffset=True)\n for exp in exp_list:\n eig_figures(exp, \"min\")\n plt.ylabel(r\"Minimum $\\lambda$\")\n plt.legend()\n\n plt.subplot(212)\n for exp in exp_list:\n eig_figures(exp, \"max\")\n plt.ylabel(r\"Maximum $\\lambda$\")\n plt.xlabel(\"Time, sec\")\n\n # Saving\n def savefig(name):\n path = os.path.join(args.save_dir, name + \".\" + args.save_ext)\n plt.savefig(path, bbox_inches=\"tight\")\n\n plt.figure(num=\"state 1\")\n plt.legend()\n savefig(\"state-1\")\n\n plt.figure(num=\"state 2\")\n plt.legend()\n savefig(\"state-2\")\n\n plt.figure(num=\"control\")\n plt.legend()\n savefig(\"control\")\n\n plt.figure(num=\"Eigenvalues\")\n savefig(\"eigs\")\n\n plt.figure(num=\"Estimation error\")\n plt.legend()\n savefig(\"estim-error\")\n\n plt.show()","def show_data(self, samples=5):\n self._samples = samples\n \n idx = 0\n batch = next(iter(self._loader))\n while idx <= self._samples:\n\n (img_batch, label_batch) = batch\n\n fig = plt.figure()\n ax1 = fig.add_subplot(121)\n ax2 = fig.add_subplot(122)\n \n ax1.imshow(np.transpose(img_batch[idx], (1, 2, 0)))\n ax2.imshow(np.transpose(label_batch[idx], (1, 2, 0)).squeeze(dim=2))\n\n plt.show()\n idx += 1","def plot_data(data, par, par_names, par_fixed, output_dir='./'):\n\n datasets = dict()\n\n for data_point in data:\n experiment_name = data_point.par['experiment_name']\n datasets.setdefault(experiment_name, list()).append(data_point)\n\n for experiment_name, dataset in datasets.items():\n\n # ##### Matplotlib ######\n\n name_pdf = ''.join([experiment_name, '.pdf'])\n name_pdf = os.path.join(output_dir, name_pdf)\n\n name_txt = ''.join([experiment_name, '.fit'])\n name_txt = os.path.join(output_dir, name_txt)\n\n print(\" * {} [.fit]\".format(name_pdf))\n\n # #######################\n\n data_grouped = group_data(dataset)\n profiles, r2_min, r2_max = compute_profiles(data_grouped)\n ymin, ymax = set_lim([r2_min, r2_max], 0.10)\n\n with PdfPages(name_pdf) as file_pdf, open(name_txt, 'w') as file_txt:\n\n for (_index, id_), profile in sorted(profiles.items()):\n write_profile(id_, profile, file_txt)\n\n ###### Matplotlib ######\n\n fig = plt.figure(1, frameon=True)\n ax = fig.add_subplot(111)\n\n ax.axhline(0, color='black', alpha=0.87)\n\n ########################\n\n frq, r2_cal, r2_exp, r2_erd, r2_eru = profile[0]\n\n ax.plot(\n frq,\n r2_cal,\n linestyle='-',\n color=red200,\n zorder=2,\n )\n\n ax.errorbar(\n frq,\n r2_exp,\n yerr=[r2_erd, r2_eru],\n fmt='o',\n color=red500,\n zorder=3,\n )\n\n xmin, xmax = set_lim(frq, 0.10)\n\n ax.set_xlim(xmin, xmax)\n ax.set_ylim(ymin, ymax)\n\n ax.xaxis.set_major_locator(MaxNLocator(6))\n ax.yaxis.set_major_locator(MaxNLocator(6))\n\n ax.set_xlabel(r'$\\mathregular{\\nu_{CPMG} \\ (Hz)}$')\n ax.set_ylabel(\n r'$\\mathregular{R_{2,eff} \\ (s^{-1})}$')\n\n ax.set_title('{:s}'.format(id_.upper()))\n\n fig.tight_layout()\n\n ########################\n\n file_pdf.savefig()\n plt.close()\n\n ########################\n\n return","def fig_6():\n epoch = 3\n N = 60000\n Nr = N\n K = 32\n n_iter = 256\n Nstar = 16\n data = 'dr10'\n factor = 100.\n features = ['psf_mag', 'model_colors', 'psf_minus_model']\n filters = ['r', 'ug gr ri iz', 'ugriz']\n message = 'pm_mc_pmm_r_all_all'\n model = 'xdmodel_%s_%d_%d_%d_%d_%s.pkl' % (data, Nr, K, n_iter, Nstar,\n message)\n model = os.environ['xddata'] + model\n figname = os.environ['xdplots'] + 'fig6.png'\n psfminusmodel_plot(epoch, model, features, filters, figname, idx=-3)","def plotBatch(inp,output='spectra_plot.pdf',comparisons=None,classify=False,normalize=False,normrange=[0.9,1.4],layout=[2,2],basecolors=['k','m'],legend=[],fontscale=0.7,classify_kwargs={},plot_kwargs={},**kwargs):\n\n# alt keyword check\n for k in ['file','filename']: \n if kwargs.get(k,'') != '': output = kwargs[k]\n for k in ['legends','labels']: \n if kwargs.get(k,'') != '': legend = kwargs[k]\n\n# force input into a list\n if isinstance(inp,list): inputlist = copy.deepcopy(inp)\n else: inputlist = [inp]\n\n# if input is a string of filenames, read in each file to a spectrum object\n if isinstance(inputlist[0],str):\n# try a glob search string \n files = glob.glob(os.path.normpath(inputlist[0]))\n if len(files) > 1 or (len(files) == 1 and inputlist[0].find('*') != -1):\n inputlist = files\n# try reading in files into Spectrum object\n try:\n splist = [splat.Spectrum(file = f) for f in inputlist]\n except:\n raise ValueError('\\nCould not read in list of files {} - make sure the full path is specified and the files are correctly formatted'.format(inputlist))\n\n# if filenames, read in each file to a spectrum object\n elif isinstance(inputlist[0],splat.Spectrum):\n splist = copy.deepcopy(inputlist)\n else:\n raise ValueError('\\nInput should be list of splat.Spectrum objects or filenames')\n\n# normalize if desired\n if normalize==True:\n tmp = [sp.normalize(normrange) for sp in splist]\n\n# comparison files are present\n complist = []\n if comparisons != None:\n comp = copy.deepcopy(comparisons)\n if not isinstance(comp,list): comp = [comp]\n if isinstance(comp[0],str):\n try:\n complist = [splat.Spectrum(file = f) for f in comp]\n except:\n print('\\nCould not read in comparison files: ignoring comparisons')\n if isinstance(comp[0],splat.Spectrum):\n complist = comp\n if len(complist) < len(splist):\n while len(complist) < len(splist):\n complist.append(complist[-1])\n# normalize\n if normalize==True:\n tmp = [sp.normalize(normrange) for sp in complist]\n\n# set comparison files to be standards for spectral classification\n# overrules input comparison sample\n if classify == True:\n complist = []\n base_kwargs={\n 'return_standard': True,\n 'method': 'kirkpatrick',\n }\n base_kwargs.update(classify_kwargs)\n for sp in splist:\n complist.append(splat.classifyByStandard(sp,**base_kwargs))\n\n# prep for plotting\n plotlist = []\n clist = []\n for i,sp in enumerate(splist):\n if len(complist) == len(splist):\n plotlist.append([sp,complist[i]])\n clist.extend(basecolors)\n else:\n plotlist.append([sp])\n clist.extend(basecolors[0])\n\n# manage legends\n if len(legend) != 0:\n if not isinstance(legend,list): legend = [legend]\n if len(legend) < (len(splist)+len(complist)):\n# guess: just left out the comparison legends \n if len(complist) > 0 and len(legend) == len(splist):\n legtmp = []\n for i,l in enumerate(legend):\n legtmp.extend([l,'{}'.format(complist[i].name)])\n legend = legtmp\n else:\n# otherwise: pad the remaining legends with the last legend (pairs) \n while len(legend) < (len(splist)+len(complist)):\n if len(complist)>0:\n legend.extend([legend[-2],legend[-1]])\n else:\n legend.extend([legend[-1]])\n if len(legend) > (len(splist)+len(complist)):\n legend = legend[0:(len(splist)+len(complist))]\n else:\n legend = []\n for i,sp in enumerate(splist):\n l = []\n if 'name' in list(sp.__dict__.keys()): l.append(sp.name)\n else: l.append(os.path.basename(sp.filename))\n if len(complist)>0:\n if 'name' in list(complist[i].__dict__.keys()): l.append(complist[i].name)\n else: l.append(os.path.basename(complist[i].filename))\n legend.extend(l)\n\n# generate plot\n base_kwargs={\n 'multiplot': True,\n 'multipage': True,\n 'legends': legend,\n 'colors': clist,\n 'layout': layout,\n 'fontscale': fontscale,\n 'output': output,\n }\n base_kwargs.update(plot_kwargs)\n fig = plotSpectrum(plotlist,**base_kwargs)\n\n return fig","def generate_figures():\r\n # create results directory if necessary\r\n try:\r\n makedirs(\"results\")\r\n except OSError as e:\r\n if e.errno != errno.EEXIST:\r\n raise\r\n \r\n for b in benchmarks:\r\n generate_figure(model[b], b)","def plotPerBxStep(options):\n name = options['scan'] + '_' + options['name'] + options['extra']\n if 'method' in options:\n name += '_' + options['method']\n f = openRootFileR(name)\n for bx in options['crossings']:\n for step in range(len(O['nominalPos'][options['scan']])):\n histname = plotName(name+'_bx'+str(bx)+'_step'+str(step), \\\n timestamp=False)\n filename = plotName(name+'_bx'+str(bx)+'_step'+str(step), \\\n timestamp=True)\n filepath = plotPath(name+'_bx'+str(bx)+'_step'+str(step), \\\n timestamp=True)\n print '<<< Save plot:', filepath\n hist = f.Get(histname)\n canvas = TCanvas()\n canvas.SetLogx(options['logx'])\n canvas.SetLogy(options['logy'])\n gStyle.SetOptStat(options['optstat'])\n gStyle.SetOptFit(options['optfit'])\n hist.Draw()\n gPad.Update()\n hist.GetXaxis().SetTitle(options['xtitle'])\n hist.GetXaxis().SetRangeUser(options['xmin'], options['xmax'])\n hist.GetYaxis().SetTitle(options['ytitle'])\n hist.GetYaxis().SetTitleOffset(1.2)\n for axis in [hist.GetXaxis(), hist.GetYaxis()]:\n axis.SetTitleFont(133)\n axis.SetTitleSize(16)\n axis.SetLabelFont(133)\n axis.SetLabelSize(12)\n axis.CenterTitle()\n stats = hist.FindObject('stats')\n stats.SetTextFont(133)\n stats.SetTextSize(16)\n drawSignature(filename)\n gPad.Modified()\n gPad.Update()\n if 'custom' in options:\n extragraphs = options['custom'](hist)\n canvas.Print(filepath)\n canvas.Close()\n closeRootFile(f, name)","def plot_results(param_names, param_options, results, params):\n\n\t# circuit/run_num where run_num is one before the existing one\n\tdirectory = params.circuit\n\tif not os.path.isdir(directory):\n\t\tos.mkdir(directory)\n\truns = immediate_subdir(directory)\n\tlatest_run = 0\n\tif runs:\n\t\tnatural_sort(runs)\n\t\tlatest_run = get_trailing_num(runs[-1])\n\tdirectory = os.path.join(directory, \"run\" + str(latest_run+1))\n\n\tprint(directory)\n\tif not os.path.isdir(directory):\n\t\tos.mkdir(directory)\n\n\twith Chdir(directory):\n\n\t\texport_results_to_csv(param_names, results, params)\n\n\t\tx = results.keys()\n\t\ty = []\n\t\tnext_figure = True\n\n\t\tp = 0\n\t\tplt.figure()\n\t\twhile p < len(param_names):\n\t\t\tprint(param_names[p])\n\n\t\t\tif param_options[p]:\n\t\t\t\tnf = True\n\t\t\t\tfor option in param_options[p].split():\n\t\t\t\t\t# stopping has veto power (must all be True to pass)\n\t\t\t\t\tnf = nf and plot_options(option)\n\t\t\t\tnext_figure = nf\n\n\t\t\tif not next_figure:\n\t\t\t\t# y becomes list of lists (for use with stackable plots)\n\t\t\t\ty.append([result[p] for result in results.values()])\n\t\t\t\tp += 1\n\t\t\t\tcontinue\n\t\t\telif not y:\n\t\t\t\ty = [result[p] for result in results.values()]\n\n\t\t\tlx = x[-1]\n\t\t\tly = y[-1]\n\t\t\tplot_method(x,y)\n\t\t\tplt.xlabel('iteration')\n\t\t\tplt.xlim(xmin=0)\n\t\t\t\n\t\t\tplt.ylabel(param_names[p])\n\n\t\t\t# annotate the last value\n\t\t\tannotate_last(lx,ly)\n\n\t\t\tif next_figure:\n\t\t\t\tplt.savefig(param_names[p])\n\t\t\t\tplt.figure()\n\n\t\t\tp += 1\n\t\t# in case the last figure hasn't been shuffled onto file yet\n\t\tif not next_figure:\n\t\t\tplot_method(x,y)\n\t\t\tplt.savefig(param_names[-1])","def save_images(self):\n for q in range(self.N_itr):\n plt.clf()\n self.plot_EM_estimate(q)\n plt.savefig('img%d.png' % (100 + q))","def display_some_traffic_sign_examples(path):\n\n images_paths = glob.glob(path + \"\\\\*.png\") # image paths\n plt.figure(figsize = (10, 10))\n\n for i in range(25):\n # select a random index in the dataset\n idx = np.random.randint(0, len(images_paths) - 1)\n img = imread(images_paths[idx])\n\n # subplot the dataset examples\n plt.subplot(5, 5, i + 1)\n plt.tight_layout(rect = [0, 0, 1, 0.95])\n plt.imshow(img)\n\n plt.suptitle(\"Dataset Examples\")\n plt.show()","def plot_PDs(output_path,M_max,max_dim,normalized=False,output_name=None):\n plots_folder = os.path.join(output_path,'plots')\n if output_name is None: \n aux = ['PDs']\n input_file = os.path.join(output_path,'outputs_PDS.csv')\n else:\n aux = [output_name,'PDs']\n input_file = os.path.join(output_path,'%s_PDS.csv' % output_name)\n if normalized is True:\n aux.append('normalized')\n plot_file_name = '-'.join(aux)+'.png'\n plot_file_name = os.path.join(plots_folder,plot_file_name)\n\n \n data = pd.read_csv(input_file,index_col = 0)\n \n\n fig_size_aux = 15/(3-max_dim)\n plt.figure(figsize=(fig_size_aux,5))\n if(normalized):\n for i in range(1,max_dim+2):\n plt.subplot(1,max_dim+1,i, aspect='equal')\n plt.plot(data[data.dimH==i-1].birth.values/np.float(M_max),data[data.dimH==i-1].death.values/np.float(M_max),'bo',alpha=.3,label='dim %i'%(i-1))\n plt.xlim((0,1)); plt.ylim((0,1))\n frame = plt.legend(loc=4,frameon=True,title='normalized')\n frame = frame.get_frame()\n frame.set_edgecolor('black')\n plt.xlabel('birth'); plt.ylabel('death')\n plt.plot([0, 1], [0, 1], ls=\"--\", c=\".3\")\n plt.suptitle('Persistence Diagrams')\n plt.savefig(plot_file_name)\n print 'Saved PDs plots in %s'%plot_file_name\n else:\n for i in range(1,max_dim+2):\n plt.subplot(1,max_dim+1,i, aspect='equal')\n plt.plot(data[data.dimH==i-1].birth.values,data[data.dimH==i-1].death.values,'bo',alpha=.3,label='dim %i'%(i-1))\n plt.xlim((0,M_max)); plt.ylim((0,M_max))\n frame = plt.legend(loc=4,frameon=True)\n frame = frame.get_frame()\n frame.set_edgecolor('black')\n plt.xlabel('birth'); plt.ylabel('death')\n plt.plot([0, M_max], [0, M_max], ls=\"--\", c=\".3\")\n plt.suptitle('Persistence Diagrams')\n plt.savefig(plot_file_name)\n print 'Saved PDs plots in %s'%plot_file_name\n return()","def main():\n Nrep = 8 # number of repetition of EM steps\n nm = 3 # number of mixed gaussians.\n ns = 300 # number of samples.\n \n mu, sg, lm, lm_ind, smp, L_true = generate_synthetic_data(nm, ns)\n plt.figure(1, figsize=(5,4))\n plt.clf()\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\n \n mue, sge, lme = generate_initial_state(nm, ns)\n axi = 0 # subplot number\n plt.figure(2, figsize=(12,9))\n plt.clf()\n for rep in range(Nrep):\n # E-step\n r, L_infer = e_step(smp, mue, sge, lme, nm, ns)\n axi += 1 \n ax = plt.subplot(Nrep/2, 6, axi)\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\n ax.set_title('E-step : %d' % (rep + 1))\n ax.set_yticklabels([])\n ax.set_xticklabels([])\n ax.set_ylim((-0.1, 0.3))\n\n # M-step\n mue, sge, lme = m_step(smp, r, nm, ns)\n axi += 1 \n ax = plt.subplot(Nrep/2, 6, axi)\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\n ax.set_title('M-step : %d' % (rep + 1))\n ax.set_yticklabels([])\n ax.set_xticklabels([])\n ax.set_ylim((-0.1, 0.3))\n\n # plot the ground truth for comparison\n axi += 1 \n ax = plt.subplot(Nrep/2, 6, axi)\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\n ax.set_title('grn_truth')\n ax.set_yticklabels([])\n ax.set_xticklabels([])\n ax.set_ylim((-0.1, 0.3))\n\n print('L_infer = %2.6f , L_true = %2.6f' % (L_infer, L_true))","def plot_results(epochs: int = 20, segments: int = 5, plot: bool = True):\n \"\"\"\n plt.figure(0)\n plot_approximation(\"product\", modelSetProd, 1, epochs, gpus=0)\n \"\"\"\n\n data = [\n {\n \"title\": \"Piecewise Discontinuous Function Approximation\",\n \"layer\": \"discontinuous\",\n \"model_set\": modelSetD,\n },\n {\n \"title\": \"Piecewise Continuous Function Approximation\",\n \"layer\": \"continuous\",\n \"model_set\": modelSetC,\n },\n {\n \"title\": \"Polynomial function approximation\",\n \"layer\": \"polynomial\",\n \"model_set\": modelSetP,\n },\n {\n \"title\": \"Fourier function approximation\",\n \"layer\": \"fourier\",\n \"model_set\": modelSetF,\n },\n ]\n\n for index, element in enumerate(data):\n if plot is True:\n plt.figure(index)\n plot_approximation(\n element[\"layer\"],\n element[\"model_set\"],\n 5,\n epochs,\n accelerator=\"cpu\",\n periodicity=2,\n )\n\n if plot is True:\n plt.title(\"Piecewise Discontinuous Function Approximation\")\n\n if plot is True:\n plt.show()","def plot_folder(folder, title, stochastic=True):\n results = open_folder(folder, stochastic=stochastic)\n assert len(results) > 0, 'Cannot find any results'\n ce_values = np.concatenate(\n [np.expand_dims(r.item()['train_xent'][:-1], 1) for r in results],\n axis=1)\n steps = np.concatenate(\n [np.expand_dims(r.item()['step'][:-1], 1) for r in results], axis=1)\n alpha_eff_values = np.concatenate(\n [\n np.expand_dims(r.item()['lr'] / (1.0 - r.item()['momentum']), 1)\n for r in results\n ],\n axis=1)\n condition = ['Manual', 'SMD']\n plot_report_figure_combined(\n steps,\n ce_values,\n alpha_eff_values,\n condition,\n title,\n 'Loss',\n 'Eff. Learning Rate',\n os.path.join(\n folder, 'combined_{}.pdf'.format('stoc' if stochastic else 'det')),\n include_legend=True)","def plot_profile(outdir, xval='x', xscale=1, yscale=1, comp2los=False, adjustRadial=False,\n fig=True):\n #Load data\n path = os.path.join(outdir,'points.h5')\n x,y,z,ux,uy,uz = pu.extract_points(path)\n\n Y = uz / yscale\n if xval == 'x':\n X = x / xscale\n Y1 = ux / yscale\n elif xval == 'r':\n X = np.hypot(x,y) / xscale\n ur = np.hypot(ux,uy)\n Y1 = ur / yscale\n if adjustRadial: #fix sign from hypot square root\n ur = pu.radial2negative(Y1)\n\n if fig:\n plt.figure()\n # otherwise profile added to active plot\n\n #plt.plot(X,uy/yscale,'r.-',label='Uy') #should be zero along EW axis\n de = 90e3 / xscale #eastern data extent\n if comp2los != False:\n data_extents = (X<=de)\n if comp2los == 'west': #switch sign of radial profile\n #ux = -ux #move to comp2los function\n X = -X\n Y1 = -Y1\n de = -de\n data_extents = (X>=de)\n\n los = pu.comp2los(x,ux,uy,uz,track=comp2los)\n plt.plot(X, los/yscale, 'k-', lw=2, label='Ulos_' + comp2los)\n plt.fill_between(X,los/yscale, where=data_extents, color='gray',alpha=0.5)\n\n plt.plot(X, Y, 'b-', lw=2, label='Uz')\n plt.plot(X, Y1, 'b--',lw=2, mfc='None',label='U{0}'.format(xval))\n\n # Annotate\n plt.title(outdir)\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n plt.ylabel('Uz [{}]'.format(get_unit(yscale)))\n plt.axhline(color='k')\n plt.axvline(de,color='k', linestyle='dashed', label='EW data extent') #EW extent of InSAR coverage\n plt.legend(loc='best')\n plt.grid(True)\n plt.show()","def generate_plots(self, env):\n print(' Generating diagnostic plots for : {0}'.format(self.__class__.__name__))\n\n # chdir into the working directory\n os.chdir(env['WORKDIR'])\n\n for nclPlotFile in self._ncl:\n # copy the NCL command to the workdir\n shutil.copy2('{0}/{1}'.format(env['NCLPATH'],nclPlotFile), '{0}/{1}'.format(env['WORKDIR'], nclPlotFile))\n\n nclFile = '{0}/{1}'.format(env['WORKDIR'],nclPlotFile)\n rc, err_msg = cesmEnvLib.checkFile(nclFile, 'read')\n if rc:\n try:\n print(' calling NCL plot routine {0}'.format(nclPlotFile))\n subprocess.check_call(['ncl', '{0}'.format(nclFile)], env=env)\n except subprocess.CalledProcessError as e:\n print('WARNING: {0} call to {1} failed with error:'.format(self.name(), nclFile))\n print(' {0}'.format(e.cmd))\n print(' rc = {0}'.format(e.returncode))\n else:\n print('{0}... continuing with additional plots.'.format(err_msg))","def plot(self, job):\n # fill PlotJob with needed data if it doesn't exist\n # Plotter will look for the files it needs relative to the work directory\n # If this fails it will fall back to a baseline location if one was \n # Provided to cmake at the time this file was generated\n if job.dataPath == None :\n job.dataPath = \"Scenarios/\" + job.verificationDirectory + \"/baselines/\"\n \n if job.dataFile == None:\n job.dataFile = job.name + \"Results.zip\"\n \n if job.outputFilename==None:\n job.outputFilename=job.titleOverride+\".jpg\"\n \n if len(job.outputFilename.split(\".\"))==1:\n job.outputFilename+=\".jpg\"\n \n if job.imageWidth==None and job.imageHeight==None:\n job.imageWidth=1600\n job.imageHeight=800\n \n if not os.path.exists(job.dataPath):\n job.dataPath = os.path.join(job.basedir,job.dataPath)\n \n if not os.path.isfile(os.path.join(job.dataPath,job.dataFile)):\n job.dataPath = os.path.join(job.basedir,job.dataPath)\n \n if not job.fontSize:\n job.fontSize=22\n \n if not os.path.exists(os.path.dirname(job.outputDir)):\n os.mkdir(os.path.dirname(job.outputDir))\n \n self.drawgraph(job,os.path.join(job.dataPath,job.dataFile),os.path.join(job.outputDir,job.outputFilename))","def plotPaperFigures(folder='results/'):\n #model Example\n _AiryDisc(amplitude=1e6, center_x=10.0, center_y=10.0, radius=0.5, focus=0.4, size=21)\n _CCDkernel(CCDx=10, CCDy=10, width_x=0.35, width_y=0.4, size=21)\n plotModelExample()\n\n #simulation figures\n theta1 = (2.e5, 9.9, 10.03, 0.41, 0.51, 10., 10., 0.291, 0.335)\n try:\n _plotDifferenceIndividualVsJoined(individuals='simulatedResults/RunI*.pkl',\n joined='results/simulated800nmJoint.pkl',\n title='Simulated Data: CCD PSF Recovery', truthx=theta1[7], truthy=theta1[8],\n requirementE=None, requirementFWHM=None, requirementR2=None)\n _plotModelResiduals(id='RunI1', folder='simulatedResults/', out='Residual1.pdf', individual=True)\n except:\n print 'No simulated data to plot...'\n\n #real data\n _plotDifferenceIndividualVsJoined(individuals=folder+'I800nm?.pkl', joined=folder+'J800nm.pkl', title='800nm',\n FWHMlims=(7.3, 11.8))\n\n _plotModelResiduals(id='I800nm2', folder=folder, out='ResidualData.pdf', individual=True)\n _plotModelResiduals(id='RunI2', folder='simulatedResults/', out='Residual2.pdf', individual=True)\n\n #_plotModelResiduals(id='G600nm0', folder=folder, out='ResidualG600.pdf', individual=True)\n #_plotModelResiduals(id='G700nm0', folder=folder, out='ResidualG700.pdf', individual=True)\n _plotModelResiduals(id='G800nm0', folder=folder, out='ResidualG800.pdf', individual=True)\n #_plotModelResiduals(id='G890nm0', folder=folder, out='ResidualG890.pdf', individual=True)\n\n #wavelength dependency\n plotLambdaDependency()\n\n #brighter fatter\n plotBrighterFatter()","def plot(self) -> List[matplotlib.figure.Figure]:\n figs = []\n\n title_prefix = self.trial_name + ' ' + self.segment_name + ' '\n # Figure 1, position in 3 subplots\n pos_fig_sub = self.plot_subplots(self.fig_num_start, title_prefix + 'Position (mm)', self.pos_raw,\n self.pos_smooth, self.pos_legend)\n figs.append(pos_fig_sub)\n\n # Figure 2, orientation in 3 subplots\n eul_fig_sub = self.plot_subplots(self.fig_num_start + 1, title_prefix + 'Euler Angles (deg)', self.eul_raw,\n self.eul_smooth, self.euler_legend)\n figs.append(eul_fig_sub)\n\n # Figure 3, velocity in 3 subplots\n vel_fig_sub = self.plot_subplots_vel(self.fig_num_start + 2, title_prefix + 'Velocity', 'Velocity (mm/s)',\n self.vel)\n figs.append(vel_fig_sub)\n\n # Figure 4, angular velocity in 3 subplots\n ang_vel_fig_sub = self.plot_subplots_vel(self.fig_num_start + 3, title_prefix + 'Angular Velocity',\n 'Angular Velocity (deg/s)', self.ang_vel)\n figs.append(ang_vel_fig_sub)\n\n # Figure 5, position in one axes\n pos_fig_one = self.plot_one_axes(self.fig_num_start + 4, title_prefix + 'Position', 'Position (mm)',\n self.pos_raw, self.pos_smooth, self.pos_legend)\n figs.append(pos_fig_one)\n\n # Figure 6, orientation in one axes\n eul_fig_one = self.plot_one_axes(self.fig_num_start + 5, title_prefix + 'Euler Angles', 'Angle (deg)',\n self.eul_raw, self.eul_smooth, self.euler_legend)\n figs.append(eul_fig_one)\n\n # Figure 7, velocity in one axes\n vel_fig_one = self.plot_one_axes_vel(self.fig_num_start + 6, title_prefix + 'Velocity', 'Velocity (mm/s)',\n self.vel, self.pos_legend)\n figs.append(vel_fig_one)\n\n # Figure 8, angular velocity in one axes\n ang_vel_fig_one = self.plot_one_axes_vel(self.fig_num_start + 7, title_prefix + 'Angular Velocity',\n 'Angular Velocity (deg/s)', self.ang_vel, self.pos_legend)\n figs.append(ang_vel_fig_one)\n\n return figs","def fig_2():\n epoch = 3\n N = 60000\n Nr = N\n K = 32\n n_iter = 256\n Nstar = 16\n data = 'dr10'\n factor = 100.\n features = ['psf_mag', 'model_colors', 'psf_minus_model']\n filters = ['r', 'ug gr ri iz', 'ugriz']\n message = 'pm_mc_pmm_r_all_all'\n model = 'xdmodel_%s_%d_%d_%d_%d_%s.pkl' % (data, Nr, K, n_iter, Nstar,\n message)\n model = os.environ['xddata'] + model\n figname = os.environ['xdplots'] + 'fig2.png'\n posteriors_plot(model, features, filters, figname, idx=-3)","def _plot(self, step, rewards, losses):\n plt.figure(figsize=(20, 5))\n plt.subplot(131)\n plt.title('Total Episode Reward')\n plt.plot(rewards)\n plt.subplot(132)\n plt.title('MSE Loss')\n plt.plot(losses)\n plt.show()","def visualize(**images):\n n_images = len(images)\n plt.figure(figsize=(20,8))\n for idx, (name, image) in enumerate(images.items()):\n plt.subplot(1, n_images, idx + 1)\n plt.xticks([]); \n plt.yticks([])\n # get title from the parameter names\n plt.title(name.replace('_',' ').title(), fontsize=20)\n plt.imshow(image)\n plt.savefig('sample_gt_pred_2_max.jpeg')\n plt.show()","def plot_steps(out_dict, units):\n from bokeh.models import BoxAnnotation\n from bokeh.plotting import figure, show, output_notebook\n import bokeh.models as bmd\n\n tooltips = [\n (\"Step (total)\", \"@index\"),\n (\"Step (stage)\", \"@step\"),\n (\"Energy\", \"@energy eV/atom\"),\n (\"Energy (dispersion)\", \"@dispersion_energy_au Ha\"),\n (\"SCF converged\", \"@scf_converged\"),\n (\"Cell A\", \"@cell_a_angs Angs\"),\n (\"Cell Vol\", \"@cell_vol_angs3 Angs^3\"),\n (\"MAX Step\", \"@max_step_au Bohr\"),\n (\"Pressure\", \"@pressure_bar bar\")\n ]\n hover = bmd.HoverTool(tooltips=tooltips)\n TOOLS = [\"pan\", \"wheel_zoom\", \"box_zoom\", \"reset\", \"save\", hover]\n\n natoms = out_dict['natoms']\n values = [ x/natoms*ha2u[units] for x in out_dict['step_info']['energy_au'] ]\n values = [ x-min(values) for x in values ]\n\n data = bmd.ColumnDataSource(data=dict( index=range(len(values)),\n step=out_dict['step_info']['step'],\n energy=values,\n dispersion_energy_au=out_dict['step_info']['dispersion_energy_au'],\n scf_converged=out_dict['step_info']['scf_converged'],\n cell_a_angs=out_dict['step_info']['cell_a_angs'],\n cell_vol_angs3=out_dict['step_info']['cell_vol_angs3'],\n max_step_au=out_dict['step_info']['max_step_au'],\n pressure_bar=out_dict['step_info']['pressure_bar'],\n ))\n\n p = figure(tools=TOOLS, title='Energy profile of the DFT minimization',\n height=350, width=550)\n\n p.xgrid.grid_line_color=None\n p.xaxis.axis_label = 'Steps'\n p.yaxis.axis_label = 'Energy ({}/atom)'.format(units)\n\n # Colored background\n colors = ['red','orange','green','yellow','cyan','pink','palegreen']\n start = 0\n for i,steps in enumerate(out_dict['stage_info']['nsteps']):\n end = start+steps\n p.add_layout(BoxAnnotation(left=start, right=end, fill_alpha=0.2, fill_color=colors[i]))\n start = end\n\n # Trace line and markers\n p.line('index', 'energy', source=data, line_color='blue')\n p.circle('index', 'energy', source=data, line_color='blue', size=3)\n return p","def make_plots(self,indices=None,hardcopy=False,hardcopydir='.',hardcopyprefix='',hardcopytype='png'):\n\t\tfor (i,E) in enumerate(self.experiments):\n\t\t\tif(indices==None) or (i in indices):\n\t\t\t\tE.show_plot(hardcopy,hardcopydir,hardcopyprefix,hardcopytype)","def do_compare_plots(cat7, cat7s, subdir,label):\n #Check the effect of the 5km/s split\n #dNdX\n cat7.plot_line_density(zmax=5)\n cat7s.plot_line_density(zmax=5, label=label)\n plt.legend(loc=0)\n save_figure(path.join(subdir,\"dndx_\"+label))\n plt.clf()\n\n #Omega_DLA\n cat7.plot_cddf(zmax=4,color=\"blue\")\n cat7s.plot_cddf(zmax=4,color=\"red\",label=label)\n plt.xlim(1e20, 1e23)\n plt.ylim(1e-28, 5e-21)\n plt.legend(loc=0)\n save_figure(path.join(subdir, \"cddf_\"+label))\n plt.clf()\n\n #Omega_DLA\n cat7.plot_omega_dla(zmax=5)\n cat7s.plot_omega_dla(zmax=5, label=label)\n plt.legend(loc=0)\n save_figure(path.join(subdir,\"omega_\"+label))\n plt.clf()","def fdd_plot(result_file_list,default_fdds,ion_default):\n # Getting data from the file\n fdd_param_keys = [result_file.split('_')[0] for result_file in result_file_list]\n# print \" Parameters to plot for:\", fdd_param_keys\n fig = plt.figure(figsize=(14,12))#(8.27,11.69))\n axs = [None]*(len(result_file_list)*5 + 1) # List of axes: 2 ions x (1 uncert + 1 value) + 1 for iterations (axs[0] will not be used)\n for j,result_file_name in enumerate(result_file_list):\n with open(result_file_name,'r') as res_file:\n res_data = res_file.read().split('\\n')\n if res_data[-1] == \"\": # delete empty line if present\n del res_data[-1]\n else:\n pass\n fdd_list, H_list, Hunc_list, D_list, Dunc_list, n_iter_list,fdd_iter_list = [[] for i in range(7)]\n for line in res_data:\n line_split = line.split()\n if line_split[1] == '0' or line_split[1] == '-1':\n fdd_list.append(float(line_split[0].split('_')[-1])) # fdd_list\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\n if line_split[1] == '0':\n n_iter_list.append(int(line_split[2])) # number of iterations list\n else:\n n_iter_list.append(-1) # 125, number of iterations\n H_list.append(float(line_split[3])) # H_list\n Hunc_list.append(float(line_split[4])) # Hunc_list\n D_list.append(float(line_split[5])) # D_list\n Dunc_list.append(float(line_split[6])) # Dunc_list\n elif line_split[1] == '1':\n print \" {} = {} <- excluded: error '1' (no f26 file was found, check 'stdout.dat' and 'stderr.dat')\".format(fdd_param_keys[j], line_split[0])\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\n n_iter_list.append(0) # number of iterations list\n elif line_split[1] == '2':\n print \" {} = {} <- excluded: error '2' (error happened during VPFITing, check 'stderr.dat')\".format(fdd_param_keys[j], line_split[0])\n\t\tfdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\n\t\tn_iter_list.append(0) # number of iterations list\n elif line_split[1] == '3':\n print \" {} = {} <- excluded: error '3' (zero size f26 file, check 'stdout.dat')\".format(fdd_param_keys[j], line_split[0])\n\t\tfdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\n\t\tn_iter_list.append(0) # number of iterations list\n elif line_split[1] == '4':\n print \" {} = {} <- excluded: error '4' (new and original f26's have different number of lines, check 'stdout.dat')\".format(fdd_param_keys[j], line_split[0])\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\n\t\tn_iter_list.append(-3) # number of iterations list\n elif line_split[1] == '5':\n print \" {} = {} <- excluded: error '5' ('****' uncertainty was found for one of specified ion! Check f26 file)\".format(fdd_param_keys[j], line_split[0])\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\n\t\tn_iter_list.append(-2) # number of iterations list\n else:\n print \" Unknown error code was specified in {}\".format(result_file_name)\n\n # Data are ready to plot\n # First column of subplots (uncertainties)\n axs[5*j+1] = plt.subplot(len(fdd_param_keys),3,3*j+1)\n axs[5*j+1].plot(fdd_list,Dunc_list,color='b',drawstyle=\"steps-mid\") # Plotting data\n axs[5*j+1].plot(default_fdds[fdd_param_keys[j]],ion_default[3],'bo',mew=0.0) # plotting default result\n axs[5*j+1].set_ylabel(r'$\\Delta$N(D I)',color='b')\n axs[5*j+1].tick_params('y',colors='b')\n axs[5*j+1].ticklabel_format(useOffset=False)\n axs[5*j+1].set_xscale('log')\n if fdd_param_keys[j] == 'fdbstep':\n axs[5*j+1].set_xlabel('{} [{:g}], km/s'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\n else:\n axs[5*j+1].set_xlabel('{} [{:g}]'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\n axs[5*j+1].axvline(default_fdds[fdd_param_keys[j]],linewidth=1,color='g') # indicate fdd from vp_setup.dat\n# axs[5*j+1].margins(y=np.ptp(Dunc_list)/2.0) # Include marging above and below the data to show default fdds\n axs[5*j+2] = axs[5*j+1].twinx() # second plot on the same axis\n axs[5*j+2].plot(fdd_list,Hunc_list,color='r',drawstyle=\"steps-mid\")\n axs[5*j+2].plot(default_fdds[fdd_param_keys[j]],ion_default[1],'ro',mew=0.0)\n axs[5*j+2].set_ylabel(r'$\\Delta$N(H I)',color='r')\n axs[5*j+2].tick_params('y',colors='r')\n axs[5*j+2].ticklabel_format(useOffset=False,axis='y')\n # Second column of subplots (middle values)\n axs[5*j+3] = plt.subplot(len(fdd_param_keys),3,3*j+2)\n plot_interal = False # Add 1-sigma interval\n if plot_interal == True:\n median = np.median(D_list)\n med_unc = np.median(Dunc_list)\n print \"median = {} +/- {} for {}\".format(median,med_unc,fdd_param_keys[j])\n axs[5*j+3].fill_between(fdd_list, median-med_unc, median+med_unc,facecolor='green', alpha=0.4)\n axs[5*j+3].plot(fdd_list,D_list,color='b',drawstyle=\"steps-mid\",zorder=2) # Plotting data\n axs[5*j+3].plot(default_fdds[fdd_param_keys[j]],ion_default[2],'bo',zorder=10,mew=0.0)\n axs[5*j+3].set_ylabel(r'N(D I)',color='b')\n axs[5*j+3].ticklabel_format(useOffset=False)\n axs[5*j+3].tick_params('y',colors='b')\n axs[5*j+3].set_xscale('log')\n if fdd_param_keys[j] == 'fdbstep':\n axs[5*j+3].set_xlabel('{} [{:g}], km/s'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\n else:\n axs[5*j+3].set_xlabel('{} [{:g}]'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\n axs[5*j+3].axvline(default_fdds[fdd_param_keys[j]],linewidth=1,color='g') # indicate fdd from vp_setup.dat\n# axs[5*j+3].margins(y=np.ptp(D_list),tight=False) # Include marging above and below the data to show default fdds\n axs[5*j+4] = axs[5*j+3].twinx()\n axs[5*j+4].plot(fdd_list,H_list,color='r',drawstyle=\"steps-mid\",zorder=1)\n axs[5*j+4].plot(default_fdds[fdd_param_keys[j]],ion_default[0],'ro',zorder=10,mew=0.0)\n axs[5*j+4].set_ylabel(r'N(H I)',color='r')\n axs[5*j+4].tick_params('y',colors='r')\n axs[5*j+4].ticklabel_format(useOffset=False,axis='y')\n # Third column of subplots (number of iterations)\n axs[5*j+5] = plt.subplot(len(fdd_param_keys),3,3*j+3)\n axs[5*j+5].plot(fdd_iter_list,n_iter_list,drawstyle=\"steps-mid\") # Plotting n_iter_list\n# axs[5*j+5].yaxis.tick_right()\n# axs[5*j+5].yaxis.set_label_position(\"right\")\n axs[5*j+5].set_ylabel('N iterations')\n axs[5*j+5].ticklabel_format(useOffset=False)\n axs[5*j+5].set_xscale('log')\n if fdd_param_keys[j] == 'fdbstep':\n axs[5*j+5].set_xlabel('{} [{:g}], km/s'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\n else:\n axs[5*j+5].set_xlabel('{} [{:g}]'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\n axs[5*j+5].axvline(default_fdds[fdd_param_keys[j]],linewidth=1,color='g') # indicate fdd from vp_setup.dat\n axs[5*j+5].axhline(0,linewidth=1,color='grey',ls=\":\") # indicate fdd from vp_setup.dat\n\n# plt.tight_layout()\n fig.subplots_adjust(hspace=0.3,wspace=0.9) # Set up spaces between subplots\n plt.savefig(\"fdd_plot.pdf\",bbox_inches='tight', pad_inches=0)\n plt.show()\n plt.close()\n print \" Plot is done!\"","def run(self):\n # fill the x_values,y_values,z_values dictionaries\n if not self.__fillCoordinatesFromSource():\n self.raiseAWarning('Nothing to Plot Yet. Returning.')\n return\n\n self.counter += 1\n if self.counter > 1:\n self.actcm = None\n clusterDict = deepcopy(self.outStreamTypes)\n\n # start plotting.... loop over the plots that need to be included in this figure\n for pltIndex in range(len(self.outStreamTypes)):\n plotSettings = self.options['plotSettings']['plot'][pltIndex]\n if 'gridLocation' in plotSettings:\n x = None\n y = None\n if 'x' in plotSettings['gridLocation']:\n x = list(map(int, plotSettings['gridLocation']['x'].strip().split(' ')))\n else:\n x = None\n if 'y' in plotSettings['gridLocation'].keys():\n y = list(map(int, plotSettings['gridLocation']['y'].strip().split(' ')))\n else:\n y = None\n if pltIndex == 0:\n self.ax.remove() # remove axis so that there is not an extra axis on plot with subplots\n if (len(x) == 1 and len(y) == 1):\n if self.dim == 2:\n self.ax = self.fig.add_subplot(self.gridSpace[x[0], y[0]])\n else:\n self.ax = self.fig.add_subplot(self.gridSpace[x[0], y[0]], projection='3d')\n elif (len(x) == 1 and len(y) != 1):\n if self.dim == 2:\n self.ax = self.fig.add_subplot(self.gridSpace[x[0], y[0]:y[-1]])\n else:\n self.ax = self.fig.add_subplot(self.gridSpace[x[0], y[0]:y[-1]], projection='3d')\n elif (len(x) != 1 and len(y) == 1):\n if self.dim == 2:\n self.ax = self.fig.add_subplot(self.gridSpace[x[0]:x[-1], y[0]])\n else:\n self.ax = self.fig.add_subplot(self.gridSpace[x[0]:x[-1], y[0]], projection='3d')\n else:\n if self.dim == 2:\n self.ax = self.fig.add_subplot(self.gridSpace[x[0]:x[-1], y[0]:y[-1]])\n else:\n self.ax = self.fig.add_subplot(self.gridSpace[x[0]:x[-1], y[0]:y[-1]], projection='3d')\n\n if 'gridSpace' in self.options['plotSettings']:\n self.ax.locator_params(axis='y', nbins=4)\n self.ax.locator_params(axis='x', nbins=2)\n if 'range' in plotSettings:\n axes_range = plotSettings['range']\n if 'ymin' in axes_range:\n self.ax.set_ylim(bottom=ast.literal_eval(axes_range['ymin']))\n if 'ymax' in axes_range:\n self.ax.set_ylim(top=ast.literal_eval(axes_range['ymax']))\n if 'xmin' in axes_range:\n self.ax.set_xlim(left=ast.literal_eval(axes_range['xmin']))\n if 'xmax' in axes_range:\n self.ax.set_xlim(right=ast.literal_eval(axes_range['xmax']))\n if self.dim == 3:\n if 'zmin' in axes_range.options['plotSettings']['plot'][pltIndex]:\n if 'zmax' not in axes_range.options['plotSettings']:\n self.raiseAWarning('zmin inputted but not zmax. zmin ignored! ')\n else:\n self.ax.set_zlim(bottom=ast.literal_eval(axes_range['zmin']), top=ast.literal_eval(self.options['plotSettings']['zmax']))\n if 'zmax' in axes_range:\n if 'zmin' not in axes_range:\n self.raiseAWarning('zmax inputted but not zmin. zmax ignored! ')\n else:\n self.ax.set_zlim(bottom=ast.literal_eval(axes_range['zmin']), top=ast.literal_eval(axes_range['zmax']))\n if 'xlabel' not in plotSettings:\n self.ax.set_xlabel('x')\n else:\n self.ax.set_xlabel(plotSettings['xlabel'])\n if 'ylabel' not in plotSettings:\n self.ax.set_ylabel('y')\n else:\n self.ax.set_ylabel(plotSettings['ylabel'])\n if 'zlabel' in plotSettings:\n if self.dim == 2:\n self.raiseAWarning('zlabel keyword does not make sense in 2-D Plots!')\n elif self.dim == 3 and self.zCoordinates:\n self.ax.set_zlabel(plotSettings['zlabel'])\n elif self.dim == 3 and self.zCoordinates:\n self.ax.set_zlabel('z')\n else:\n if 'xlabel' not in self.options['plotSettings']:\n self.ax.set_xlabel('x')\n else:\n self.ax.set_xlabel(self.options['plotSettings']['xlabel'])\n if 'ylabel' not in self.options['plotSettings']:\n self.ax.set_ylabel('y')\n else:\n self.ax.set_ylabel(self.options['plotSettings']['ylabel'])\n if 'zlabel' in self.options['plotSettings']:\n if self.dim == 2:\n self.raiseAWarning('zlabel keyword does not make sense in 2-D Plots!')\n elif self.dim == 3 and self.zCoordinates:\n self.ax.set_zlabel(self.options['plotSettings']['zlabel'])\n elif self.dim == 3 and self.zCoordinates:\n self.ax.set_zlabel('z')\n\n if 'legend' in self.options['plotSettings']:\n if 'label' not in plotSettings.get('attributes', {}):\n if 'attributes' not in plotSettings:\n plotSettings['attributes'] = {}\n plotSettings['attributes']['label'] = self.outStreamTypes[pltIndex] + ' ' + str(pltIndex)\n #################\n # SCATTER PLOT #\n #################\n self.raiseADebug(f'creating plot {self.name}')\n if self.outStreamTypes[pltIndex] == 'scatter':\n if 's' not in plotSettings:\n plotSettings['s'] = '20'\n if 'c' not in plotSettings:\n plotSettings['c'] = 'b'\n if 'marker' not in plotSettings:\n plotSettings['marker'] = 'o'\n if 'alpha' not in plotSettings:\n plotSettings['alpha'] = 'None'\n if 'linewidths' not in plotSettings:\n plotSettings['linewidths'] = 'None'\n if self.colorMapCoordinates[pltIndex] is not None:\n # Find the max and min colormap values\n firstKey = utils.first(self.xValues[pltIndex].keys())\n vmin = np.amin(self.colorMapValues[pltIndex][firstKey])\n vmax = np.amax(self.colorMapValues[pltIndex][firstKey])\n for key in self.xValues[pltIndex]:\n vmin = min(vmin,np.amin(self.colorMapValues[pltIndex][key]))\n vmax = max(vmax,np.amax(self.colorMapValues[pltIndex][key]))\n plotSettings['norm'] = matplotlib.colors.Normalize(vmin,vmax)\n for key in self.xValues[pltIndex]:\n for xIndex in range(len(self.xValues[pltIndex][key])):\n for yIndex in range(len(self.yValues[pltIndex][key])):\n scatterPlotOptions = {'s': ast.literal_eval(plotSettings['s']),\n 'marker': (plotSettings['marker']),\n 'alpha': ast.literal_eval(plotSettings['alpha']),\n 'linewidths': ast.literal_eval(plotSettings['linewidths'])}\n if self.colorMapCoordinates[pltIndex] is not None:\n scatterPlotOptions['norm'] = plotSettings['norm']\n scatterPlotOptions.update(plotSettings.get('attributes', {}))\n if self.dim == 2:\n if self.colorMapCoordinates[pltIndex] is not None:\n scatterPlotOptions['c'] = self.colorMapValues[pltIndex][key][xIndex]\n scatterPlotOptions['cmap'] = matplotlib.cm.get_cmap(\"winter\")\n if self.actcm:\n first = False\n else:\n first = True\n if plotSettings['cmap'] == 'None':\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n **scatterPlotOptions)\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n if first:\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_array(self.colorMapValues[pltIndex][key])\n self.actcm = self.fig.colorbar(m)\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n try:\n self.actcm.draw_all()\n # this is not good, what exception will be thrown?\n except:\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_array(self.colorMapValues[pltIndex][key])\n self.actcm = self.fig.colorbar(m)\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n scatterPlotOptions['cmap'] = plotSettings['cmap']\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n **scatterPlotOptions)\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n if first:\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_array(self.colorMapValues[pltIndex][key])\n self.actcm = self.fig.colorbar(m, ax=self.ax)\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_clim(vmin = min(self.colorMapValues[pltIndex][key][-1]), vmax=max(self.colorMapValues[pltIndex][key][-1]))\n self.actcm.draw_all()\n else:\n if 'color' not in scatterPlotOptions:\n scatterPlotOptions['c'] = plotSettings['c']\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n **scatterPlotOptions)\n else:\n for zIndex in range(len(self.zValues[pltIndex][key])):\n if self.colorMapCoordinates[pltIndex] is not None:\n scatterPlotOptions['c'] = self.colorMapValues[pltIndex][key][zIndex]\n if self.actcm:\n first = False\n else:\n first = True\n if plotSettings['cmap'] == 'None':\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], self.zValues[pltIndex][key][zIndex], **scatterPlotOptions)\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n if first:\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_array(self.colorMapValues[pltIndex][key])\n self.actcm = self.fig.colorbar(m)\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n self.actcm.draw_all()\n else:\n scatterPlotOptions['cmap'] = plotSettings['cmap']\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], self.zValues[pltIndex][key][zIndex], **scatterPlotOptions)\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n if first:\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_array(self.colorMapValues[pltIndex][key])\n self.actcm = self.fig.colorbar(m)\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n m = matplotlib.cm.ScalarMappable(cmap = self.actPlot.cmap, norm = self.actPlot.norm)\n m.set_clim(vmin = min(self.colorMapValues[pltIndex][key][-1]), vmax=max(self.colorMapValues[pltIndex][key][-1]))\n self.actcm.draw_all()\n else:\n if 'color' not in scatterPlotOptions:\n scatterPlotOptions['c'] = plotSettings['c']\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], self.zValues[pltIndex][key][zIndex], **scatterPlotOptions)\n #################\n # LINE PLOT #\n #################\n elif self.outStreamTypes[pltIndex] == 'line':\n minV = 0\n maxV = 0\n # If the user does not define an appropriate cmap, then use matplotlib's default.\n if 'cmap' not in plotSettings or plotSettings['cmap'] not in matplotlib.cm.datad:\n plotSettings['cmap'] = None\n if bool(self.colorMapValues):\n for key in self.xValues[pltIndex]:\n minV = min(minV,self.colorMapValues[pltIndex][key][-1][-1])\n maxV = max(maxV,self.colorMapValues[pltIndex][key][-1][-1])\n cmap = matplotlib.cm.ScalarMappable(matplotlib.colors.Normalize(minV, maxV, True), plotSettings['cmap'])\n cmap.set_array([minV,maxV])\n for key in self.xValues[pltIndex]:\n for xIndex in range(len(self.xValues[pltIndex][key])):\n if self.colorMapCoordinates[pltIndex] is not None:\n plotSettings['interpPointsX'] = str(max(200, len(self.xValues[pltIndex][key][xIndex])))\n for yIndex in range(len(self.yValues[pltIndex][key])):\n if self.dim == 2:\n if self.yValues[pltIndex][key][yIndex].size < 2:\n return\n xi, yi = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], plotSettings, returnCoordinate=True)\n if self.colorMapCoordinates[pltIndex] is not None:\n self.ax.plot(xi, yi, c=cmap.cmap(self.colorMapValues[pltIndex][key][-1][-1]/(maxV-minV)))\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n if self.actcm is None:\n self.actcm = self.fig.colorbar(cmap)\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n self.actcm.draw_all()\n else:\n self.actPlot = self.ax.plot(xi, yi, **plotSettings.get('attributes', {}))\n else:\n for zIndex in range(len(self.zValues[pltIndex][key])):\n if self.zValues[pltIndex][key][zIndex].size <= 3:\n return\n if self.colorMapCoordinates[pltIndex] is not None:\n self.ax.plot(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n self.zValues[pltIndex][key][zIndex],\n c=cmap.cmap(self.colorMapValues[pltIndex][key][-1][-1]/(maxV-minV)))\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n if self.actcm is None:\n self.actcm = self.fig.colorbar(cmap)\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n self.actcm.draw_all()\n else:\n self.actPlot = self.ax.plot(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n self.zValues[pltIndex][key][zIndex],\n **plotSettings.get('attributes', {}))\n ##################\n # HISTOGRAM PLOT #\n ##################\n elif self.outStreamTypes[pltIndex] == 'histogram':\n if 'bins' not in plotSettings:\n if self.dim == 2:\n plotSettings['bins'] = '10'\n else:\n plotSettings['bins'] = '4'\n if 'normed' not in plotSettings:\n plotSettings['normed'] = 'False'\n if 'weights' not in plotSettings:\n plotSettings['weights'] = 'None'\n if 'cumulative' not in plotSettings:\n plotSettings['cumulative'] = 'False'\n if 'histtype' not in plotSettings:\n plotSettings['histtype'] = 'bar'\n if 'align' not in plotSettings:\n plotSettings['align'] = 'mid'\n if 'orientation' not in plotSettings:\n plotSettings['orientation'] = 'vertical'\n if 'rwidth' not in plotSettings:\n plotSettings['rwidth'] = 'None'\n if 'log' not in plotSettings:\n plotSettings['log'] = 'None'\n if 'color' not in plotSettings:\n plotSettings['color'] = 'b'\n if 'stacked' not in plotSettings:\n plotSettings['stacked'] = 'None'\n if self.sourceData[0].type.strip() == 'HistorySet':\n #####################################################################################################################################\n # @MANDD: This 'if' condition has been added in order to allow the user the correctly create an histogram out of an historySet #\n # If the histogram is created out of the input variables, then the plot has an identical meaning of the one generated by a pointSet #\n # However, if the histogram is created out of the output variables, then the plot consider only the last value of the array #\n #####################################################################################################################################\n data = {}\n data['x'] = np.empty(0)\n data['y'] = np.empty(0)\n for index in range(len(self.outStreamTypes)):\n for key in self.xValues[index]:\n data['x'] = np.append(data['x'], self.xValues[index][key][0][-1])\n if self.dim == 3:\n data['y'] = np.append(data['y'], self.yValues[index][key][0][-1])\n del self.xValues[index]\n self.xValues = {}\n self.xValues[index] = {}\n self.xValues[index][0] = []\n self.xValues[index][0].append(deepcopy(data['x']))\n if self.dim == 3:\n del self.yValues[index]\n self.yValues = {}\n self.yValues[index] ={ }\n self.yValues[index][0] = []\n self.yValues[index][0].append(deepcopy(data['y']))\n\n for key in self.xValues[pltIndex]:\n for xIndex in range(len(self.xValues[pltIndex][key])):\n try:\n colorss = ast.literal_eval(plotSettings['color'])\n # unknown what specific error is anticipated here, but I don't like a bare except...\n # ast.literal_eval can raise the exceptions listed below (see library docs):\n except (ValueError, TypeError, SyntaxError, MemoryError, RecursionError):\n colorss = plotSettings['color']\n if self.dim == 2:\n self.ax.hist(self.xValues[pltIndex][key][xIndex],\n bins=ast.literal_eval(plotSettings['bins']),\n density=ast.literal_eval(plotSettings['normed']),\n weights=ast.literal_eval(plotSettings['weights']),\n cumulative=ast.literal_eval(plotSettings['cumulative']),\n histtype=plotSettings['histtype'],\n align=plotSettings['align'],\n orientation=plotSettings['orientation'],\n rwidth=ast.literal_eval(plotSettings['rwidth']),\n log=ast.literal_eval(plotSettings['log']),\n color=colorss,\n stacked=ast.literal_eval(plotSettings['stacked']),\n **plotSettings.get('attributes', {}))\n else:\n for yIndex in range(len(self.yValues[pltIndex][key])):\n hist, xedges, yedges = np.histogram2d(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n bins=ast.literal_eval(plotSettings['bins']))\n elements = (len(xedges) - 1) * (len(yedges) - 1)\n if 'x_offset' in plotSettings:\n xoffset = float(plotSettings['x_offset'])\n else:\n xoffset = 0.25\n if 'y_offset' in plotSettings:\n yoffset = float(plotSettings['y_offset'])\n else:\n yoffset = 0.25\n if 'dx' in plotSettings:\n dxs = float(plotSettings['dx'])\n else:\n dxs = (self.xValues[pltIndex][key][xIndex].max() - self.xValues[pltIndex][key][xIndex].min()) / float(plotSettings['bins'])\n if 'dy' in plotSettings:\n dys = float(plotSettings['dy'])\n else:\n dys = (self.yValues[pltIndex][key][yIndex].max() - self.yValues[pltIndex][key][yIndex].min()) / float(plotSettings['bins'])\n xpos, ypos = np.meshgrid(xedges[:-1] + xoffset, yedges[:-1] + yoffset)\n self.actPlot = self.ax.bar3d(xpos.flatten(),\n ypos.flatten(),\n np.zeros(elements),\n dxs*np.ones_like(elements),\n dys*np.ones_like(elements),\n hist.flatten(),\n color=colorss,\n zsort='average',\n **plotSettings.get('attributes', {}))\n ##################\n # STEM PLOT #\n ##################\n elif self.outStreamTypes[pltIndex] == 'stem':\n if 'linefmt' not in plotSettings:\n plotSettings['linefmt'] = 'b-'\n if 'markerfmt' not in plotSettings:\n plotSettings['markerfmt'] = 'bo'\n if 'basefmt' not in plotSettings:\n plotSettings['basefmt'] = 'r-'\n for key in self.xValues[pltIndex]:\n for xIndex in range(len(self.xValues[pltIndex][key])):\n for yIndex in range(len(self.yValues[pltIndex][key])):\n if self.dim == 2:\n self.actPlot = self.ax.stem(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n linefmt=plotSettings['linefmt'],\n markerfmt=plotSettings['markerfmt'],\n basefmt = plotSettings['linefmt'],\n use_line_collection=True,\n **plotSettings.get('attributes', {}))\n else:\n # it is a basic stem plot constructed using a standard line plot. For now we do not use the previous defined keywords...\n for zIndex in range(len(self.zValues[pltIndex][key])):\n for xx, yy, zz in zip(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], self.zValues[pltIndex][key][zIndex]):\n self.ax.plot([xx, xx], [yy, yy], [0, zz], '-')\n ##################\n # STEP PLOT #\n ##################\n elif self.outStreamTypes[pltIndex] == 'step':\n if self.dim == 2:\n if 'where' not in plotSettings:\n plotSettings['where'] = 'mid'\n for key in self.xValues[pltIndex]:\n for xIndex in range(len(self.xValues[pltIndex][key])):\n if self.xValues[pltIndex][key][xIndex].size < 2:\n xi = self.xValues[pltIndex][key][xIndex]\n else:\n xi = np.linspace(self.xValues[pltIndex][key][xIndex].min(), self.xValues[pltIndex][key][xIndex].max(), ast.literal_eval(plotSettings['interpPointsX']))\n for yIndex in range(len(self.yValues[pltIndex][key])):\n if self.yValues[pltIndex][key][yIndex].size <= 3:\n return\n yi = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], plotSettings)\n self.actPlot = self.ax.step(xi, yi, where=plotSettings['where'], **plotSettings.get('attributes', {}))\n else:\n self.raiseAWarning('step Plot not available in 3D')\n return\n ########################\n # PSEUDOCOLOR PLOT #\n ########################\n elif self.outStreamTypes[pltIndex] == 'pseudocolor':\n if self.dim == 2:\n for key in self.xValues[pltIndex]:\n for xIndex in range(len(self.xValues[pltIndex][key])):\n # Hopefully, x,y, and z are all the same length, so checking this\n # here should be good enough.\n # The problem is you cannot interpolate any amount of space if\n # you only have a single data point.\n if self.xValues[pltIndex][key][xIndex].size == 1:\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\n continue\n for yIndex in range(len(self.yValues[pltIndex][key])):\n if not self.colorMapCoordinates:\n self.raiseAMessage('pseudocolor Plot needs coordinates for color map... Returning without plotting')\n return\n for zIndex in range(len(self.colorMapValues[pltIndex][key])):\n if self.colorMapValues[pltIndex][key][zIndex].size <= 3:\n return\n xig, yig, Ci = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n plotSettings,\n z=self.colorMapValues[pltIndex][key][zIndex],\n returnCoordinate=True)\n if plotSettings['cmap'] == 'None':\n self.actPlot = self.ax.pcolormesh(xig,\n yig,\n ma.masked_where(np.isnan(Ci), Ci),\n **plotSettings.get('attributes', {}))\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n else:\n self.actPlot = self.ax.pcolormesh(xig,\n yig,\n ma.masked_where(np.isnan(Ci), Ci),\n cmap=matplotlib.cm.get_cmap(name = plotSettings['cmap']),\n **plotSettings.get('attributes', {}))\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_array(ma.masked_where(np.isnan(Ci), Ci))\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n actcm = self.fig.colorbar(m)\n actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n self.raiseAWarning('pseudocolor Plot is considered a 2D plot, not a 3D!')\n return\n ########################\n # SURFACE PLOT #\n ########################\n elif self.outStreamTypes[pltIndex] == 'surface':\n if self.dim == 2:\n self.raiseAWarning('surface Plot is NOT available for 2D plots, IT IS A 3D!')\n return\n else:\n if 'rstride' not in plotSettings:\n plotSettings['rstride'] = '1'\n if 'cstride' not in plotSettings:\n plotSettings['cstride'] = '1'\n if 'antialiased' not in plotSettings:\n plotSettings['antialiased'] = 'False'\n if 'linewidth' not in plotSettings:\n plotSettings['linewidth'] = '0'\n for key in self.xValues[pltIndex]:\n for xIndex in range(len(self.xValues[pltIndex][key])):\n # Hopefully, x,y, and z are all the same length, so checking this\n # here should be good enough.\n # The problem is you cannot interpolate any amount of space if\n # you only have a single data point.\n if self.xValues[pltIndex][key][xIndex].size == 1:\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\n continue\n for yIndex in range(len(self.yValues[pltIndex][key])):\n for zIndex in range(len(self.zValues[pltIndex][key])):\n if self.zValues[pltIndex][key][zIndex].size <= 3:\n return\n if self.colorMapCoordinates[pltIndex] is not None:\n xig, yig, Ci = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n plotSettings,\n z=self.colorMapValues[pltIndex][key][zIndex],\n returnCoordinate=True)\n xig, yig, zi = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n plotSettings,\n z=self.zValues[pltIndex][key][zIndex],\n returnCoordinate=True)\n if self.colorMapCoordinates[pltIndex] is not None:\n if self.actcm:\n first = False\n else:\n first = True\n if plotSettings['cmap'] == 'None':\n plotSettings['cmap'] = 'jet'\n self.actPlot = self.ax.plot_surface(xig,\n yig,\n ma.masked_where(np.isnan(zi), zi),\n rstride=ast.literal_eval(plotSettings['rstride']),\n cstride=ast.literal_eval(plotSettings['cstride']),\n facecolors=matplotlib.cm.get_cmap(name=plotSettings['cmap'])(ma.masked_where(np.isnan(Ci), Ci)),\n cmap=matplotlib.cm.get_cmap(name = plotSettings['cmap']),\n linewidth=ast.literal_eval(plotSettings['linewidth']),\n antialiased=ast.literal_eval(plotSettings['antialiased']),\n **plotSettings.get('attributes', {}))\n if first:\n self.actPlot.cmap = matplotlib.cm.get_cmap(name=plotSettings['cmap'])\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n if first:\n m = matplotlib.cm.ScalarMappable(cmap = self.actPlot.cmap, norm = self.actPlot.norm)\n m.set_array(self.colorMapValues[pltIndex][key])\n self.actcm = self.fig.colorbar(m)\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_clim(vmin=min(self.colorMapValues[pltIndex][key][-1]), vmax=max(self.colorMapValues[pltIndex][key][-1]))\n self.actcm.draw_all()\n else:\n if plotSettings['cmap'] == 'None':\n self.actPlot = self.ax.plot_surface(xig,\n yig,\n ma.masked_where(np.isnan(zi), zi),\n rstride=ast.literal_eval(plotSettings['rstride']),\n cstride=ast.literal_eval(plotSettings['cstride']),\n linewidth=ast.literal_eval(plotSettings['linewidth']),\n antialiased=ast.literal_eval(plotSettings['antialiased']),\n **plotSettings.get('attributes', {}))\n if 'color' in plotSettings.get('attributes', {}):\n self.actPlot.set_color = plotSettings.get('attributes', {})['color']\n else:\n self.actPlot.set_color = 'blue'\n else:\n self.actPlot = self.ax.plot_surface(xig,\n yig,\n ma.masked_where(np.isnan(zi), zi),\n rstride=ast.literal_eval(plotSettings['rstride']),\n cstride=ast.literal_eval(plotSettings['cstride']),\n cmap=matplotlib.cm.get_cmap(name = plotSettings['cmap']),\n linewidth=ast.literal_eval(plotSettings['linewidth']),\n antialiased=ast.literal_eval(plotSettings['antialiased']),\n **plotSettings.get('attributes', {}))\n ########################\n # TRI-SURFACE PLOT #\n ########################\n elif self.outStreamTypes[pltIndex] == 'tri-surface':\n if self.dim == 2:\n self.raiseAWarning('TRI-surface Plot is NOT available for 2D plots, it is 3D!')\n return\n else:\n if 'color' not in plotSettings:\n plotSettings['color'] = 'b'\n if 'shade' not in plotSettings:\n plotSettings['shade'] = 'False'\n for key in self.xValues[pltIndex]:\n for xIndex in range(len(self.xValues[pltIndex][key])):\n # Hopefully, x,y, and z are all the same length, so checking this\n # here should be good enough.\n # The problem is you cannot interpolate any amount of space if\n # you only have a single data point.\n if self.xValues[pltIndex][key][xIndex].size == 1:\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\n continue\n for yIndex in range(len(self.yValues[pltIndex][key])):\n for zIndex in range(len(self.zValues[pltIndex][key])):\n metric = (self.xValues[pltIndex][key][xIndex] ** 2 + self.yValues[pltIndex][key][yIndex] ** 2) ** 0.5\n metricIndeces = np.argsort(metric)\n xs = np.zeros(self.xValues[pltIndex][key][xIndex].shape)\n ys = np.zeros(self.yValues[pltIndex][key][yIndex].shape)\n zs = np.zeros(self.zValues[pltIndex][key][zIndex].shape)\n for sindex in range(len(metricIndeces)):\n xs[sindex] = self.xValues[pltIndex][key][xIndex][metricIndeces[sindex]]\n ys[sindex] = self.yValues[pltIndex][key][yIndex][metricIndeces[sindex]]\n zs[sindex] = self.zValues[pltIndex][key][zIndex][metricIndeces[sindex]]\n surfacePlotOptions = {'color': plotSettings['color'],\n 'shade': ast.literal_eval(plotSettings['shade'])}\n surfacePlotOptions.update(plotSettings.get('attributes', {}))\n if self.zValues[pltIndex][key][zIndex].size <= 3:\n return\n if self.colorMapCoordinates[pltIndex] is not None:\n if self.actcm:\n first = False\n else:\n first = True\n if plotSettings['cmap'] == 'None':\n plotSettings['cmap'] = 'jet'\n surfacePlotOptions['cmap'] = matplotlib.cm.get_cmap(name = plotSettings['cmap'])\n self.actPlot = self.ax.plot_trisurf(xs, ys, zs, **surfacePlotOptions)\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n if first:\n self.actPlot.cmap = matplotlib.cm.get_cmap(name=plotSettings['cmap'])\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_array(self.colorMapValues[pltIndex][key])\n self.actcm = self.fig.colorbar(m)\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_clim(vmin=min(self.colorMapValues[pltIndex][key][-1]), vmax=max(self.colorMapValues[pltIndex][key][-1]))\n self.actcm.draw_all()\n else:\n if plotSettings['cmap'] != 'None':\n surfacePlotOptions[\"cmap\"] = matplotlib.cm.get_cmap(name=plotSettings['cmap'])\n self.actPlot = self.ax.plot_trisurf(xs, ys, zs, **surfacePlotOptions)\n ########################\n # WIREFRAME PLOT #\n ########################\n elif self.outStreamTypes[pltIndex] == 'wireframe':\n if self.dim == 2:\n self.raiseAWarning('wireframe Plot is NOT available for 2D plots, IT IS A 3D!')\n return\n else:\n if 'rstride' not in plotSettings:\n plotSettings['rstride'] = '1'\n if 'cstride' not in plotSettings:\n plotSettings['cstride'] = '1'\n for key in self.xValues[pltIndex]:\n for xIndex in range(len(self.xValues[pltIndex][key])):\n # Hopefully, x,y, and z are all the same length, so checking this\n # here should be good enough.\n # The problem is you cannot interpolate any amount of space if\n # you only have a single data point.\n if self.xValues[pltIndex][key][xIndex].size == 1:\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\n continue\n for yIndex in range(len(self.yValues[pltIndex][key])):\n for zIndex in range(len(self.zValues[pltIndex][key])):\n if self.zValues[pltIndex][key][zIndex].size <= 3:\n return\n if self.colorMapCoordinates[pltIndex] is not None:\n xig, yig, Ci = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n plotSettings,\n z=self.colorMapValues[pltIndex][key][zIndex],\n returnCoordinate=True)\n xig, yig, zi = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n plotSettings,\n z=self.zValues[pltIndex][key][zIndex],\n returnCoordinate=True)\n if self.colorMapCoordinates[pltIndex] is not None:\n self.raiseAWarning(f'Currently, ax.plot_wireframe() in MatPlotLib version: {matplotlib.__version__} does not support a colormap! Wireframe plotted on a surface plot...')\n if self.actcm:\n first = False\n else:\n first = True\n if plotSettings['cmap'] == 'None':\n plotSettings['cmap'] = 'jet'\n self.actPlot = self.ax.plot_wireframe(xig,\n yig,\n ma.masked_where(np.isnan(zi), zi),\n rstride=ast.literal_eval(plotSettings['rstride']),\n cmap=matplotlib.cm.get_cmap(name = plotSettings['cmap']),\n cstride=ast.literal_eval(plotSettings['cstride']),\n **plotSettings.get('attributes', {}))\n self.actPlot = self.ax.plot_surface(xig,\n yig,\n ma.masked_where(np.isnan(zi), zi),\n alpha=0.4,\n rstride=ast.literal_eval(plotSettings['rstride']),\n cmap=matplotlib.cm.get_cmap(name=plotSettings['cmap']),\n cstride=ast.literal_eval(plotSettings['cstride']),\n **plotSettings.get('attributes', {}))\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n if first:\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_array(self.colorMapValues[pltIndex][key])\n self.actcm = self.fig.colorbar(m)\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_clim(vmin=min(self.colorMapValues[pltIndex][key][-1]), vmax=max(self.colorMapValues[pltIndex][key][-1]))\n self.actcm.draw_all()\n else:\n if plotSettings['cmap'] == 'None':\n self.actPlot = self.ax.plot_wireframe(xig,\n yig,\n ma.masked_where(np.isnan(zi), zi),\n rstride=ast.literal_eval(plotSettings['rstride']),\n cstride=ast.literal_eval(plotSettings['cstride']),\n **plotSettings.get('attributes', {}))\n if 'color' in plotSettings.get('attributes', {}):\n self.actPlot.set_color = plotSettings.get('attributes', {})['color']\n else:\n self.actPlot.set_color = 'blue'\n else:\n self.actPlot = self.ax.plot_wireframe(xig,\n yig,\n ma.masked_where(np.isnan(zi), zi),\n rstride=ast.literal_eval(plotSettings['rstride']),\n cstride=ast.literal_eval(plotSettings['cstride']),\n **plotSettings.get('attributes', {}))\n ########################\n # CONTOUR PLOT #\n ########################\n elif self.outStreamTypes[pltIndex] == 'contour' or self.outStreamTypes[pltIndex] == 'filledContour':\n if self.dim == 2:\n if 'numberBins' in plotSettings:\n nbins = int(plotSettings['numberBins'])\n else:\n nbins = 5\n for key in self.xValues[pltIndex]:\n if not self.colorMapCoordinates:\n self.raiseAWarning(self.outStreamTypes[pltIndex] + ' Plot needs coordinates for color map... Returning without plotting')\n return\n for xIndex in range(len(self.xValues[pltIndex][key])):\n # Hopefully, x,y, and z are all the same length, so checking this\n # here should be good enough.\n # The problem is you cannot interpolate any amount of space if\n # you only have a single data point.\n if self.xValues[pltIndex][key][xIndex].size == 1:\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\n continue\n for yIndex in range(len(self.yValues[pltIndex][key])):\n for zIndex in range(len(self.colorMapValues[pltIndex][key])):\n if self.actcm:\n first = False\n else:\n first = True\n xig, yig, Ci = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n plotSettings,\n z=self.colorMapValues[pltIndex][key][zIndex],\n returnCoordinate=True)\n if self.outStreamTypes[pltIndex] == 'contour':\n if plotSettings['cmap'] == 'None':\n if 'color' in plotSettings.get('attributes', {}):\n color = plotSettings.get('attributes', {})['color']\n else:\n color = 'blue'\n self.actPlot = self.ax.contour(xig,\n yig,\n ma.masked_where(np.isnan(Ci), Ci),\n nbins,\n colors=color,\n **plotSettings.get('attributes', {}))\n else:\n self.actPlot = self.ax.contour(xig,\n yig,\n ma.masked_where(np.isnan(Ci), Ci),\n nbins,\n **plotSettings.get('attributes', {}))\n else:\n if plotSettings['cmap'] == 'None':\n plotSettings['cmap'] = 'jet'\n self.actPlot = self.ax.contourf(xig,\n yig,\n ma.masked_where(np.isnan(Ci), Ci),\n nbins,\n **plotSettings.get('attributes', {}))\n self.ax.clabel(self.actPlot, inline=1, fontsize=10)\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n if first:\n self.actcm = self.fig.colorbar(self.actPlot, shrink=0.8, extend='both')\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n m = matplotlib.cm.ScalarMappable(cmap = self.actPlot.cmap, norm = self.actPlot.norm)\n m.set_clim(vmin = min(self.colorMapValues[pltIndex][key][-1]), vmax = max(self.colorMapValues[pltIndex][key][-1]))\n self.actcm.draw_all()\n else:\n self.raiseAWarning('contour/filledContour is a 2-D plot, where x,y are the surface coordinates and colorMap vector is the array to visualize!\\n contour3D/filledContour3D are 3-D! ')\n return\n # These should be combined: ^^^ & vvv\n elif self.outStreamTypes[pltIndex] == 'contour3D' or self.outStreamTypes[pltIndex] == 'filledContour3D':\n if self.dim == 2:\n self.raiseAWarning('contour3D/filledContour3D Plot is NOT available for 2D plots, IT IS A 2D! Check \"contour/filledContour\"!')\n return\n else:\n if 'numberBins' in plotSettings:\n nbins = int(plotSettings['numberBins'])\n else:\n nbins = 5\n if 'extend3D' in plotSettings:\n ext3D = bool(plotSettings['extend3D'])\n else:\n ext3D = False\n for key in self.xValues[pltIndex]:\n for xIndex in range(len(self.xValues[pltIndex][key])):\n # Hopefully, x,y, and z are all the same length, so checking this\n # here should be good enough.\n # The problem is you cannot interpolate any amount of space if\n # you only have a single data point.\n if self.xValues[pltIndex][key][xIndex].size == 1:\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\n continue\n for yIndex in range(len(self.yValues[pltIndex][key])):\n for zIndex in range(len(self.colorMapValues[pltIndex][key])):\n if self.actcm:\n first = False\n else:\n first = True\n xig, yig, Ci = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n plotSettings,\n z=self.colorMapValues[pltIndex][key][zIndex],\n returnCoordinate=True)\n if self.outStreamTypes[pltIndex] == 'contour3D':\n if plotSettings['cmap'] == 'None':\n if 'color' in plotSettings.get('attributes', {}):\n color = plotSettings.get('attributes', {})['color']\n else:\n color = 'blue'\n self.actPlot = self.ax.contour3D(xig,\n yig,\n ma.masked_where(np.isnan(Ci), Ci),\n nbins,\n colors=color,\n extend3d=ext3D,\n **plotSettings.get('attributes', {}))\n else:\n self.actPlot = self.ax.contour3D(xig,\n yig,\n ma.masked_where(np.isnan(Ci), Ci),\n nbins,\n extend3d=ext3D,\n cmap=matplotlib.cm.get_cmap(name=plotSettings['cmap']),\n **plotSettings.get('attributes', {}))\n else:\n if plotSettings['cmap'] == 'None':\n plotSettings['cmap'] = 'jet'\n self.actPlot = self.ax.contourf3D(xig,\n yig,\n ma.masked_where(np.isnan(Ci), Ci),\n nbins,\n cmap=matplotlib.cm.get_cmap(name=plotSettings['cmap']),\n **plotSettings.get('attributes', {}))\n self.ax.clabel(self.actPlot, inline=1, fontsize=10)\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n if first:\n self.actcm = self.fig.colorbar(self.actPlot, shrink = 0.8, extend = 'both')\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n m = matplotlib.cm.ScalarMappable(cmap = self.actPlot.cmap, norm = self.actPlot.norm)\n m.set_clim(vmin = min(self.colorMapValues[pltIndex][key][-1]), vmax = max(self.colorMapValues[pltIndex][key][-1]))\n self.actcm.draw_all()\n ########################\n # DataMining PLOT #\n ########################\n elif self.outStreamTypes[pltIndex] == 'dataMining':\n colors = cycle(['#88CCEE', '#DDCC77', '#AA4499', '#117733', '#332288', '#999933', '#44AA99', '#882255', '#CC6677', '#CD6677', '#DC6877', '#886677', '#AA6677', '#556677', '#CD7865'])\n if 's' not in plotSettings:\n plotSettings['s'] = '20'\n if 'c' not in plotSettings:\n plotSettings['c'] = 'b'\n if 'marker' not in plotSettings:\n plotSettings['marker'] = 'o'\n if 'alpha' not in plotSettings:\n plotSettings['alpha'] = 'None'\n if 'linewidths' not in plotSettings:\n plotSettings['linewidths'] = 'None'\n clusterDict[pltIndex] = {}\n for key in self.xValues[pltIndex]:\n for xIndex in range(len(self.xValues[pltIndex][key])):\n for yIndex in range(len(self.yValues[pltIndex][key])):\n dataMiningPlotOptions = {'s': ast.literal_eval(plotSettings['s']),\n 'marker': (plotSettings['marker']),\n 'alpha': ast.literal_eval(plotSettings['alpha']),\n 'linewidths': ast.literal_eval(plotSettings['linewidths'])}\n if self.colorMapCoordinates[pltIndex] is not None:\n self.raiseAWarning('ColorMap values supplied, however DataMining plots do not use colorMap from input.')\n if plotSettings['cmap'] == 'None':\n self.raiseAWarning('ColorSet supplied, however DataMining plots do not use color set from input.')\n if 'cluster' == plotSettings['SKLtype']:\n # TODO: include the cluster Centers to the plot\n if 'noClusters' in plotSettings.get('attributes', {}):\n clusterDict[pltIndex]['noClusters'] = int(plotSettings.get('attributes', {})['noClusters'])\n plotSettings.get('attributes', {}).pop('noClusters')\n else:\n clusterDict[pltIndex]['noClusters'] = np.amax(self.clusterValues[pltIndex][1][0]) + 1\n dataMiningPlotOptions.update(plotSettings.get('attributes', {}))\n if self.dim == 2:\n clusterDict[pltIndex]['clusterValues'] = np.zeros(shape=(len(self.xValues[pltIndex][key][xIndex]), 2))\n else:\n clusterDict[pltIndex]['clusterValues'] = np.zeros(shape=(len(self.xValues[pltIndex][key][xIndex]), 3))\n clusterDict[pltIndex]['clusterValues'][:, 0] = self.xValues[pltIndex][key][xIndex]\n clusterDict[pltIndex]['clusterValues'][:, 1] = self.yValues[pltIndex][key][yIndex]\n if self.dim == 2:\n for k, col in zip(range(int(clusterDict[pltIndex]['noClusters'])), colors):\n myMembers = self.clusterValues[pltIndex][1][0] == k\n self.actPlot = self.ax.scatter(clusterDict[pltIndex]['clusterValues'][myMembers, 0],\n clusterDict[pltIndex]['clusterValues'][myMembers, 1],\n color=col,\n **dataMiningPlotOptions)\n\n # Handle all of the outlying data\n myMembers = self.clusterValues[pltIndex][1][0] == -1\n # resize the points\n dataMiningPlotOptions['s'] /= 2\n # and hollow out their markers\n if 'facecolors' in dataMiningPlotOptions:\n faceColors = dataMiningPlotOptions['facecolors']\n else:\n faceColors = None\n dataMiningPlotOptions['facecolors'] = 'none'\n\n self.actPlot = self.ax.scatter(clusterDict[pltIndex]['clusterValues'][myMembers, 0],\n clusterDict[pltIndex]['clusterValues'][myMembers, 1],\n color='#000000',\n **dataMiningPlotOptions)\n\n # Restore the plot options to their original values\n dataMiningPlotOptions['s'] *= 2\n if faceColors is not None:\n dataMiningPlotOptions['facecolors'] = faceColors\n else:\n del dataMiningPlotOptions['facecolors']\n\n else:\n for zIndex in range(len(self.zValues[pltIndex][key])):\n clusterDict[pltIndex]['clusterValues'][:, 2] = self.zValues[pltIndex][key][zIndex]\n for k, col in zip(range(int(clusterDict[pltIndex]['noClusters'])), colors):\n myMembers = self.clusterValues[pltIndex][1][0] == k\n self.actPlot = self.ax.scatter(clusterDict[pltIndex]['clusterValues'][myMembers, 0],\n clusterDict[pltIndex]['clusterValues'][myMembers, 1],\n clusterDict[pltIndex]['clusterValues'][myMembers, 2],\n color=col,\n **dataMiningPlotOptions)\n\n # Handle all of the outlying data\n myMembers = self.clusterValues[pltIndex][1][0] == -1\n # resize the points\n dataMiningPlotOptions['s'] /= 2\n # and hollow out their markers\n if 'facecolors' in dataMiningPlotOptions:\n faceColors = dataMiningPlotOptions['facecolors']\n else:\n faceColors = None\n dataMiningPlotOptions['facecolors'] = 'none'\n\n self.actPlot = self.ax.scatter(clusterDict[pltIndex]['clusterValues'][myMembers, 0],\n clusterDict[pltIndex]['clusterValues'][myMembers, 1],\n clusterDict[pltIndex]['clusterValues'][myMembers, 2],\n color='#000000',\n **dataMiningPlotOptions)\n\n # Restore the plot options to their original values\n dataMiningPlotOptions['s'] *= 2\n if faceColors is not None:\n dataMiningPlotOptions['facecolors'] = faceColors\n else:\n del dataMiningPlotOptions['facecolors']\n\n elif 'bicluster' == plotSettings['SKLtype']:\n self.raiseAnError(IOError, 'SKLType Bi-Cluster Plots are not implemented yet!..')\n elif 'mixture' == plotSettings['SKLtype']:\n if 'noMixtures' in plotSettings.get('attributes', {}):\n clusterDict[pltIndex]['noMixtures'] = int(plotSettings.get('attributes', {})['noMixtures'])\n plotSettings.get('attributes', {}).pop('noMixtures')\n else:\n clusterDict[pltIndex]['noMixtures'] = np.amax(self.mixtureValues[pltIndex][1][0]) + 1\n if self.dim == 3:\n self.raiseAnError(IOError, 'SKLType Mixture Plots are only available in 2-Dimensions')\n else:\n clusterDict[pltIndex]['mixtureValues'] = np.zeros(shape = (len(self.xValues[pltIndex][key][xIndex]), 2))\n clusterDict[pltIndex]['mixtureValues'][:, 0] = self.xValues[pltIndex][key][xIndex]\n clusterDict[pltIndex]['mixtureValues'][:, 1] = self.yValues[pltIndex][key][yIndex]\n if 'mixtureCovars' in plotSettings.get('attributes', {}):\n split = self.__splitVariableNames('mixtureCovars', (pltIndex, 0))\n # mixtureCovars = self.sourceData[pltIndex].getParam(split[1], split[2], nodeId = 'ending')\n plotSettings.get('attributes', {}).pop('mixtureCovars')\n # else:\n # mixtureCovars = None\n if 'mixtureMeans' in plotSettings.get('attributes', {}):\n split = self.__splitVariableNames('mixtureMeans', (pltIndex, 0))\n # mixtureMeans = self.sourceData[pltIndex].getParam(split[1], split[2], nodeId = 'ending')\n plotSettings.get('attributes', {}).pop('mixtureMeans')\n # else:\n # mixtureMeans = None\n # mixtureCovars.reshape(3, 4)\n # mixtureMeans.reshape(3, 4)\n # for i, (mean, covar, col) in enumerate(zip(mixtureMeans, mixtureCovars, colors)):\n for i, col in zip(range(clusterDict[pltIndex]['noMixtures']), colors):\n if not np.any(self.mixtureValues[pltIndex][1][0] == i):\n continue\n myMembers = self.mixtureValues[pltIndex][1][0] == i\n self.actPlot = self.ax.scatter(clusterDict[pltIndex]['mixtureValues'][myMembers, 0],\n clusterDict[pltIndex]['mixtureValues'][myMembers, 1],\n color=col,\n **dataMiningPlotOptions)\n elif 'manifold' == plotSettings['SKLtype']:\n if self.dim == 2:\n manifoldValues = np.zeros(shape=(len(self.xValues[pltIndex][key][xIndex]), 2))\n else:\n manifoldValues = np.zeros(shape=(len(self.xValues[pltIndex][key][xIndex]), 3))\n manifoldValues[:, 0] = self.xValues[pltIndex][key][xIndex]\n manifoldValues[:, 1] = self.yValues[pltIndex][key][yIndex]\n if 'clusterLabels' in plotSettings.get('attributes', {}):\n split = self.__splitVariableNames('clusterLabels', (pltIndex, 0))\n clusterDict[pltIndex]['clusterLabels'] = self.sourceData[pltIndex].getParam(split[1], split[2], nodeId = 'ending')\n plotSettings.get('attributes', {}).pop('clusterLabels')\n else:\n clusterDict[pltIndex]['clusterLabels'] = None\n if 'noClusters' in plotSettings.get('attributes', {}):\n clusterDict[pltIndex]['noClusters'] = int(plotSettings.get('attributes', {})['noClusters'])\n plotSettings.get('attributes', {}).pop('noClusters')\n else:\n clusterDict[pltIndex]['noClusters'] = np.amax(self.clusterValues[pltIndex][1][0]) + 1\n if self.clusterValues[pltIndex][1][0] is not None:\n if self.dim == 2:\n for k, col in zip(range(clusterDict[pltIndex]['noClusters']), colors):\n myMembers = self.clusterValues[pltIndex][1][0] == k\n self.actPlot = self.ax.scatter(manifoldValues[myMembers, 0],\n manifoldValues[myMembers, 1],\n color=col,\n **dataMiningPlotOptions)\n else:\n for zIndex in range(len(self.zValues[pltIndex][key])):\n manifoldValues[:, 2] = self.zValues[pltIndex][key][zIndex]\n for k, col in zip(range(clusterDict[pltIndex]['noClusters']), colors):\n myMembers = self.clusterValues[pltIndex][1][0] == k\n self.actPlot = self.ax.scatter(manifoldValues[myMembers, 0],\n manifoldValues[myMembers, 1],\n manifoldValues[myMembers, 2],\n color=col,\n **dataMiningPlotOptions)\n else:\n if self.dim == 2:\n self.actPlot = self.ax.scatter(manifoldValues[:, 0],\n manifoldValues[:, 1],\n **dataMiningPlotOptions)\n else:\n for zIndex in range(len(self.zValues[pltIndex][key])):\n manifoldValues[:, 2] = self.zValues[pltIndex][key][zIndex]\n self.actPlot = self.ax.scatter(manifoldValues[:, 0],\n manifoldValues[:, 1],\n manifoldValues[:, 2],\n **dataMiningPlotOptions)\n elif 'decomposition' == plotSettings['SKLtype']:\n if self.dim == 2:\n decompositionValues = np.zeros(shape = (len(self.xValues[pltIndex][key][xIndex]), 2))\n else:\n decompositionValues = np.zeros(shape = (len(self.xValues[pltIndex][key][xIndex]), 3))\n decompositionValues[:, 0] = self.xValues[pltIndex][key][xIndex]\n decompositionValues[:, 1] = self.yValues[pltIndex][key][yIndex]\n if 'noClusters' in plotSettings.get('attributes', {}):\n clusterDict[pltIndex]['noClusters'] = int(plotSettings.get('attributes', {})['noClusters'])\n plotSettings.get('attributes', {}).pop('noClusters')\n else:\n clusterDict[pltIndex]['noClusters'] = np.amax(self.clusterValues[pltIndex][1][0]) + 1\n if self.clusterValues[pltIndex][1][0] is not None:\n if self.dim == 2:\n for k, col in zip(range(clusterDict[pltIndex]['noClusters']), colors):\n myMembers = self.clusterValues[pltIndex][1][0] == k\n self.actPlot = self.ax.scatter(decompositionValues[myMembers, 0],\n decompositionValues[myMembers, 1],\n color=col,\n **dataMiningPlotOptions)\n else:\n for zIndex in range(len(self.zValues[pltIndex][key])):\n decompositionValues[:, 2] = self.zValues[pltIndex][key][zIndex]\n for k, col in zip(range(clusterDict[pltIndex]['noClusters']), colors):\n myMembers = self.clusterValues[pltIndex][1][0] == k\n self.actPlot = self.ax.scatter(decompositionValues[myMembers, 0],\n decompositionValues[myMembers, 1],\n decompositionValues[myMembers, 2],\n color=col,\n **dataMiningPlotOptions)\n else:\n # no ClusterLabels\n if self.dim == 2:\n self.actPlot = self.ax.scatter(decompositionValues[:, 0],\n decompositionValues[:, 1],\n **dataMiningPlotOptions)\n else:\n for zIndex in range(len(self.zValues[pltIndex][key])):\n decompositionValues[:, 2] = self.zValues[pltIndex][key][zIndex]\n self.actPlot = self.ax.scatter(decompositionValues[:, 0],\n decompositionValues[:, 1],\n decompositionValues[:, 2],\n **dataMiningPlotOptions)\n else:\n # Let's try to \"write\" the code for the plot on the fly\n self.raiseAWarning('Trying to create a non-predefined plot of type ' + self.outStreamTypes[pltIndex] + '. If this fails, please refer to the and/or the related matplotlib method specification.')\n kwargs = {}\n for kk in plotSettings:\n if kk != 'attributes' and kk != self.outStreamTypes[pltIndex]:\n try:\n kwargs[kk] = ast.literal_eval(plotSettings[kk])\n except ValueError:\n kwargs[kk] = plotSettings[kk]\n try:\n if self.dim == 2:\n customFunctionCall = getattr(self.ax, self.outStreamTypes[pltIndex])\n else:\n customFunctionCall = getattr(self.ax, self.outStreamTypes[pltIndex])\n self.actPlot = customFunctionCall(**kwargs)\n except AttributeError as ae:\n self.raiseAnError(RuntimeError, '<' + str(ae) + '> -> in execution custom plot \"' + self.outStreamTypes[pltIndex] + '\" in Plot ' + self.name + '.\\nSTREAM MANAGER: ERROR -> command has been called in the following way: ' + 'ax.' + self.outStreamTypes[pltIndex])\n\n if 'legend' in self.options['plotSettings']:\n self.fig.legend(**self.options['plotSettings']['legend'])\n\n # SHOW THE PICTURE\n self.__executeActions()\n self.fig.canvas.draw_idle()\n\n if 'screen' in self.destinations and display:\n def handle_close(event):\n \"\"\"\n This method is aimed to handle the closing of figures (overall when in interactive mode)\n @ In, event, instance, the event to close\n @ Out, None\n \"\"\"\n self.fig.canvas.stop_event_loop()\n self.raiseAMessage('Closed Figure')\n self.fig.canvas.mpl_connect('close_event', handle_close)\n # self.plt.pause(1e-6)\n # The following code is extracted from pyplot.pause without actually\n # needing to force the code to sleep, according to MPL's documentation,\n # this feature is experimental, hopefully by not calling the pause\n # function, we can obtain consistent results.\n # We are skipping a few of the sanity checks done in that function,\n # since we are sure we have an interactive backend and access to the\n # correct type of canvas and figure.\n self.fig.canvas.draw()\n # If your graphs are unresponsive to user input, you may want to consider\n # adjusting this timeout, to allow more time for the input to be handled.\n self.fig.canvas.start_event_loop(1e-3)\n\n # self.fig.canvas.flush_events()\n\n for fileType in self.destinations:\n if fileType == 'screen':\n continue\n\n if not self.overwrite:\n prefix = str(self.counter) + '-'\n else:\n prefix = ''\n\n if len(self.filename) > 0:\n name = self.filename\n else:\n name = prefix + self.name + '_' + str(self.outStreamTypes).replace(\"'\", \"\").replace(\"[\", \"\").replace(\"]\", \"\").replace(\",\", \"-\").replace(\" \", \"\")\n\n if self.subDirectory is not None:\n name = os.path.join(self.subDirectory,name)\n\n self.fig.savefig(name + '.' + fileType, format=fileType)\n\n if 'screen' not in self.destinations:\n plt.close(fig=self.fig)\n\n gc.collect()","def app_SN_last_24h_plots(self, dfs, phase_dirs, sizer_val, styler_val):\n\n print('Currently plotting con_last_24h_plots')\n\n for df, direc in zip(dfs, phase_dirs):\n df = self.data_processor.create_24h_subset(df)\n self.plotter.plot_SN_separate_temperature_series(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['06_last_24_hours'],\n sizer=self.formatter.sizer[sizer_val]['1x1_full_width'],\n styler=self.formatter.styler[styler_val],\n xaxis_type='datetime',\n last_day=True\n )\n self.plotter.plot_SN_separate_moisture_series(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['06_last_24_hours'],\n sizer=self.formatter.sizer[sizer_val]['1x1_full_width'],\n styler=self.formatter.styler[styler_val],\n xaxis_type='datetime',\n last_day=True\n )\n self.plotter.plot_SN_combined_temperature_series(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['06_last_24_hours'],\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\n styler=self.formatter.styler[styler_val],\n xaxis_type='datetime',\n last_day=True,\n )\n self.plotter.plot_SN_combined_moisture_series(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['06_last_24_hours'],\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\n styler=self.formatter.styler[styler_val],\n xaxis_type='datetime',\n last_day=True,\n )\n\n print('Done\\n')","def plot_folder(path):\r\n plt.figure(figsize=(20, 10))\r\n for filename in glob.glob(path + '/*.pspec'):\r\n x, y= np.loadtxt(fname=filename, delimiter='\\t',dtype=int, usecols = (1,2),\r\n skiprows=100, unpack = True)\r\n plt.plot(x, y)\r\n return plt.show()","def check_plots(tracklist_subset, tracklist):\n\n for trial in tracklist_subset: # Iterates over all available trials\n\n # Scale time for colormap\n scaled_time = (tracklist[trial]['data'].index.values -\n tracklist[trial]['data'].index.values.min()) / \\\n tracklist[trial]['data'].index.values.ptp()\n timemax = max(tracklist[trial]['data'].index.values)\n data = tracklist[trial]['data']\n colors = plt.cm.cubehelix(scaled_time)\n m = cm.ScalarMappable(cmap=cm.cubehelix)\n m.set_array(tracklist[trial]['data'].index.values)\n\n # filename = str(trial) + '.pdf'\n\n fig = plt.figure(figsize=(20, 20))\n fig.suptitle(tracklist[trial]['sequence'] + ' ' +\n tracklist[trial]['behavior'])\n\n ax1 = fig.add_subplot(4, 2, 1, projection='3d')\n ax1.set_title('Pt 1 Position')\n ax1.scatter3D(xs=tracklist[trial]['data']['pt1x_smth'],\n ys=tracklist[trial]['data']['pt1y_smth'],\n zs=tracklist[trial]['data']['pt1z_smth'],\n zdir='z', s=3, c=colors, marker='o',\n edgecolor='none') # 3D Scatter plot\n ax1.autoscale(enable=True, tight=True)\n ax1.set_xlabel('X position')\n ax1.set_ylabel('Y position')\n ax1.set_zlabel('Z position')\n plt.colorbar(m, shrink=0.5, aspect=10)\n\n ax2 = fig.add_subplot(4, 2, 3)\n ax2.plot(data.index.values, data['pt1y_v_smth'], 'bo')\n ax2.set_ylabel('Y velocity (cm/s)', color='b')\n ax2.tick_params('y', colors='b')\n\n ax3 = fig.add_subplot(4, 2, 5)\n ax3.plot(data.index.values, data['pt1_net_v'], 'bo')\n ax3.set_ylabel('Net Velocity (cm/s)', color='b')\n ax3.tick_params('y', colors='b')\n\n ax4 = fig.add_subplot(4, 2, 7)\n ax4.plot(data.index.values, data['pt1_net_a'], 'bo')\n ax4.set_ylabel('Net accel (cm/s2)', color='b')\n ax4.tick_params('y', colors='b')\n\n ax5 = fig.add_subplot(4, 2, 2, projection='3d')\n ax5.set_title('Pt 2 Position')\n ax5.scatter3D(xs=tracklist[trial]['data']['pt2x_smth'],\n ys=tracklist[trial]['data']['pt2y_smth'],\n zs=tracklist[trial]['data']['pt2z_smth'],\n zdir='z', s=3, c=colors, marker='o',\n edgecolor='none') # 3D Scatter plot\n ax5.autoscale(enable=True, tight=True)\n ax5.set_xlabel('X position')\n ax5.set_ylabel('Y position')\n ax5.set_zlabel('Z position')\n plt.colorbar(m, shrink=0.5, aspect=10)\n\n ax6 = fig.add_subplot(4, 2, 4)\n ax6.plot(data.index.values, data['pt2y_v_smth'], 'bo')\n ax6.set_ylabel('Y velocity (cm/s)', color='b')\n ax6.tick_params('y', colors='b')\n\n ax7 = fig.add_subplot(4, 2, 6)\n ax7.plot(data.index.values, data['pt2_net_v'], 'bo')\n ax7.set_ylabel('Net Velocity (cm/s)', color='b')\n ax7.tick_params('y', colors='b')\n\n ax8 = fig.add_subplot(4, 2, 8)\n ax8.plot(data.index.values, data['pt2_net_a'], 'bo')\n ax8.set_ylabel('Net accel (cm/s2)', color='b')\n ax8.tick_params('y', colors='b')\n\n plt.show()","def viz(inpath, outpath='sample/', save_fig=False):\n for sub_dir in os.listdir(inpath):\n dir = os.path.join(inpath, sub_dir)\n out_dir = os.path.join(outpath, sub_dir)\n frame_list = os.listdir(dir)\n frame_list = [frame for frame in frame_list if frame.endswith('.png')]\n for frame in frame_list:\n imgpath = os.path.join(dir, frame)\n kp_path = dir + frame[0:4] + '_joint2D.txt'\n kp = read_kp(kp_path)\n img = cv2.imread(imgpath)\n plothand(img, kp)\n if save_fig:\n if not os.path.exists(out_dir):\n os.makedirs(out_dir, exist_ok=True)\n cv2.imwrite(os.path.join(outpath, frame[0:4]+'.jpg'), img)\n else:\n cv2.imshow(frame, img)","def save_dataset_visual(lines, output_dir):\n\n # Ensure output directory exists\n if not os.path.exists(output_dir):\n os.makedirs(output_dir)\n\n cols = 3\n rows = 3\n fig_size = (7 * cols, 4 * rows) # Figure width and height, in inches\n # Random sample of images\n save_name = \"training_data_sample.png\"\n fig, ax = plt.subplots(rows, cols, figsize=fig_size)\n for row in range(rows):\n for col in range(cols):\n idx = np.random.randint(0, len(lines))\n ax[row, col].imshow(ndimage.imread(lines[idx][0]))\n ax[row, col].set_title(\"Angle = \" + str(round(lines[idx][1], 3)))\n plt.savefig(output_dir + save_name, bbox_inches='tight')\n # Distribution of steering angles\n save_name = \"data_histogram.png\"\n fig_size = (5, 3) # Figure width and height, in inches\n num_bins = 100\n angles = np.array([line[1] for line in lines])\n hist, bins = np.histogram(angles, bins=num_bins)\n fig = plt.figure(figsize=fig_size)\n plt.bar(bins[:-1], hist)\n plt.xlabel(\"Steering Angle\")\n plt.ylabel(\"Frequency\")\n plt.title(\"Distribution of Steering Angles in Training Data\")\n plt.savefig(output_dir + save_name, bbox_inches='tight')","def Diagnostic_plot3(self):\n\n floc = glob.glob('/home/mxs191/Desktop/MathewSchofield/TRG/DetTest/DetTest1_results/Info2Save/*.csv')\n fig = plt.figure()\n plt.rc('font', size=18)\n #fig, ax = generalPlot(xaxis=r'$\\nu / \\mu$Hz', yaxis=r'$P_{\\rm det}$')\n gs = gridspec.GridSpec(1, 2, width_ratios=(4,1))\n ax = fig.add_subplot(gs[0])\n\n for idx, i in enumerate(floc):\n\n d = pd.read_csv(i)\n\n if idx == 0:\n fullpdet = d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']]\n else:\n fullpdet = pd.concat([ fullpdet,\\\n d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']] ])\n\n plt.scatter(d['f0'], d['Pdet_Kepler'], color='b',\\\n label=r\"$\\rm Kepler - 4\\ yrs$\" if idx == 0 else '')\n plt.scatter(d['f0'], d['Pdet_TESS365'], color='orange',\\\n label=r'$\\rm TESS - 1\\ yr$' if idx == 0 else '')\n plt.scatter(d['f0'], d['Pdet_TESS27'], color='g',\\\n label=r'$\\rm TESS - 27\\ days$' if idx == 0 else '')\n\n plt.axhline(fullpdet['Pdet_Kepler'].median(), color='b')\n plt.axhline(fullpdet['Pdet_TESS365'].median(), color='orange')\n plt.axhline(fullpdet['Pdet_TESS27'].median(), color='g')\n ax.legend(loc='lower right')\n plt.ylim([0,1])\n ax.set_ylabel(r'$P_{\\rm det}$')\n ax.set_xlabel(r'$\\nu / \\mu \\rm Hz$')\n\n bx = fig.add_subplot(gs[1])\n import seaborn as sns\n bw = 0.4\n sns.kdeplot(fullpdet['Pdet_Kepler'].values, shade=True, vertical=True, \\\n ax=bx, color='b', bw=bw)\n sns.kdeplot(fullpdet['Pdet_TESS365'].values, shade=True, vertical=True, \\\n ax=bx, color='orange', bw=bw)\n sns.kdeplot(fullpdet['Pdet_TESS27'].values, shade=True, vertical=True, \\\n ax=bx, color='g', bw=bw)\n bx.set_ylim([0.0,1.0])\n bx.set_xticks([])\n bx.set_yticks([])\n bx.set_xlabel(r'$\\rm Density$')\n plt.tight_layout()\n\n plt.show()\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\n 'DetTest_Diagnostic_plot3.pdf')\n sys.exit()","def plot_results(path: Path, output_dir: Path, skip: int = 100) -> Path:\n with xr.open_dataset(path) as ds:\n lons = ds.lon.values\n lats = ds.lat.values\n status = ds.status.values\n stranded_flag = get_stranded_flag_from_status(ds)\n\n _ = plt.figure(figsize=(10, 10))\n ax = plt.axes(projection=ccrs.PlateCarree(central_longitude=180))\n ax.set_extent(\n [-210, -140, 45, 75],\n crs=ccrs.PlateCarree()\n )\n nparticles = len(lons)\n if nparticles > skip:\n iter_particles = np.arange(0, nparticles, skip)\n else:\n iter_particles = np.arange(0, nparticles)\n\n for particle in iter_particles:\n # Create mask for stranded or not moving particles\n mask = np.logical_and(\n status[particle, :] <= 1,\n status[particle, :] >= 0\n )\n # Cannot save figure if you plot something that is completely masked\n # Cartopy will raise an error on save\n if not np.any(mask):\n continue\n ax.plot(\n lons[particle, mask],\n lats[particle, mask],\n color='g',\n transform=ccrs.PlateCarree()\n )\n\n # Starting position\n ax.scatter(\n ds.lon[particle, 0],\n ds.lat[particle, 0],\n c='b',\n transform=ccrs.PlateCarree()\n )\n stranded_ix = ds.status[particle, :] == stranded_flag\n\n # Stranded particles\n if np.any(stranded_ix):\n ax.scatter(\n ds.lon[particle, stranded_ix],\n ds.lat[particle, stranded_ix],\n c='r',\n transform=ccrs.PlateCarree()\n )\n\n ax.coastlines()\n ax.add_feature(cartopy.feature.LAND.with_scale('110m'))\n ax.gridlines(draw_labels=True)\n\n fname = path.name.replace('.nc', '.png')\n outpath = output_dir / fname\n\n plt.tight_layout()\n plt.savefig(outpath)\n plt.close()\n\n return outpath","def fig_4():\n epoch = 3\n N = 60000\n Nr = N\n K = 32\n n_iter = 256\n Nstar = 16\n data = 'dr10'\n factor = 100.\n features = ['psf_mag', 'model_colors', 'psf_minus_model']\n filters = ['r', 'ug gr ri iz', 'ugriz']\n message = 'pm_mc_pmm_r_all_all'\n model = 'xdmodel_%s_%d_%d_%d_%d_%s.pkl' % (data, Nr, K, n_iter, Nstar,\n message)\n model = os.environ['xddata'] + model\n figname = os.environ['xdplots'] + 'fig4.png'\n xx_plot(epoch, model, features, filters, figname)","def plot_number_steps(step_cache_qlearning, step_cache_SARSA): \n cum_step_q = []\n steps_mean = np.array(step_cache_qlearning).mean()\n steps_std = np.array(step_cache_qlearning).std()\n count = 0 # used to determine the batches\n cur_step = 0 # accumulate reward for the batch\n for cache in step_cache_qlearning:\n count = count + 1\n cur_step += cache\n if(count == 10):\n # normalize the sample\n normalized_step = (cur_step - steps_mean)/steps_std\n cum_step_q.append(normalized_step)\n cur_step = 0\n count = 0\n \n cum_step_SARSA = []\n steps_mean = np.array(step_cache_SARSA).mean()\n steps_std = np.array(step_cache_SARSA).std()\n count = 0 # used to determine the batches\n cur_step = 0 # accumulate reward for the batch\n for cache in step_cache_SARSA:\n count = count + 1\n cur_step += cache\n if(count == 10):\n # normalize the sample\n normalized_step = (cur_step - steps_mean)/steps_std\n cum_step_SARSA.append(normalized_step)\n cur_step = 0\n count = 0 \n # prepare the graph \n plt.plot(cum_step_q, label = \"q_learning\")\n plt.plot(cum_step_SARSA, label = \"SARSA\")\n plt.ylabel('Number of iterations')\n plt.xlabel('Batches of Episodes (sample size 10) ')\n plt.title(\"Q-Learning/SARSA Iteration number untill game ends\")\n plt.legend(loc='lower right', ncol=2, mode=\"expand\", borderaxespad=0.)\n plt.show()\n plt.savefig('number_steps.png')","def run(config, workdir, files, output=None, n=1):\n file = None\n for i in range(1, n+1):\n Logger.info(f'Starting run {i}/{n}')\n\n if output:\n file = f'{output}/run_{i}.dat'\n\n # Make sure these directories are clean\n for file in glob(f'{workdir}/lut_h2o/*'):\n os.remove(file)\n for file in glob(f'{workdir}/output/*'):\n os.remove(file)\n\n profile(\n args = SimpleNamespace(\n input_radiance = files[0],\n input_loc = files[1],\n input_obs = files[2],\n working_directory = workdir,\n config_file = config,\n wavelength_path = None,\n log_file = None,\n logging_level = 'DEBUG',\n pressure_elevation = None\n ),\n output = file\n )","def plot(self):\n # Get data\n #print(self.file_name)\n fig, ax = plb.subplots(1,1,figsize=(18,20))\n for key,value in self.testTrend.items():\n x = np.arange(len(self.data_array))\n y = np.asarray(value)\n plb.plot(x,y, label=key)\n ax.scatter(x, y)\n for i in range(0, len(value)):\n ax.annotate(str(i), (x[i], y[i]))\n # Title\n plb.title(self.file_name)\n # Legend\n plb.legend(bbox_to_anchor=(.05, 1), loc='best', borderaxespad=0.)\n # x ticks\n plb.xticks(np.arange(min(x), max(x) + 1, 2.0))\n #plb.ylim(-250, 1)\n # Show image\n plb.show()","def plot(\n self,\n output: Optional[str] = None,\n max_plot_points: Optional[int] = None,\n **kwargs,\n ):\n import matplotlib.pyplot as plt\n\n fig, axes = plt.subplots(\n 1,\n len(self._records),\n figsize=(6 * len(self._records), 6),\n constrained_layout=True,\n )\n if not isinstance(axes, np.ndarray):\n # when only one record, axes is not a list, so wrap it\n axes = [axes]\n\n plt_kwargs = dict(alpha=0.8, linewidth=1)\n plt_kwargs.update(kwargs)\n\n for idx, record in enumerate(self._records):\n axes[idx].plot(\n *self._sample_points(record.floats(), max_len=max_plot_points),\n **plt_kwargs,\n )\n axes[idx].set_ylabel(record.name)\n axes[idx].set_xlabel('Steps')\n\n if output:\n plt.savefig(output, bbox_inches='tight', pad_inches=0.1)\n else:\n plt.show()","def show_data_files(self):\n for idx in self.plot_data:\n self.plot_data[idx].show()","def comp2profile(output):\n\n # Load components\n data = '/home/scott/data/insar/cvz/los2xyz/components.txt_backup'\n lon,lat,x,ur,uz = np.loadtxt(data,unpack=True)\n\n # Load FEM output\n points = '/home/scott/research/models/pylith/3d/fialko2012/model3_agu/output_points.txt'\n pointsh5 = '/home/scott/research/models/pylith/3d/fialko2012/model3_agu/output/elastic/apmb/points.h5'\n x_fem, ur_fem, uz_fem = pu.extract_points(pointsh5)\n #NOTE: in this case need radial distance b/c not on x-axis\n #x = np.sqrt(2)*1e3*np.loadtxt(points,usecols=[0])\n # NOTE: cludge fix for negative radial displacements in dipole model\n ur_fem[x_fem >= 40000] = -ur_fem[x_fem >= 40000]\n #ur_fem = np.abs(ur_fem)\n\n #Convert to cm units for plotting\n x_fem = x_fem/1000\n ur_fem = ur_fem * 100.0\n uz_fem = uz_fem * 100.0\n\n #NOTE: must interpolate either insar data or FEM to compare at values at same radial distance\n fig = plt.figure()\n ax = fig.add_subplot(111)\n plt.plot(x, uz, 'b.-', lw=2, label='data')\n plt.plot(x, ur, 'g.-', lw=2)\n plt.plot(x_fem, uz_fem, marker='o', ls='None', lw=2, mec='b', mfc='None',label='FEM')\n plt.plot(x_fem, ur_fem, marker='o', ls='None', lw=2, mec='g', mfc='None')\n plt.axhline(color='k')\n plt.title('FEM vs. Data')\n plt.xlabel('Radial distance [km]')\n plt.ylabel('Displacement [cm]')\n plt.grid(True)\n plt.xlim(0,150) #only show out to 150km\n plt.legend()","def setup_plot_by_stage(stage, inds=None):\n if inds is not None:\n stage = stage[inds]\n ustage = np.unique(stage)\n nplots = ustage.size + 1.\n fig, (axs) = setup_multiplot(nplots, sharex=True, sharey=True, figsize=(12, 8))\n return fig, (axs)","def __init__(self):\n super().__init__()\n\n # general attributes\n self.printTag = 'OUTSTREAM PLOT'\n self.options = {} # outstreaming options # no addl info from original developer\n self.counter = 0 # keeps track of how many times the same plot has been plotted\n self.dim = None # default plot is 2D\n self.sourceName = [] # list of source names\n self.sourceData = None # source of data\n self.outStreamTypes = [] # list of the outstream types\n self.destinations = None # where plots should go (screen, file, etc.)\n\n # plot types key is data dimension, value is list of available plot types\n self.availableOutStreamTypes = {2: ['scatter',\n 'line',\n 'histogram',\n 'stem',\n 'step',\n 'pseudocolor',\n 'dataMining',\n 'contour',\n 'filledContour'],\n 3: ['scatter',\n 'line',\n 'histogram',\n 'stem',\n 'surface',\n 'wireframe',\n 'tri-surface',\n 'contour',\n 'filledContour']}\n\n # interpolators that can be used in plots\n self.availableInterpolators = ['nearest',\n 'linear',\n 'cubic',\n 'multiquadric',\n 'inverse',\n 'gaussian',\n 'Rbflinear',\n 'Rbfcubic',\n 'quintic',\n 'thin_plate']\n\n # plot components\n self.fig = None # figure\n self.ax = None # axes\n self.actPlot = None # plot action, ie., ax.plot()\n self.gridSpace = None # subplot setup\n self.actcm = None # colormap\n self.xCoordinates = None # x coordinate name\n self.yCoordinates = None # y coordinate name\n self.zCoordinates = None # z coordinate name\n self.xValues = None # dictionary of x values\n self.yValues = None # dictionary of y values\n self.zValues = None # dictionary of z values\n self.colorMapCoordinates = {} # color map coordinates\n self.colorMapValues = {} # color map values\n\n # For the data-mining plot, I think?\n self.clusterLabels = None\n self.clusterValues = None\n\n # Gaussian Mixtures\n self.mixtureLabels = None\n self.mixtureValues = None\n self.mixtureMeans = None\n self.mixtureCovars = None","def subplottPNG(self):\n os.chdir(self.mainDir)\n folder = os.listdir(u'.')\n folders = [f for f in folder if f[0] == 'S']\n\n for subject in folders:\n\n try: # go to the 'results' directory\n resultsDir = os.path.join(os.path.join(self.mainDir, subject),'results')\n os.chdir(resultsDir)\n\n # find all files with .png extension\n pngfiles = glob.glob('*.png')\n pngfiles.sort(key = lambda x:x[0])\n pngfiles.sort(key = lambda x:x[1])\n\n fig = plt.figure()\n\n for ii, filename in enumerate(pngfiles):\n f = plt.subplot(4,4,ii+1)\n f.set_axis_off()\n f.set_xlabel('ses:'+str(ii+1))# f.set_figheight(15)\n fig.set_figwidth(30)\n fig.set_figheight(30)\n fig.tight_layout()\n img = matplotlib.image.imread(filename)\n plt.imshow(img)\n\n figname = subject + '_subplot'+ '.png'\n matplotlib.pyplot.savefig(figname)\n\n except Exception as errMessage:\n print(errMessage)","def main(self, args):\n for plot in args.plots:\n if plot == 'no_plot':\n break\n print \"plotting\", plot\n\n fig = self.plot_figure(plot)\n\n fformat = '{plot}_{index}.{ext}'\n fname = fformat.format(plot=plot, index=self.index, ext='png')\n fpath = os.path.join(plot_dir, fname)\n fig.savefig(fpath)\n\n if args.distributions == 'all':\n distributions = ['Uf', 'Wf', 'uf_abs',\n 'vorticity', 'vertical_shear']\n else:\n distributions = args.distributions\n for dist in distributions:\n range = self.properties[dist]['range']\n name = self.properties[dist]['name']\n print \"plotting distribution\", dist, name\n fig = self.plot_distribution(getattr(self, dist), range, name)\n\n fformat = 'distribution_{q}_{index}.{ext}'\n fname = fformat.format(q=dist, index=self.index, ext='png')\n fpath = os.path.join(plot_dir, fname)\n fig.savefig(fpath)\n\n if args.funcs:\n for func in args.funcs:\n print \"multiprocessing\", func\n f = getattr(self, 'plot_' + func)\n f()","def spider(inputfiles, names, type=\"M1\", threshold=0.1, spinwindow=[], Eg_low=0, Eg_high=1e9, Ex_low=0, Ex_high=1e9, scale=2):\n\n Nsp = np.ceil(np.sqrt(len(inputfiles))).astype(int)\n f, ax_list = plt.subplots(Nsp,Nsp,squeeze=False,sharex='col', sharey='row')\n\n for i in range(len(inputfiles)):\n inputfile = inputfiles[i]\n name = names[i]\n ax = ax_list[i%Nsp][int((i-i%Nsp)/Nsp)]\n\n\n levels = read_energy_levels(inputfile)\n Egs = levels[0,0]\n\n Ex_high = min(Ex_high, levels[:,0].max()-Egs)\n Eg_high = min(Eg_high, levels[:,0].max()-Egs)\n \n \n levels_plot_J = []\n levels_plot_Ex = []\n for iEx in range(len(levels[:,0])):\n # print levels[iEx,:]\n J2 = levels[iEx,1]\n par = levels[iEx,2]\n if len(spinwindow) > 0 and not ([J2,par] in spinwindow or [J2-2,par] in spinwindow or [J2+2,par] in spinwindow):\n continue\n Ex = levels[iEx,0]-Egs\n if Ex < Ex_low or Ex > Ex_high:\n continue\n \n levels_plot_J.append(J2/2)\n levels_plot_Ex.append(Ex)\n \n ax.plot(levels_plot_J, levels_plot_Ex, 'o', color='grey', linewidth=0.5)\n ax.set_xlim([levels[:,1].min()/2-1,levels[:,1].max()/2+1])\n ax.set_title(name+r'$\\,E_\\gamma\\in[{:.1f},{:.1f}]$'.format(Eg_low,Eg_high))\n ax.set_ylabel(r'$E_x\\,\\mathrm{[MeV]}$')\n ax.set_xlabel(r'$J\\,\\mathrm{[\\hbar]}$')\n \n \n \n transitions = read_transition_strengths(inputfile, type=type)\n for iEx in range(len(transitions[:,0])):\n J2i = int(transitions[iEx,0])\n pari = int(transitions[iEx,1])\n if len(spinwindow) > 0 and not [J2i,pari] in spinwindow:\n continue\n B = transitions[iEx,7]\n Eg = transitions[iEx,6]\n if B < threshold or Eg<Eg_low or Eg>Eg_high:\n continue\n Ei = transitions[iEx,2]-Egs\n if Ei < Ex_low or Ei > Ex_high:\n continue\n J2f = int(transitions[iEx,3])\n parf = int(transitions[iEx,4])\n Ef = transitions[iEx,5]-Egs\n ax.plot([J2i/2,J2f/2],[Ei,Ef], color='teal', linewidth=(scale*B))\n \n return f, ax_list","def plot_gains(gains, gain_ref, TITLES, OUT_DIR):\n\n# print 'directory: %s' % OUT_DIR\n# print 'TITLES:%s', TITLES\n\n gain_ref_np = np.array(gains[gain_ref].gain)\n ratios = []\n for gain in gains:\n gain_np = np.array(gain.gain)\n dim = (min(gain_ref_np.shape[0], gain_np.shape[0]),\n min(gain_ref_np.shape[1], gain_np.shape[1])\n )\n# print 'dim = ', dim\n ratios.append(gain_np[0:dim[0], 0:dim[1]] / gain_ref_np[0:dim[0], 0:dim[1]])\n\n# print 'Ratios = ', ratios\n\n rows = 2*((len(ratios) -1) / 6 + 1)\n cmap = plt.get_cmap('gnuplot')\n colors = [cmap(i) for i in np.linspace(0, 1, len(ratios))]\n fig, axes = plt.subplots(nrows=rows, ncols=6)\n fig.set_size_inches(20,20)\n axfl = axes.flatten()\n for i, ratio in enumerate(ratios):\n# print 'Plotting %s', TITLES[i]\n\tj = (i / 6)*12 + i % 6\n ax = axfl[j]\n ax2 = axfl[j+6]\n ax.hist(np.reshape(ratio, -1), 20, range=(0.9, 1.1), facecolor=colors[i])\n ax.set_title(TITLES[i], size=20)\n ax2.hist(np.reshape(ratio, -1), 50, range=(0., 2.), facecolor=colors[i])\n\n fig.suptitle(\"Gains with ref gain '%s'\" % TITLES[gain_ref], y=0.95, size=25)\n # fig.tight_layout()\n plt.savefig(OUT_DIR + 'gain.png')\n plt.close(fig)"],"string":"[\n \"def plot_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2014/output',\\n\\t\\t\\t\\tsteps=['step01','step02'],\\n\\t\\t\\t\\t#labels='',\\n\\t\\t\\t\\tshow=True,\\n\\t\\t\\t\\txscale=1e3,\\n\\t\\t\\t\\tyscale=1e-2):\\n\\tplt.figure()\\n\\t#path = '/Users/scott/Desktop/elastic'\\n\\n\\t# Deep source\\n\\t#labels = ['no APMB', 'APMB']\\n\\t#if labels == '':\\n\\tlabels = steps\\n\\tdeep = {}\\n\\t#uzmax = 0.824873455364\\n\\t# NOT sure why hardcoded...\\n\\tuzmax = 1\\n\\tfor i,outdir in enumerate(steps):\\n\\t\\tpointsFile = os.path.join(path, outdir, 'points.h5')\\n\\t\\tprint(pointsFile)\\n\\t\\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n\\n\\t\\tX = x / xscale\\n\\t\\tY1 = ux / yscale\\n\\n\\t\\tx_fem = X #/ xscale #double scaling!\\n\\t\\tur_fem = Y1 #/ yscale\\n\\t\\tuz_fem = uz / yscale\\n\\n\\t\\t#print(pointsFile)\\n\\t\\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\\n\\n\\t\\t#normalize\\n\\t\\tuz_fem = uz_fem / uzmax\\n\\t\\tur_fem = ur_fem / uzmax\\n\\t\\tx_fem = x_fem / 30.0\\n\\n\\t\\tl, = plt.plot(x_fem,uz_fem,'o-',ms=4,lw=4,label=labels[i])\\n\\t\\tplt.plot(x_fem,ur_fem,'o--',ms=4,lw=4,color=l.get_color()) #mfc='none' transparent\\n\\t\\tdeep[outdir] = uz_fem/uz_fem\\n\\n\\t'''\\n\\t# Shallow Source\\n\\tshallow = {}\\n\\tuzmax = 0.949652827795\\n\\tfor i,outdir in enumerate(['step11','step12']):\\n\\t\\tpointsFile = os.path.join(path, outdir, 'points.h5')\\n\\n\\t\\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n\\n\\t\\tX = x / xscale\\n\\t\\tY1 = ux / yscale\\n\\n\\t\\tx_fem = X #/ xscale #double scaling!\\n\\t\\tur_fem = Y1 #/ yscale\\n\\t\\tuz_fem = uz / yscale\\n\\n\\t\\t#print(pointsFile)\\n\\t\\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\\n\\n\\t#normalize\\n\\tuz_fem = uz_fem / uzmax\\n\\tur_fem = ur_fem / uzmax\\n\\tx_fem = x_fem / 20.0\\n\\n\\t\\tl, = plt.plot(x_fem,uz_fem,'.-', mfc='w', lw=4,label=labels[i])\\n\\t\\tplt.plot(x_fem,ur_fem,'.--',lw=4, mfc='w',color=l.get_color()) #mfc='none' transparent\\n\\n\\t\\tshallow[outdir] = uz_fem/ur_fem\\n\\t'''\\n\\n\\t# Annotate\\n\\tplt.axhline(color='k',lw=0.5)\\n\\t#plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n\\t#plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\\n\\tplt.legend()\\n\\tplt.grid()\\n\\t#plt.ylim(-0.5, 3.5)\\n\\t#plt.savefig('deep.png',bbox_inches='tight')\\n\\t#plt.savefig('shallow.png',bbox_inches='tight')\\n\\n\\t# normalized\\n\\tplt.ylim(-0.5, 4)\\n\\tplt.xlim(0,10)\\n\\tplt.xlabel('Normalized Radial Distance [R / D]')\\n\\tplt.ylabel('Normalized Displacement [U / Uz_max]')\\n\\t#plt.savefig('normalized_deep.png',bbox_inches='tight')\\n\\tplt.savefig('normalized_shallow.png',bbox_inches='tight')\\n\\n\\n\\t# Plot ratios of uz versus NOTE: this plot is confusing,,, just keep ratio of uz_max to ur_max\\n\\t'''\\n\\tplt.figure()\\n\\tplt.plot(x_fem, deep['step01'], label='Deep no APMB')\\n\\tplt.plot(x_fem, deep['step02'], label='Deep w/ APMB')\\n\\tplt.plot(x_fem, shallow['step11'], label='Shallow no APMB')\\n\\tplt.plot(x_fem, shallow['step12'], label='Shallow w/ APMB')\\n\\tplt.xlabel('Distance [km]') #NOTE: maybe plot normailzed X-axis (R-d)\\n\\t#plt.xlabel('Normalized Distance [R/d]')\\n\\tplt.ylabel('Ratio [Uz/Ur]')\\n\\tplt.title('Ratio of vertical to radial displacement')\\n\\tplt.legend()\\n\\tplt.show()\\n\\t'''\",\n \"def plot(profiler, outdir):\\n # go through the outputs of all morphisms\\n for cur_name, cur_output in profiler.profile.items():\\n cur_outdir = os.path.join(outdir, cur_name)\\n if not os.path.exists(cur_outdir):\\n os.makedirs(cur_outdir)\\n\\n ProfilePlotter.plot_morphism_output(cur_output, cur_outdir)\",\n \"def run_plots(self):\\n # load the files\\n self.pre_dark_file = os.path.join(self.input_dir, 'step_lastframe.fits')\\n self.post_dark_file = os.path.join(self.input_dir, 'step_dark_current.fits')\\n self.jump_file = os.path.join(self.input_dir, 'step_jump.fits')\\n self.rate_file = os.path.join(self.input_dir, 'step_rate.fits')\\n self.ramp_file = glob.glob(os.path.join(self.input_dir, '*.fits'))[0]\\n\\n # plots\\n self.plot_jump_flags_image()\\n self.plot_groupdq_flags(pixel=[884, 550])\\n self.plot_ramps_pre_post_correction(pixel=[884, 550])\",\n \"def plot_morphism_output(data, outdir):\\n\\n # show the distributions for each variable separately\\n for col in data.columns:\\n ProfilePlotter._plot_1d(data[col], outfile = os.path.join(outdir, col + \\\".pdf\\\"))\\n\\n # later, maybe also show 2d plots etc.\",\n \"def plot_profiles(self, fig=0, title=''):\\n plot_input.plot_profiles(self, fig, title)\",\n \"def plot_directory_numex(path, vals, param='density', outname=None, show=True,\\n xscale=1e-3,yscale=1e2):\\n #vals = arange(2300.0, 2800.0, 50.0)\\n outdirs = np.sort(os.listdir(path))\\n plt.figure()\\n\\n # Plot surface profiles for each parameter\\n for val,outdir in zip(vals,outdirs):\\n pointsFile = os.path.join(path, outdir, 'points.h5')\\n print(pointsFile)\\n x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile, output=True, adjustRadial=True)\\n x_fem = x_fem / xscale\\n ur_fem = ur_fem / yscale\\n uz_fem = uz_fem / yscale\\n l, = plt.plot(x_fem,uz_fem,'.-',label=str(val))\\n plt.plot(x_fem,ur_fem,'.-',color=l.get_color())\\n\\n # Annotate\\n plt.axhline(color='k') #zero displacement line\\n plt.title(param)\\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\\n plt.legend()\\n\\n if outname: plt.savefig(outname)\\n if show: plt.show()\",\n \"def create_plots(self):\\n if not os.path.exists(self.output_folder):\\n os.makedirs(self.output_folder)\\n self.sse_plot()\\n self.avg_sse_plot()\",\n \"def make_plots(self):\\n import os\\n os.system('rm schelling*.png')\\n file_name = 'schelling_000.png'\\n title = 'Initial Population'\\n self.plot(title=title, file_name=file_name)\\n n_unhappy = 999\\n counter = 0\\n while n_unhappy > 0 and counter < 100:\\n counter += 1\\n print counter\\n n_unhappy = self.move_unhappy()\\n file_name = 'schelling_%03g.png'%(counter)\\n title = 'Step %03g'%(counter)\\n self.plot(title=title, file_name=file_name)\",\n \"def plot_one_directory(args, dirnames, figname):\\n logdir = args.logdir\\n num = len(ATTRIBUTES)\\n fig, axes = subplots(num, figsize=(13,4*num))\\n\\n for (dd, cc) in zip(dirnames, COLORS):\\n A = np.genfromtxt(join(logdir, dd, 'log.txt'), \\n delimiter='\\\\t', \\n dtype=None, \\n names=True)\\n x = A['Iterations']\\n\\n for (i,attr) in enumerate(ATTRIBUTES):\\n axes[i].plot(x, A[attr], '-', lw=lw, color=cc, label=dd)\\n axes[i].set_ylabel(attr, fontsize=ysize)\\n axes[i].tick_params(axis='x', labelsize=tick_size)\\n axes[i].tick_params(axis='y', labelsize=tick_size)\\n axes[i].legend(loc='best', ncol=2, prop={'size':legend_size})\\n\\n axes[0].set_ylim([-10,10])\\n axes[1].set_ylim([-10,10])\\n axes[2].set_ylim([0,10])\\n axes[3].set_ylim([0,10])\\n\\n plt.tight_layout()\\n plt.savefig(figname)\",\n \"def ex1_plots(instance, destination, prefix, save, animate):\\n \\n plts = ukf_plots(instance, destination, prefix, save, animate)\\n\\n truths = truth_parser(instance)\\n nan_array= nan_array_parser(instance, truths, instance.base_model)\\n #obs, obs_key = obs_parser(instance, True)\\n obs_key = obs_key_parser(instance, True)\\n preds = preds_parser(instance, True)\\n #forecasts = forecasts_parser(instance, True)\\n \\n ukf_params = instance.ukf_params\\n index2 = ukf_params[\\\"index2\\\"]\\n \\n \\\"remove agents not in model to avoid wierd plots\\\"\\n #obs *= nan_array\\n truths *= nan_array\\n preds *= nan_array\\n #forecasts*= nan_array\\n \\n \\\"indices for unobserved agents\\\"\\n not_index2 = np.array([i for i in np.arange(truths.shape[1]) if i not in index2])\\n plts.pair_frame(truths, preds, obs_key, 10, destination)\\n plts.error_hist(truths[::instance.sample_rate,index2], \\n preds[::instance.sample_rate,index2],\\\"Observed Errors\\\")\\n if len(not_index2)>0:\\n plts.error_hist(truths[::instance.sample_rate, not_index2], \\n preds[::instance.sample_rate, not_index2],\\\"Unobserved Errors\\\")\\n \\n #plts.path_plots(obs[::instance.sample_rate] , \\\"Observed\\\")\\n plts.path_plots(preds[::instance.sample_rate], \\\"Predicted\\\")\\n plts.path_plots(truths, \\\"True\\\")\\n #plts.path_plots(forecasts[::instance.sample_rate], \\\"Forecasts\\\")\\n\\n if animate:\\n #plts.trajectories(truths, \\\"plots/\\\")\\n plts.pair_frames(truths, preds, obs_key,\\n truths.shape[0], \\\"../../plots/\\\")\",\n \"def initial_plots(runs):\\n for run in runs.keys():\\n meta = runs[run]\\n plot_pdfs(meta)\\n plot_priorsamps(meta)\\n plot_ivals(meta)\\n# if meta.truNz is not None:\\n# plot_true(meta)\\n timesaver(meta,'iplot',meta.key)\",\n \"def plot(model, results, filename):\\n\\n # c = model.compartments.get_one(id='c')\\n #\\n # rna_1 = model.species_types.get_one(id='rna_1').species.get_one(compartment=c)\\n # rna_2 = model.species_types.get_one(id='rna_2').species.get_one(compartment=c)\\n # rna_3 = model.species_types.get_one(id='rna_3').species.get_one(compartment=c)\\n #\\n pops = results.get('populations')\\n time = pops.index\\n pop_rna_1 = pops['rna_1[c]']\\n pop_rna_2 = pops['rna_2[c]']\\n pop_rna_3 = pops['rna_3[c]']\\n\\n pop_atp = pops['atp[c]']\\n pop_gtp = pops['gtp[c]']\\n pop_utp = pops['ctp[c]']\\n pop_ctp = pops['utp[c]']\\n\\n pop_amp = pops['amp[c]']\\n pop_gmp = pops['gmp[c]']\\n pop_ump = pops['cmp[c]']\\n pop_cmp = pops['ump[c]']\\n\\n print(pop_rna_1, pop_atp, pop_gtp, pop_utp, pop_ctp)\\n\\n fig1, axes1 = pyplot.subplots(nrows=3, ncols=1)\\n\\n axes1[0].plot(time / 3600, pop_rna_1)\\n axes1[0].plot(time / 3600, pop_rna_2)\\n axes1[0].plot(time / 3600, pop_rna_3)\\n axes1[0].set_xlim((time[0] / 3600, time[-1] / 3600))\\n axes1[0].set_ylim((0., 10.0))\\n axes1[0].legend(loc='upper right')\\n\\n axes1[1].plot(time / 3600, pop_atp)\\n axes1[1].plot(time / 3600, pop_gtp)\\n axes1[1].plot(time / 3600, pop_utp)\\n axes1[1].plot(time / 3600, pop_ctp)\\n axes1[1].set_xlim((time[0] / 3600, time[-1] / 3600))\\n # axes1[1].set_ylim((0., 10.0))\\n axes1[1].legend(loc='upper right')\\n\\n axes1[2].plot(time / 3600, pop_amp)\\n axes1[2].plot(time / 3600, pop_gmp)\\n axes1[2].plot(time / 3600, pop_ump)\\n axes1[2].plot(time / 3600, pop_cmp)\\n axes1[2].set_xlim((time[0] / 3600, time[-1] / 3600))\\n # axes1[2].set_ylim((0., 10.0))\\n axes1[2].legend(loc='upper right')\\n\\n fig1.savefig(filename.format('species'))\\n pyplot.close(fig1)\",\n \"def plot_parcles_run(k, v):\\n\\n L.info(f'Received Input: {v}')\\n\\n L.info(f\\\"Plotting results from: {v['filepath']}\\\")\\n\\n plotpath = Path(__file__).parent.parent / 'plots'\\n filename = v['id'] + '.png'\\n plotfile = str(plotpath / filename) \\n\\n plotTrajectoriesFile(v['filepath'], mode='2d', show_plt=False)\\n f = plt.gcf()\\n f.savefig(plotfile)\\n\\n L.info(f'Saved plot to: {plotfile}')\",\n \"def generate_plots(path):\\n videos = glob(path + '/*.mkv')\\n print(path, len(videos), videos)\\n\\n if len(videos) == 0:\\n return\\n else:\\n videos = videos[0]\\n\\n metadata_list = glob(path + '/metadata.txt')\\n #print(path, len(metadata_list), metadata_list)\\n\\n if len(metadata_list) == 0:\\n return \\n\\n P = Preprocessor()\\n P.import_video(str(videos))\\n P.read_metadata(path)\\n P.preprocess()\\n Im = P.frames_processed\\n if len(Im) == 0:\\n print(len(Im))\\n return\\n\\n z_start = P.z_start\\n z_end = P.z_end\\n\\n mean, cov = analyze_image(Im)\\n\\n window_size = 10\\n mean_smoothed = smoothing.mean_moving_average(mean, window_size)\\n cov_smoothed = smoothing.cov_moving_average(cov, window_size)\\n\\n c = CubicFitRotated()\\n c.fit(mean=mean_smoothed, cov=cov_smoothed, z_start=z_start, z_end=z_end)\\n\\n try:\\n os.mkdir(path + '/analysis')\\n path += '/analysis'\\n except OSError:\\n pass\\n\\n\\n plots.plot_mean(mean, z_start, z_end).savefig(path + '/beam_center.png')\\n plots.plot_beta(cov, z_start, z_end).savefig(path + '/sigma_squared.png')\\n\\n export.export_mean(mean = mean, filename = path + '/center.csv', z_start = z_start, z_end = z_end)\\n export.export_cov(cov = cov, filename = path + '/cov.csv', z_start = z_start, z_end = z_end)\\n\\n plt.close('all')\",\n \"def plot_sample(self):\\n print(u'plot_sample()')\\n data_set = self.data_sets[1]\\n scenario = u'Greedy Search'\\n titles = [u'Collaborative Filtering', u'Content-based']\\n fig, axes = plt.subplots(1, 2, figsize=(10, 5))\\n for i, rec_type in enumerate(data_set.missions):\\n graph = data_set.folder_graphs + rec_type + '_' + str(15) + u'.txt'\\n for strategy in Strategy.strategies:\\n m = data_set.missions[rec_type][graph][strategy][scenario]\\n m.compute_stats()\\n ppl.plot(axes[i], np.arange(STEPS_MAX + 1),\\n m.stats, label=strategy, linewidth=2)\\n axes[i].set_xlabel(u'#Hops')\\n axes[i].set_ylabel(u'Success Ratio')\\n axes[i].set_ylim(0, 85)\\n axes[i].set_xlim(0, STEPS_MAX * 1.01)\\n axes[i].set_title(titles[i])\\n ppl.legend(axes[i], loc=0)\\n\\n\\n # plt.suptitle(u'Greedy Search on the BookCrossing for N=15',\\n # size='xx-large', x=0.5)\\n fig.subplots_adjust(left=0.08, right=0.97, top=0.9)\\n\\n plt.savefig('plots/sample.png')\\n plt.savefig('plots/sample.pdf')\",\n \"def plot_visualization(path_results, x_data, y_data, variant_mode, nb_classes, signal_test, args):\\n\\n\\t#path_tsne = path_results + \\\"/Visualization/train/\\\" + str(args.step) + \\\"_2d.csv\\\"\\n\\t#data_frame = pd.read_csv(path_tsne)\\n\\t\\n\\tpath_maping = path_results + \\\"/Maping/\\\" + str(args.subject).split(\\\".txt\\\")[0] + \\\"/\\\"\\n\\tfilename = path_maping + \\\"maping_\\\" + str(args.step) + \\\"_\\\" + str(args.subject).split(\\\".txt\\\")[0] + \\\"_stick\\\" + str(args.stick) + \\\".png\\\"\\n\\n\\tprint(\\\"path_save maping\\\", path_maping)\\n\\n\\tif not os.path.exists(path_maping):\\n\\t\\tos.makedirs(path_maping)\\n\\n\\t#print(\\\"path_tsne\\\", path_tsne)\\n\\n\\tlabel_maping = np.array([10])\\n\\n\\tx_data = np.concatenate((x_data,signal_test),axis=0)\\n\\ty_data = np.concatenate((y_data,label_maping),axis=0)\\n\\n\\tprint(\\\"x_data concatenate\\\",x_data.shape)\\n\\tprint(\\\"y_data concatenate\\\",y_data.shape)\\n\\n\\tdata_frame = tsne_2d(x_data, y_data)\\n\\n\\t\\n\\t\\n\\tgroups = data_frame.groupby('label')\\n\\n\\tcluster_names, cluster_colors = get_target_names_dr(nb_classes, args.mode, args, variant_mode)\\n\\n\\tfig = plt.figure(figsize=(20, 10))\\n\\tax = fig.add_subplot(111)\\n\\tax.margins(0.05) # Optional, just adds 5% padding to the autoscaling\\n\\tfor name, group in groups:\\n\\t\\t\\n\\t\\tif cluster_names[name] == str(args.subject):\\n\\t\\t\\tax.scatter(group.x, group.y, marker='D', s=150, edgecolors = 'face',label=cluster_names[name], color=cluster_colors[name])\\n\\t\\telse:\\n\\t\\t\\tax.scatter(group.x, group.y, marker='o', label=cluster_names[name], color=cluster_colors[name])\\n\\n\\tax.legend(numpoints=1) #show legend with only 1 point\\n\\tplt.savefig(filename) #save the plot\",\n \"def plot(data, filenames, game, destination, num_interplt):\\n if isinstance(filenames, str):\\n plt.plot(data[:,0], data[:,1], label=filenames)\\n ax = plt.gca()\\n ax.xaxis.get_major_formatter().set_powerlimits((0,1))\\n plt.xlabel('# of steps')\\n plt.ylabel('Cumulative reward')\\n plt.title('{}'.format(game))\\n plt.legend()\\n figname = '{}_{}.png'.format(game, datetime_random_str())\\n plt.savefig('{}/{}'.format(destination, figname))\\n print('Images saved as {}/{}'.format(destination, figname))\\n plt.close()\\n else:\\n print('{} results have been found.'.format(len(filenames)))\\n agents = []\\n for i in range(len(filenames)):\\n # :-24 is to remove the previous datetime string\\n # :-30 is to remove the train label\\n agents.append(filenames[i][:-30])\\n uni_agents = np.unique(np.array(agents))\\n print('Game result from agent: {}'.format(uni_agents))\\n fig = plt.figure()\\n for agent in uni_agents:\\n i_data = []\\n for i in range(len(agents)):\\n if agent == agents[i]:\\n i_data.append(data[i])\\n i_data = calculate_interpolation(np.array(i_data), num_interplt)\\n plot_mean_standard_error(i_data, agent)\\n plt.legend()\\n ax = plt.gca()\\n ax.xaxis.get_major_formatter().set_powerlimits((0,1))\\n plt.xlabel('# of steps')\\n plt.ylabel('Cumulative reward')\\n plt.title('{}'.format(game))\\n figname = '{}_{}.png'.format(game, datetime_random_str())\\n plt.savefig('{}/{}'.format(destination, figname))\\n plt.close()\\n print('Images saved as {}/{}'.format(destination, figname))\",\n \"def plot_pipeline(differences_dir, plots_dir_intonation, num_quantiles = 31):\\n perf_list = ['54363310_1939750539', '540791114_1793842568']\\n difference_path_list = [os.path.join(differences_dir, perf_list[i] + \\\".npy\\\") for i in range(len(perf_list))]\\n comparisons_list = [np.load(path) for _, path in enumerate(difference_path_list)]\\n num_samples = 10000\\n # quantile indices\\n q_indices = (np.linspace(0, 1, num_quantiles)*(num_samples-1)).astype(np.int32)\\n plt.style.use('ggplot')\\n labels = ['perf. A', 'perf. B']\\n colors = ['blue', 'red']\\n linestyles = ['dotted', 'dashed']\\n grid = plt.GridSpec(2, 2)\\n ax1 = plt.subplot(grid[1, 0])\\n ax2 = plt.subplot(grid[1, 1])\\n ax4 = plt.subplot(grid[0, :])\\n ax4.plot(comparisons_list[0], color=colors[0], label=labels[0], linestyle=linestyles[0])\\n ax4.plot(comparisons_list[1], color=colors[1], label=labels[1], linestyle=linestyles[1])\\n ax4.set_title(\\\"Difference between MIDI and pYIN, two performances\\\")\\n ax4.set_ylabel(\\\"Cents\\\")\\n ax4.set_xlabel(\\\"Frames\\\")\\n ax4.axhline(y=200, linestyle=\\\"solid\\\", linewidth=0.7, c=\\\"black\\\", zorder=2, label=\\\"thresh.\\\")\\n ax4.axhline(y=-200, linestyle=\\\"solid\\\", linewidth=0.7, c=\\\"black\\\", zorder=2)\\n ax4.legend(loc=\\\"upper right\\\")\\n ax1.set_title(\\\"10k random sample of distances\\\")\\n ax1.set_ylabel(r\\\"$|$Cents$|$\\\")\\n ax1.set_xlabel(\\\"Frames sorted by distance\\\")\\n ax2.set_title(\\\"Sample quantiles\\\")\\n ax2.set_xlabel(\\\"Quantile indices\\\")\\n # run analysis song by song\\n for i, arr in enumerate(comparisons_list):\\n # random sample so all arrays have the same size\\n samples = np.random.choice(arr, num_samples, replace=True)\\n # sort\\n samples = np.sort(np.abs(samples))\\n # discard the high values (might be due to misalignment, etc...)\\n samples = samples[samples <= 200]\\n samples = np.random.choice(samples, num_samples, replace=True)\\n samples = np.sort(np.abs(samples))\\n ax1.plot(samples, color=colors[i], linestyle=linestyles[i], label=labels[i])\\n # get the quantiles\\n samples = samples[q_indices]\\n ax2.plot(samples, color=colors[i], linestyle=linestyles[i], label=labels[i])\\n ax1.legend()\\n ax2.legend()\\n plt.tight_layout()\\n plt.savefig(os.path.join(plots_dir_intonation, \\\"data processing pipeline.eps\\\"), format=\\\"eps\\\")\\n plt.show()\",\n \"def plot(path, subjects):\\n transformToXYZmm = np.array([[-3.125, 0, 0, 81.250], [0, 3.125, 0, -115.625], [0, 0, 6, -54.000], [0, 0, 0, 1.000]])\\n data = data_load.load_data(path, subjects)\\n dimx = int(data[0][\\\"meta\\\"][\\\"dimx\\\"][0])\\n dimy = int(data[0][\\\"meta\\\"][\\\"dimy\\\"][0])\\n dimz = int(data[0][\\\"meta\\\"][\\\"dimz\\\"][0])\\n coordToCol = data[0][\\\"meta\\\"][\\\"coordToCol\\\"][0][0]\\n images = {}\\n max_val = 0\\n voxels = np.load(\\\"data/general_selected_500_1.npy\\\")\\n directory = os.listdir(\\\"data/input/\\\")\\n bar = pyprind.ProgBar(len(directory), title='Info extraction and Image Building')\\n bar2 = pyprind.ProgBar(len(images.keys()), title='Saving Pictures')\\n for file in directory:\\n file_name = \\\"data/input/{}\\\".format(file)\\n fh = open(file_name)\\n activation_values = np.asarray(list(map(lambda x: float(x), filter(lambda x: x != '', fh.read().split(\\\",\\\")))))\\n fh.close()\\n plot_matrix = np.zeros((dimx, dimy, dimz))\\n for x in range(dimx):\\n for y in range(dimy):\\n for z in range(dimz):\\n indice = coordToCol[x][y][z]\\n if indice != 0:\\n if indice in list(voxels):\\n voxel_indice = list(voxels).index(indice)\\n value = activation_values[voxel_indice]\\n if abs(value) > max_val:\\n max_val = abs(value)\\n plot_matrix[x][y][z] = value\\n image = nib.Nifti1Image(plot_matrix, transformToXYZmm)\\n images[file_name] = image\\n bar.update(force_flush=True)\\n print(bar)\\n for image in images:\\n plotting.plot_glass_brain(images[image], display_mode='ortho', vmax=max_val, plot_abs=False, threshold=None, colorbar=True, output_file=\\\"{}-wom1.png\\\".format(image))\\n bar2.update(force_flush=True)\\n print(bar2)\",\n \"def app_SN_plot_all_active_sample(self, sample_list: List, phases):\\n\\n for sample in sample_list:\\n sample_name = sample['sample_name']\\n print(f'processing: {sample_name}')\\n dfs, phase_dirs, sizer_val, styler_val = self.preprocessing_before_plotting(sample, phases=phases)\\n\\n self.app_SN_combined_master(dfs, phase_dirs, sizer_val, styler_val)\\n self.app_SN_combined_temperature_series(dfs, phase_dirs, sizer_val, styler_val)\\n self.app_SN_combined_temperature_gradient(dfs, phase_dirs, sizer_val, styler_val)\\n self.app_SN_combined_moisture_series(dfs, phase_dirs, sizer_val, styler_val)\\n self.app_SN_combined_moisture_gradient(dfs, phase_dirs, sizer_val, styler_val)\\n self.app_SN_combined_series_moist_vs_temp(dfs, phase_dirs, sizer_val, styler_val)\\n self.app_SN_separate_temperature_series(dfs, phase_dirs, sizer_val, styler_val)\\n self.app_SN_separate_temperature_gradient(dfs, phase_dirs, sizer_val, styler_val)\\n self.app_SN_separate_moisture_series(dfs, phase_dirs, sizer_val, styler_val)\\n self.app_SN_separate_moisture_gradient(dfs, phase_dirs, sizer_val, styler_val)\\n self.app_SN_separate_series_moist_vs_temp(dfs, phase_dirs, sizer_val, styler_val)\\n self.app_SN_last_24h_plots(dfs, phase_dirs, sizer_val, styler_val)\\n self.app_SN_hot_end_temperature(dfs, phase_dirs, sizer_val, styler_val)\",\n \"def save_plots(self):\\n pdir = os.path.splitext(self.filename)[0] + '_plots'\\n if not os.path.exists(pdir):\\n os.mkdir(pdir)\\n\\n for ii in range(self.uv.n_ant):\\n fig, ax = self.plot_single_baseline_dual_pol(ii+1, ii+1)\\n print \\\"Saving ant %i\\\"%ii\\n plt.savefig(os.path.join(pdir, 'ant-%i.png'%ii))\\n plt.clf()\",\n \"def compare_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2013/output',\\n\\t\\t\\t\\tsteps=['step01','step02'],\\n\\t\\t\\t\\t#labels='',\\n\\t\\t\\t\\tshow=True,\\n\\t\\t\\t\\txscale=1e3,\\n\\t\\t\\t\\tyscale=1e-2):\\n\\tplt.figure()\\n\\t#path = '/Users/scott/Desktop/elastic'\\n\\n\\t# Deep source\\n\\tlabels = ['no APMB', 'APMB']\\n\\tdeep = {}\\n\\tuzmax = 0.824873455364\\n\\t# NOT sure why hardcoded...\\n\\tuzmax = 1\\n\\tfor i,outdir in enumerate(steps):\\n\\t\\tpointsFile = os.path.join(path, outdir, 'points.h5')\\n\\n\\t\\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n\\n\\t\\tX = x / xscale\\n\\t\\tY1 = ux / yscale\\n\\n\\t\\tx_fem = X #/ xscale #double scaling!\\n\\t\\tur_fem = Y1 #/ yscale\\n\\t\\tuz_fem = uz / yscale\\n\\n\\t\\t#print(pointsFile)\\n\\t\\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\\n\\n\\t\\t#normalize\\n\\t\\tuz_fem = uz_fem / uzmax\\n\\t\\tur_fem = ur_fem / uzmax\\n\\t\\tx_fem = x_fem / 30.0\\n\\n\\t\\tl, = plt.plot(x_fem,uz_fem,'o-',ms=4,lw=4,label=labels[i])\\n\\t\\tplt.plot(x_fem,ur_fem,'o--',ms=4,lw=4,color=l.get_color()) #mfc='none' transparent\\n\\t\\tdeep[outdir] = uz_fem/uz_fem\\n\\n\\n\\t# Shallow Source\\n\\tshallow = {}\\n\\tuzmax = 0.949652827795 # Why?\\n\\tfor i,outdir in enumerate(['step11','step12']):\\n\\t\\tpointsFile = os.path.join(path, outdir, 'points.h5')\\n\\n\\t\\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n\\n\\t\\tX = x / xscale\\n\\t\\tY1 = ux / yscale\\n\\n\\t\\tx_fem = X #/ xscale #double scaling!\\n\\t\\tur_fem = Y1 #/ yscale\\n\\t\\tuz_fem = uz / yscale\\n\\n\\t\\t#print(pointsFile)\\n\\t\\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\\n\\n\\t\\t#normalize\\n\\t\\tuz_fem = uz_fem / uzmax\\n\\t\\tur_fem = ur_fem / uzmax\\n\\t\\tx_fem = x_fem / 20.0\\n\\n\\t\\tl, = plt.plot(x_fem,uz_fem,'.-', mfc='w', lw=4,label=labels[i])\\n\\t\\tplt.plot(x_fem,ur_fem,'.--',lw=4, mfc='w',color=l.get_color()) #mfc='none' transparent\\n\\n\\t\\tshallow[outdir] = uz_fem/ur_fem\\n\\n\\t# Annotate\\n\\tplt.axhline(color='k',lw=0.5)\\n\\t#plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n\\t#plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\\n\\tplt.legend()\\n\\tplt.grid()\\n\\t#plt.ylim(-0.5, 3.5)\\n\\t#plt.savefig('deep.png',bbox_inches='tight')\\n\\t#plt.savefig('shallow.png',bbox_inches='tight')\\n\\n\\t# normalized\\n\\tplt.ylim(-0.5, 4)\\n\\tplt.xlim(0,10)\\n\\tplt.xlabel('Normalized Radial Distance [R / D]')\\n\\tplt.ylabel('Normalized Displacement [U / Uz_max]')\\n\\t#plt.savefig('normalized_deep.png',bbox_inches='tight')\\n\\tplt.savefig('normalized_shallow.png',bbox_inches='tight')\\n\\n\\n\\t# Plot ratios of uz versus NOTE: this plot is confusing,,, just keep ratio of uz_max to ur_max\\n\\t'''\\n\\tplt.figure()\\n\\tplt.plot(x_fem, deep['step01'], label='Deep no APMB')\\n\\tplt.plot(x_fem, deep['step02'], label='Deep w/ APMB')\\n\\tplt.plot(x_fem, shallow['step11'], label='Shallow no APMB')\\n\\tplt.plot(x_fem, shallow['step12'], label='Shallow w/ APMB')\\n\\tplt.xlabel('Distance [km]') #NOTE: maybe plot normailzed X-axis (R-d)\\n\\t#plt.xlabel('Normalized Distance [R/d]')\\n\\tplt.ylabel('Ratio [Uz/Ur]')\\n\\tplt.title('Ratio of vertical to radial displacement')\\n\\tplt.legend()\\n\\tplt.show()\\n\\t'''\",\n \"def plot_results(dir_path):\\n results, labels, dx = get_results_labels(dir_path)\\n\\n colors = plt.cm.get_cmap('tab10', len(labels)+1)\\n fig = plt.figure(figsize=(16, 9))\\n for i, (label, result) in enumerate(zip(labels, results)):\\n plt.plot(np.arange(result.shape[1]) * dx, np.mean(result, 0),\\n color=colors(i), linewidth=2, label=label)\\n plt.fill_between(np.arange(len(result[0])) * dx,\\n np.mean(result, 0) - np.std(result, 0),\\n np.mean(result, 0) + np.std(result, 0),\\n alpha=0.25, color=colors(i))\\n plt.title('Training Performance of Different Algorithms', fontsize=25)\\n plt.ylabel('Cumulative return', fontsize=20)\\n plt.xlabel('Steps', fontsize=20)\\n plt.xlim([0, results[0].shape[1] * dx])\\n plt.tick_params(labelsize=15)\\n plt.ticklabel_format(axis='both', style='sci', scilimits=(-2, 2))\\n plt.legend(fontsize=20)\\n plt.grid(linestyle=':')\\n plt.show()\\n\\n return fig\",\n \"def generate_images(self, model, test_input, step, dst_dir):\\n prediction = model(test_input)\\n\\n plt.figure(figsize=(12, 12))\\n display_list = [test_input[0], prediction[0]]\\n title = ['Input Image', 'Predicted Image']\\n\\n for i in range(2):\\n plt.subplot(1, 2, i+1)\\n plt.title(title[i])\\n # getting the pixel values between [0, 1] to plot it.\\n plt.imshow(display_list[i] * 0.5 + 0.5)\\n plt.axis('off')\\n filename = os.path.join(dst_dir, 'generated_imgs_at_step_{:06d}.png'.format(step))\\n plt.savefig(filename)\",\n \"def make_plots(self):\\n n_rounds = self.run.n_rounds\\n\\n log.info('Making %d frames', n_rounds)\\n args = [self._get_for_parallel(i) for i in range(n_rounds)]\\n self.lbv.map(_plot_helper, args)\",\n \"def _step_plot_closure(self, step_number):\\n for image_name, image, clean_net_output in zip(self.images_names, self.images, self.clean_nets_outputs):\\n plot_image_grid(image_name + \\\"_watermark_clean_{}\\\".format(step_number),\\n [np.clip(torch_to_np(self.watermark_net_output), 0, 1),\\n np.clip(torch_to_np(clean_net_output), 0, 1)])\\n plot_image_grid(image_name + \\\"_learned_image_{}\\\".format(step_number),\\n [np.clip(torch_to_np(self.watermark_net_output) * torch_to_np(self.mask_net_output) +\\n (1 - torch_to_np(self.mask_net_output)) * torch_to_np(clean_net_output),\\n 0, 1), image])\",\n \"def visualize(self, paths, instance, during_analysis):\\r\\n xvalues = np.arange(self.data.shape[0])\\r\\n\\r\\n model_data = self.model_data_from_instance(instance=instance)\\r\\n\\r\\n residual_map = self.data - model_data\\r\\n chi_squared_map = (residual_map / self.noise_map) ** 2.0\\r\\n\\r\\n \\\"\\\"\\\"The visualizer now outputs images of the best-fit results to hard-disk (checkout `visualizer.py`).\\\"\\\"\\\"\\r\\n plot_profile_1d(\\r\\n xvalues=xvalues,\\r\\n profile_1d=self.data,\\r\\n title=\\\"Data\\\",\\r\\n ylabel=\\\"Data Values\\\",\\r\\n color=\\\"k\\\",\\r\\n output_path=paths.image_path,\\r\\n output_filename=\\\"data\\\",\\r\\n )\\r\\n\\r\\n plot_profile_1d(\\r\\n xvalues=xvalues,\\r\\n profile_1d=model_data,\\r\\n title=\\\"Model Data\\\",\\r\\n ylabel=\\\"Model Data Values\\\",\\r\\n color=\\\"k\\\",\\r\\n output_path=paths.image_path,\\r\\n output_filename=\\\"model_data\\\",\\r\\n )\\r\\n\\r\\n plot_profile_1d(\\r\\n xvalues=xvalues,\\r\\n profile_1d=residual_map,\\r\\n title=\\\"Residual Map\\\",\\r\\n ylabel=\\\"Residuals\\\",\\r\\n color=\\\"k\\\",\\r\\n output_path=paths.image_path,\\r\\n output_filename=\\\"residual_map\\\",\\r\\n )\\r\\n\\r\\n plot_profile_1d(\\r\\n xvalues=xvalues,\\r\\n profile_1d=chi_squared_map,\\r\\n title=\\\"Chi-Squared Map\\\",\\r\\n ylabel=\\\"Chi-Squareds\\\",\\r\\n color=\\\"k\\\",\\r\\n output_path=paths.image_path,\\r\\n output_filename=\\\"chi_squared_map\\\",\\r\\n )\",\n \"def walkplot(cons):\\n # Call always after cons.runn()!\\n if not hasattr(cons, \\\"outplot\\\"):\\n print(\\\"Consortium must run before analyzing the output of the run!\\\")\\n return\\n global plt\\n if not plt:\\n import matplotlib.pyplot as plt\\n\\n # keep original inputs\\n original_metplots = dcp(cons.mets_to_plot)\\n original_outplot = dcp(cons.outplot)\\n cons.outplot = \\\"tmp.png\\\"\\n mets = [k for k in cons.media]\\n # loop over metabolites, plot them and let the user close the window\\n for m in range(0, len(mets), 4):\\n cons.mets_to_plot = [mets[m], mets[m + 1], mets[m + 2], mets[m + 3]]\\n plot_comm(cons)\\n plt.show()\\n print(\\\"Image number\\\", m / 4)\\n\\n # clean temporary files, return to orginal parameters\\n plt.close(\\\"all\\\")\\n os.remove(cons.outplot)\\n cons.mets_to_plot = original_metplots\\n cons.outplot = original_outplot\\n return\",\n \"def save_plot(epoch_num, step, rewards, filepath):\\n fig, ax = plt.subplots() \\n ax.plot(range(0, epoch_num + 1, step), rewards)#,'.')\\n ax.plot(range(0, epoch_num + 1, step), np.ones(len(range(0, epoch_num + 1, step)))*rewards[0], 'r')\\n fig.savefig(filepath)\\n plt.close(fig) # close the figure \",\n \"def main():\\n import argparse\\n import os\\n parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)\\n parser.add_argument('--dirs', help='List of log directories', nargs='*', default=['./log'])\\n parser.add_argument('--num_timesteps', type=int, default=int(10e6))\\n parser.add_argument('--xaxis', help='Varible on X-axis', default=X_TIMESTEPS)\\n parser.add_argument('--task_name', help='Title of plot', default='Breakout')\\n args = parser.parse_args()\\n args.dirs = [os.path.abspath(folder) for folder in args.dirs]\\n plot_results(args.dirs, args.num_timesteps, args.xaxis, args.task_name)\\n plt.show()\",\n \"def multi_plot(self, plottitle, gof_fileroot, indir, outdir,\\n legends, num_stations):\\n # Pick components and labels\\n xtick_loc = XTICK_LOC_0_01\\n xtick_label = XTICK_LABEL_0_01\\n\\n # Initialize data arrays\\n periods = [[] for _ in range(len(gof_fileroot))]\\n bias = [[] for _ in range(len(gof_fileroot))]\\n m90 = [[] for _ in range(len(gof_fileroot))]\\n p90 = [[] for _ in range(len(gof_fileroot))]\\n sigma = [[] for _ in range(len(gof_fileroot))]\\n sigma0 = [[] for _ in range(len(gof_fileroot))]\\n\\n bias_l = [[] for _ in range(len(gof_fileroot))]\\n bias_h = [[] for _ in range(len(gof_fileroot))]\\n conf_l = [[] for _ in range(len(gof_fileroot))]\\n conf_h = [[] for _ in range(len(gof_fileroot))]\\n\\n # Read data from all input files\\n for compnum in xrange(0, len(gof_fileroot)):\\n filenamebase = os.path.join(indir, gof_fileroot[compnum])\\n #print(\\\"Reading component files %s.*\\\" % (filenamebase))\\n periods[compnum], bias[compnum] = self.read_data(\\\"%s.bias\\\" %\\n (filenamebase),\\n 0.01)\\n periods[compnum], m90[compnum] = self.read_data(\\\"%s.m90\\\" %\\n (filenamebase),\\n 0.01)\\n periods[compnum], p90[compnum] = self.read_data(\\\"%s.p90\\\" %\\n (filenamebase),\\n 0.01)\\n periods[compnum], sigma[compnum] = self.read_data(\\\"%s.sigma\\\" %\\n (filenamebase),\\n 0.01)\\n periods[compnum], sigma0[compnum] = self.read_data(\\\"%s.sigma0\\\" %\\n (filenamebase),\\n 0.01)\\n\\n # Compute bias and conf interval lower/upper bounds\\n for i in xrange(0, len(bias[compnum])):\\n bias_l[compnum].append(bias[compnum][i] - sigma0[compnum][i])\\n bias_h[compnum].append(bias[compnum][i] + sigma0[compnum][i])\\n conf_l[compnum].append(m90[compnum][i])\\n conf_h[compnum].append(p90[compnum][i])\\n\\n num_periods = len(periods[0])\\n for comp in periods:\\n if len(comp) != num_periods:\\n print(\\\"Number of data points unequal across components\\\")\\n return\\n\\n # Construct baseline\\n baseline = [0.0 for _ in periods[0]]\\n\\n # Find max, min values\\n min_x = min([min(comp) for comp in periods])\\n max_x = max([max(comp) for comp in periods])\\n min_y = MIN_Y_AXIS\\n max_y = MAX_Y_AXIS\\n\\n # Start plots\\n num_plots = len(gof_fileroot)\\n # Make 1 column of \\\"num_plots\\\" rows\\n fig, axs = pylab.plt.subplots(num_plots, 1)\\n # Set plot dims\\n fig.set_size_inches(6, 10)\\n\\n #subplots_adjust(left=0.125)\\n #subplots_adjust(right=0.9)\\n #subplots_adjust(top=0.85)\\n fig.subplots_adjust(hspace=0.4)\\n fig.subplots_adjust(wspace=0.5)\\n\\n # Add subplots in a list\\n subfigs = []\\n for idx in range(0, num_plots):\\n subfigs.append(axs[idx])\\n\\n # Now walk through each subfig\\n for (subfig, subplot_title, cur_period,\\n cur_bias, cur_bias_h, cur_bias_l,\\n cur_conf_h, cur_conf_l) in zip(subfigs,\\n legends,\\n periods,\\n bias,\\n bias_h,\\n bias_l,\\n conf_h,\\n conf_l):\\n subfig.set_xlim(min_x, max_x)\\n subfig.set_ylim(min_y, max_y)\\n subfig.set_title(\\\"%s\\\" % subplot_title, size=10)\\n subfig.plot(cur_period, cur_bias, color='red', label='_nolegend_')\\n subfig.fill_between(cur_period, cur_bias_h,\\n cur_bias_l, color='cyan',\\n label='_nolegend_')\\n subfig.fill_between(cur_period, cur_conf_h,\\n cur_conf_l, color='yellow',\\n label='_nolegend_')\\n subfig.plot(cur_period, baseline, color='grey',\\n label='_nolegend_')\\n # Only put xlabel on bottom plot\\n if legends.index(subplot_title) == len(gof_fileroot) - 1:\\n subfig.set_xlabel(\\\"Period (sec)\\\", size=8)\\n subfig.set_ylabel(\\\"ln (data/model)\\\", size=8)\\n subfig.set_xscale('log')\\n # Old way to do it\\n # subfig.set_xticks(xtick_loc, xtick_label)\\n subfig.set_xticks(xtick_loc)\\n subfig.set_xticklabels(xtick_label)\\n subfig.tick_params(labelsize=8)\\n subfig.minorticks_on()\\n\\n fig.suptitle('%s\\\\nNumber of stations: %d' % (plottitle, num_stations),\\n size=12)\\n # Figure out output filename\\n outfile = gof_fileroot[0]\\n outfile = outfile[:outfile.rfind(\\\"-\\\")]\\n outfile = os.path.join(outdir, \\\"gof-%s.png\\\" % (outfile))\\n print(\\\"==> Created GoF plot: %s\\\" % (outfile))\\n fig.savefig(outfile, format=\\\"png\\\",\\n transparent=False, dpi=plot_config.dpi)\\n pylab.close()\",\n \"def plot_model(model, inputs, outputs, tss=90):\\n mdl = np.load(model)\\n sys = ss(mdl['A'], mdl['B'], mdl['C'], mdl['D'],1)\\n gain_matrix = dcgain(sys).T\\n num_i = len(inputs)\\n num_o = len(outputs)\\n fig, axs = plt.subplots(num_i,num_o, figsize=(3*len(outputs), 2*len(inputs)), facecolor='w', edgecolor='k')\\n fig.suptitle('Step responce: '+model)\\n T = np.arange(tss)\\n for idx_i in range(num_i):\\n for idx_o in range(num_o):\\n ax = axs[idx_i][idx_o]\\n t,y_step = step_response(sys,T, input=idx_i, output=idx_o)\\n gain = round(gain_matrix[idx_i][idx_o],4)\\n ax.plot(t, y_step,color='r')\\n if idx_i == 0:\\n ax.set_title(outputs[idx_o], rotation='horizontal', ha='center', fontsize=10)\\n if idx_o == 0:\\n ax.set_ylabel(inputs[idx_i], rotation=90, fontsize=10)\\n ax.grid(color='k', linestyle='--', linewidth=0.5)\\n ax.tick_params(axis='x', colors='red',size=0,labelsize=4)\\n ax.tick_params(axis='y', colors='red',size=0,labelsize=4)\\n ax.annotate(str(gain),xy=(.72,.8),xycoords='axes fraction')\\n # fig.tight_layout()\\n plt.show()\",\n \"def combine_plot(qa_out_path,brain_path):\\n \\n #Get the scan volume of the brain.\\n brain_ref = nib.load(brain_path)\\n brain_ref_shape = brain_ref.shape[0:3]\\n \\n plots_list = ['Rotate_Z_axis_000000.png','Rotate_Z_axis_000001.png','Rotate_Z_axis_000002.png',\\n 'Rotate_Y_axis_000000.png','Rotate_Y_axis_000001.png','Rotate_Y_axis_000002.png',\\n 'Rotate_X_axis_000000.png','Rotate_X_axis_000001.png','Rotate_X_axis_000002.png']\\n y_labels = [\\\"Rotate with Z axis\\\",\\\"Rotate with Y axis\\\",\\\"Rotate with X axis\\\"]\\n x_labels = [\\\"angle=0\\\",\\\"angle=120\\\",\\\"angle=240\\\"]\\n \\n #Temporary list to store the image nparray:\\n im_arr=[] \\n \\n fig= plt.figure()\\n plt.title(f'QA_tractography. Scan volume = {brain_ref_shape} \\\\n\\\\n', fontsize=60,fontweight='bold')\\n plt.xticks([])\\n plt.yticks([])\\n plt.axis(\\\"off\\\")\\n\\n j = 0\\n for i in range(9):\\n #Load in the nine images into a nparray one by one.\\n im_arr = np.array(Image.open(qa_out_path + \\\"/\\\" + plots_list[i]))\\n #Change the background of the image into black:\\n im_arr = np.where(im_arr<=0.01, 255, im_arr) \\n ax = fig.add_subplot(3,3,i+1)\\n ax.imshow(im_arr,interpolation=\\\"none\\\",alpha=0.9)\\n \\n #Set the X labels and Y labels\\n if i<3:\\n ax.set_title(x_labels[i],fontsize=60,fontweight='bold')\\n if i % 3 == 0:\\n ax.set_ylabel(y_labels[j],fontsize=60,fontweight='bold')\\n j = j + 1\\n plt.xticks([])\\n plt.yticks([])\\n \\n fig.set_size_inches(40, 40, forward = True)\\n fig.savefig(qa_out_path + \\\"/\\\" + 'qa_tractography.png', format='png')\\n\\n #Delete the Nine images which used to generate the qa_tractography.png \\n for plot in plots_list:\\n if os.path.exists(qa_out_path + \\\"/\\\" + plot):\\n os.remove(qa_out_path + \\\"/\\\" + plot)\\n else:\\n print('No such file generated from streamlines window. Please check if the streamline.trk files is generated from the pipeline correctly or not')\",\n \"def analyse_plots(plot_dict, data_dict) :\\n for component in [ '_x', '_y' ] :\\n z_pos = array.array( 'd' )\\n trans_pos = array.array( 'd' )\\n errors = array.array( 'd' )\\n zeros = array.array( 'd' )\\n\\n plot = plot_dict['beam_positions'+component]\\n\\n for i in range( plot.GetXaxis().GetNbins()+2 ) :\\n projection = plot.ProjectionY( \\\\\\n 'profile'+component+'_pro_'+str(i), i, i )\\n if projection.GetEntries() == 0 :\\n continue\\n\\n pro_mean, pro_mean_err, pro_std, pro_std_err = \\\\\\n scifi.fit_gaussian( projection )\\n\\n errors.append( pro_mean_err )\\n trans_pos.append( pro_mean )\\n z_pos.append( data_dict['station_positions'][ i-6 ] )\\n zeros.append(0.0)\\n\\n position_graph = ROOT.TGraphErrors( len(zeros), z_pos, trans_pos, \\\\\\n zeros, errors )\\n position_graph.SetName('beam_profile'+component)\\n plot_dict['beam_profile'+component] = position_graph\\n\\n profile_x = plot_dict['beam_profile_x']\\n profile_y = plot_dict['beam_profile_y']\\n\\n up_x_func = ROOT.TF1( \\\"up_fit_x\\\", \\\"pol1\\\", -5000.0, 0.0 )\\n up_y_func = ROOT.TF1( \\\"up_fit_y\\\", \\\"pol1\\\", -5000.0, 0.0 )\\n down_x_func = ROOT.TF1( \\\"down_fit_x\\\", \\\"pol1\\\", 0.0, 5000.0 )\\n down_y_func = ROOT.TF1( \\\"down_fit_y\\\", \\\"pol1\\\", 0.0, 5000.0 )\\n\\n up_fit_x = profile_x.Fit( 'up_fit_x', \\\"QSR\\\" )\\n up_fit_y = profile_y.Fit( 'up_fit_y', \\\"QSR\\\" )\\n down_fit_x = profile_x.Fit( 'down_fit_x', \\\"QSR\\\" )\\n down_fit_y = profile_y.Fit( 'down_fit_y', \\\"QSR\\\" )\\n\\n plot_dict['beam_profile_x_up_fit'] = up_x_func\\n plot_dict['beam_profile_y_up_fit'] = up_y_func\\n plot_dict['beam_profile_x_down_fit'] = down_x_func\\n plot_dict['beam_profile_y_down_fit'] = down_y_func\\n\\n\\n up_beam_gra_x = up_x_func.GetParameter(1)\\n up_beam_gra_x_err = up_x_func.GetParError(1)\\n up_beam_gra_y = up_y_func.GetParameter(1)\\n up_beam_gra_y_err = up_y_func.GetParError(1)\\n\\n up_beam_pos_x = data_dict['station_positions'][-1]*up_beam_gra_x + up_x_func.GetParameter(0)\\n up_beam_pos_x_err = up_x_func.GetParError(0)\\n up_beam_pos_y = data_dict['station_positions'][-1]*up_beam_gra_y + up_y_func.GetParameter(0)\\n up_beam_pos_y_err = up_y_func.GetParError(0)\\n\\n up_beam_rot_x = math.atan( up_beam_gra_x )\\n up_beam_rot_x_err = up_beam_gra_x_err # Approx linear\\n up_beam_rot_y = math.atan( up_beam_gra_y )\\n up_beam_rot_y_err = up_beam_gra_y_err # Approx linear\\n\\n\\n\\n down_beam_gra_x = down_x_func.GetParameter(1)\\n down_beam_gra_x_err = down_x_func.GetParError(1)\\n down_beam_gra_y = down_y_func.GetParameter(1)\\n down_beam_gra_y_err = down_y_func.GetParError(1)\\n\\n down_beam_pos_x = data_dict['station_positions'][1]*down_beam_gra_x + down_x_func.GetParameter(0)\\n down_beam_pos_x_err = down_x_func.GetParError(0)\\n down_beam_pos_y = data_dict['station_positions'][1]*down_beam_gra_y + down_y_func.GetParameter(0)\\n down_beam_pos_y_err = down_y_func.GetParError(0)\\n\\n down_beam_rot_x = math.atan( down_beam_gra_x )\\n down_beam_rot_x_err = down_beam_gra_x_err # Approx linear\\n down_beam_rot_y = math.atan( down_beam_gra_y )\\n down_beam_rot_y_err = down_beam_gra_y_err # Approx linear\\n\\n\\n# down_pos_x = down_beam_pos_x - data_dict['station_positions'][1]*up_beam_gra_x + up_x_func.GetParameter(0)\\n# down_pos_x_err = math.sqrt( up_x_func.GetParError(0)**2 + down_beam_pos_x_err**2 )\\n# down_pos_y = down_beam_pos_y - data_dict['station_positions'][1]*up_beam_gra_y + up_y_func.GetParameter(0)\\n# down_pos_y_err = math.sqrt( up_y_func.GetParError(0)**2 + down_beam_pos_y_err**2 )\\n\\n length = TRACKER_SEPARATION\\n down_pos_x = down_beam_pos_x - ( up_beam_pos_x + length*up_beam_gra_x )\\n down_pos_x_err = math.sqrt( up_beam_pos_x_err**2 + down_beam_pos_x_err**2 + (length*up_beam_gra_x_err)**2 )\\n down_pos_y = down_beam_pos_y - ( up_beam_pos_y + length*up_beam_gra_y )\\n down_pos_y_err = math.sqrt( up_beam_pos_y_err**2 + down_beam_pos_y_err**2 + (length*up_beam_gra_y_err)**2 )\\n\\n down_rot_x = down_beam_rot_x - up_beam_rot_x\\n down_rot_x_err = math.sqrt( down_beam_rot_x_err**2 + up_beam_rot_x_err**2 )\\n down_rot_y = down_beam_rot_y - up_beam_rot_y\\n down_rot_y_err = math.sqrt( down_beam_rot_y_err**2 + up_beam_rot_y_err**2 )\\n\\n\\n print\\n print \\\"Incoming Beam Misalignments:\\\"\\n print\\n print \\\"Displacement and rotation of beam with respect to upstream tracker:\\\"\\n print\\n print \\\"X Position = {0:0.3f} +/- {1:0.3f} mm\\\".format( up_beam_pos_x, up_beam_pos_x_err )\\n print \\\"Y Position = {0:0.3f} +/- {1:0.3f} mm\\\".format( up_beam_pos_y, up_beam_pos_y_err )\\n print\\n print \\\"X Rotation = {0:0.3f} +/- {1:0.3f} mrad\\\".format( up_beam_rot_x*1000.0, up_beam_rot_x_err*1000.0 )\\n print \\\"Y Rotation = {0:0.3f} +/- {1:0.3f} mrad\\\".format( up_beam_rot_y*1000.0, up_beam_rot_y_err*1000.0 )\\n print\\n\\n print\\n print \\\"Downstream Tracker Beam Misalignments:\\\"\\n print\\n print \\\"Displacement and rotation of beam with respect to downstream tracker:\\\"\\n print\\n print \\\"X Position = {0:0.3f} +/- {1:0.3f} mm\\\".format( down_beam_pos_x, down_beam_pos_x_err )\\n print \\\"Y Position = {0:0.3f} +/- {1:0.3f} mm\\\".format( down_beam_pos_y, down_beam_pos_y_err )\\n print\\n print \\\"X Rotation = {0:0.3f} +/- {1:0.3f} mrad\\\".format( down_beam_rot_x*1000.0, down_beam_rot_x_err*1000.0 )\\n print \\\"Y Rotation = {0:0.3f} +/- {1:0.3f} mrad\\\".format( down_beam_rot_y*1000.0, down_beam_rot_y_err*1000.0 )\\n print\\n\\n print\\n print \\\"Downstream Tracker Alignment:\\\"\\n print\\n print \\\"Displacement and rotation of between the two trackers:\\\"\\n print\\n print \\\"X Position = {0:0.3f} +/- {1:0.3f} mm\\\".format( down_pos_x, down_pos_x_err )\\n print \\\"Y Position = {0:0.3f} +/- {1:0.3f} mm\\\".format( down_pos_y, down_pos_y_err )\\n print\\n print \\\"X Rotation = {0:0.3f} +/- {1:0.3f} mrad\\\".format( down_rot_x*1000.0, down_rot_x_err*1000.0 )\\n print \\\"Y Rotation = {0:0.3f} +/- {1:0.3f} mrad\\\".format( down_rot_y*1000.0, down_rot_y_err*1000.0 )\\n print\",\n \"def __init__(self, output_directory: str, step: int = 100, **kwargs) -> None:\\n self.directory = output_directory\\n self.plot_front = Plot(title=\\\"Pareto front approximation\\\", **kwargs)\\n self.last_front = []\\n self.fronts = []\\n self.counter = 0\\n self.step = step\\n\\n if Path(self.directory).is_dir():\\n LOGGER.warning(\\\"Directory {} exists. Removing contents.\\\".format(self.directory))\\n for file in os.listdir(self.directory):\\n os.remove(\\\"{0}/{1}\\\".format(self.directory, file))\\n else:\\n LOGGER.warning(\\\"Directory {} does not exist. Creating it.\\\".format(self.directory))\\n Path(self.directory).mkdir(parents=True)\",\n \"def output_results(self, filename):\\n\\n self.data.plot(title='Result of applying {} onto data set'.format(self.transformations[-1]))\\n plt.savefig(\\\"results/{}.png\\\".format(filename))\\n plt.close()\",\n \"def plot_training_progress(model_output_path):\\n try:\\n results = load_results(model_output_path)\\n except FileNotFoundError:\\n print('monitor.csv file is not found!')\\n\\n results['l_moving_avg_100'] = results['l'].rolling(window=100).mean()\\n results['r_moving_avg_100'] = results['r'].rolling(window=100).mean()\\n results['t_per_M'] = results['t'] / 1000\\n\\n fig, axs = plt.subplots()\\n results.plot(\\n ax=axs,\\n x='t_per_M', y='r_moving_avg_100',\\n title='Training Progress',\\n xlabel='Million Steps',\\n ylabel='Mean Reward'\\n )\\n return results\",\n \"def ex_plot_sequence(ax, path, fname, num_checkpoints, prefix=None, step=1, pause_time=0.01):\\n\\n if type(num_checkpoints) is tuple:\\n if len(num_checkpoints) > 2:\\n raise ValueError(\\\"Cannot accept more than 2 limits for num_checkpoints\\\")\\n if num_checkpoints[0] == 0:\\n n_min = 1\\n else:\\n n_min = int(num_checkpoints[0])\\n n_max = int(num_checkpoints[1])\\n else:\\n n_min = 1\\n n_max = int(num_checkpoints)\\n\\n # Check input arguments\\n if type(path) is not list:\\n path = [path]\\n\\n if type(fname) is not list:\\n fname = [fname]\\n\\n # Iterate over all files and generate animations\\n for p in path:\\n for f in fname:\\n for n in range(n_min, n_max, step):\\n if prefix is not None:\\n cname = '%s/%s/%s_epoch_%d.pkl' % (prefix, p, f, int(n))\\n else:\\n cname = '%s/%s_epoch_%d.pkl' % (p, f, int(n))\\n solv = solver.Solver(None, None)\\n solv.load_checkpoint(cname)\\n title = '%s (epoch %d)' % (f, n)\\n vis_solver.plot_model_first_layer(ax, solv.model, title=title)\\n plt.pause(pause_time)\\n plt.draw()\",\n \"def plot_multi_outputs(X_list, gp,xlim,n_outputs):\\r\\n\\r\\n slices = GPy.util.multioutput.get_slices(X_list)\\r\\n fig = plt.figure(figsize=(15, 8))\\r\\n plt.subplots_adjust(hspace=0.)\\r\\n for i in range(1, n_outputs+1):\\r\\n ax = plt.subplot(n_outputs, 1, i)\\r\\n ax.tick_params(axis=\\\"both\\\", direction=\\\"in\\\", bottom=True, top=True, left=True, right=True)\\r\\n ax.tick_params(axis=\\\"both\\\", labelbottom=False)\\r\\n ax.set_xlim(xlim)\\r\\n ax.set_ylabel(f'Output {i}')\\r\\n gp.plot(plot_limits=xlim, ax=ax, fixed_inputs=[(1, i-1)], which_data_rows=slices[i-1], legend=False)\\r\\n ax.tick_params(axis=\\\"both\\\", labelbottom=True)\\r\\n plt.show()\\r\\n return\",\n \"def Plot(self):\\n\\n ### Create the path names ###\\n folder_string = self.params.folder+\\\"/plots/\\\"\\n u_string = self.params.folder+\\\"/plots/u.pdf\\\"\\n p_string = self.params.folder+\\\"/plots/p.pdf\\\"\\n\\n ### Check if folder exists ###\\n if not os.path.exists(folder_string): os.makedirs(folder_string)\\n\\n ### Plot the x component of velocity ###\\n plot(self.u_next[0],title=\\\"Velocity in the x Direction\\\")\\n plt.savefig(u_string)\\n plt.figure()\\n\\n ### Plot the pressure ###\\n plot(self.p_next,title=\\\"Pressure\\\")\\n plt.savefig(p_string)\\n plt.show()\",\n \"def plotting(self,job,input_zip,output_file,df,my_dpi):\\n if len(job.Y2headers)>0:\\n X1=df.loc[:,job.X1header].values\\n X2=df.loc[:,job.X2header].values\\n Y1=df.loc[:,job.Y1headers].values\\n if (job.name.startswith(\\\"Morphine\\\") or job.name.startswith(\\\"Sarin\\\")) and os.path.exists(job.experimentalData):\\n df2=pd.read_csv(job.experimentalData)\\n Y2=np.array(df2.loc[:,job.Y2headers].values)\\n X1=np.array(df2.loc[:,job.X1header].values[:Y2.shape[0]])\\n Y1=np.array(df.loc[:,job.Y1headers].values[:Y2.shape[0]])\\n X2=np.array(df.loc[:,job.X2header].values[:Y2.shape[0]])\\n else:\\n Y2=df.loc[:,job.Y2headers].values\\n fig,ax = plt.subplots()\\n fig.set_size_inches(w=job.imageWidth/my_dpi+3.1,h=job.imageHeight/my_dpi+1)\\n \\n if not os.path.exists(job.outputDir):\\n os.mkdir(job.outputDir)\\n \\n if job.X1LowerBound and job.X1UpperBound:\\n ax.set_xlim(job.X1LowerBound,job.X1UpperBound)\\n elif job.X1LowerBound:\\n ax.set_xlim(left=job.X1LowerBound)\\n elif job.X1UpperBound:\\n ax.set_xlim(right=job.X1UpperBound)\\n\\n if job.Y1LowerBound and job.Y1UpperBound:\\n ax.set_ylim(job.Y1LowerBound,job.Y1UpperBound)\\n elif job.Y1LowerBound:\\n ax.set_ylim(bottom=job.Y1LowerBound)\\n elif job.Y1UpperBound:\\n ax.set_ylim(top=job.Y1UpperBound) \\n \\n ax.get_yaxis().set_major_locator(MaxNLocator(nbins=18,min_n_ticks=8))\\n ax.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\\n ax.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\\n ax.set_xlabel(job.X1header,fontsize=job.fontSize)\\n \\n if job.Y1Label!=None:\\n ax.set_ylabel(job.Y1Label,color=\\\"g\\\",fontsize=job.fontSize)\\n else:\\n ax.set_ylabel(job.Y1headers[0],color=\\\"g\\\",fontsize=job.fontSize)\\n p1=ax.plot(X1,Y1,color=\\\"g\\\")\\n\\n ax2=ax.twinx()\\n \\n if job.Y2LowerBound and job.Y2UpperBound:\\n ax2.set_ylim(job.Y2LowerBound,job.Y2UpperBound)\\n elif job.Y2LowerBound:\\n ax2.set_ylim(bottom=job.Y2LowerBound)\\n elif job.Y2UpperBound:\\n ax2.set_ylim(top=job.Y2UpperBound)\\n \\n ax2.get_yaxis().set_major_locator(MaxNLocator(nbins=18,min_n_ticks=8))\\n ax2.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\\n ax2.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\\n ax2.set_xlabel(job.X1header,fontsize=job.fontSize)\\n \\n if job.Y2Label!=None:\\n ax2.set_ylabel(job.Y2Label,color=\\\"b\\\",fontsize=job.fontSize)\\n else:\\n ax2.set_ylabel(job.Y2headers[0],color=\\\"b\\\",fontsize=job.fontSize)\\n \\n p2=ax2.plot(X2,Y2,color=\\\"b\\\")\\n title=job.name+\\\"_\\\"\\n title+=job.Y2headers[0]\\n title = title + \\\"vs_\\\" + job.X1header\\n \\n if job.X2header != None and not job.X1header.lower() == job.X2header.lower():\\n title = title + \\\"_\\\" + job.X2header\\n # Override the constructed title if desired\\n \\n if job.titleOverride != None and not len(job.titleOverride)==0 and not job.titleOverride.lower() == \\\"None\\\".lower():\\n title = job.titleOverride\\n if job.log>=1:\\n logging.info(\\\"Creating Graph:\\\"+title)\\n \\n if job.titleOverride !=\\\"None\\\":\\n plt.title(title,fontsize=job.fontSize)\\n \\n if job.showGridLines:\\n plt.grid(b=True, which='major', color='r', linestyle='--')\\n \\n if not job.removeAllLegends:\\n p=p1+p2\\n labs=[job.Y1headers[0],job.Y2headers[0]]\\n ax.legend(p,labs)\\n \\n if \\\"(\\\" and \\\")\\\" in job.outputFilename:\\n job.outputFilename=job.outputFilename.split(\\\"(\\\")[0]+\\\".jpg\\\"\\n plt.savefig(os.path.join(job.outputDir,job.outputFilename),dpi=my_dpi)\\n plt.close(\\\"all\\\")\\n\\n elif len(job.Y2headers)==0:\\n X1=df.loc[:,job.X1header]\\n Y1=df.loc[:,job.Y1headers]\\n fig,ax = plt.subplots()\\n fig.set_size_inches(w=job.imageWidth/my_dpi+3.1,h=job.imageHeight/my_dpi+1)\\n \\n if not os.path.exists(job.outputDir):\\n os.mkdir(job.outputDir)\\n \\n if job.X1LowerBound and job.X1UpperBound:\\n ax.set_xlim(job.X1LowerBound,job.X1UpperBound)\\n elif job.X1LowerBound:\\n ax.set_xlim(left=job.X1LowerBound)\\n elif job.X1UpperBound:\\n ax.set_xlim(right=job.X1UpperBound)\\n\\n if job.Y1LowerBound and job.Y1UpperBound:\\n ax.set_ylim(job.Y1LowerBound,job.Y1UpperBound)\\n elif job.Y1LowerBound:\\n ax.set_ylim(bottom=job.Y1LowerBound)\\n elif job.Y1UpperBound:\\n ax.set_ylim(top=job.Y1UpperBound) \\n \\n ax.get_yaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=8))\\n ax.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\\n ax.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\\n ax.set_xlabel(job.X1header,fontsize=job.fontSize)\\n ax.set_ylabel(job.Y1headers[0],fontsize=job.fontSize)\\n p=ax.plot(X1,Y1)\\n title=job.name+\\\"_\\\"\\n title = title + \\\"vs_\\\" + job.X1header\\n \\n if job.X2header != None and not job.X1header.lower() == job.X2header.lower():\\n title = title + \\\"_\\\" + job.X2header\\n \\n # Override the constructed title if desired\\n if job.titleOverride != None and not len(job.titleOverride)==0 and not job.titleOverride.lower() == \\\"None\\\".lower():\\n title = job.titleOverride\\n if job.log>=1:\\n logging.info(\\\"Creating Graph:\\\"+title)\\n \\n if job.titleOverride !=\\\"None\\\":\\n plt.title(title,fontsize=job.fontSize)\\n \\n if job.showGridLines:\\n plt.grid(b=True, which='major', color='r', linestyle='--')\\n \\n if not job.removeAllLegends:\\n labs=job.Y1headers\\n plt.legend(p,labs)\\n \\n if \\\"(\\\" and \\\")\\\" in job.outputFilename:\\n job.outputFilename=job.outputFilename.split(\\\"(\\\")[0]+\\\".jpg\\\"\\n plt.savefig(os.path.join(job.outputDir,job.outputFilename),dpi=my_dpi)\\n plt.close(\\\"all\\\")\\n \\n else:\\n X1=df.loc[:,job.X1header]\\n Y1=df.loc[:,job.Y1headers]\\n fig,ax = plt.subplots()\\n fig.set_size_inches(w=job.imageWidth/my_dpi+3.1,h=job.imageHeight/my_dpi+1)\\n \\n if not os.path.exists(job.outputDir):\\n os.mkdir(job.outputDir)\\n \\n if job.X1LowerBound and job.X1UpperBound:\\n ax.set_xlim(job.X1LowerBound,job.X1UpperBound)\\n elif job.X1LowerBound:\\n ax.set_xlim(left=job.X1LowerBound)\\n elif job.X1UpperBound:\\n ax.set_xlim(right=job.X1UpperBound)\\n\\n if job.Y1LowerBound and job.Y1UpperBound:\\n ax.set_ylim(job.Y1LowerBound,job.Y1UpperBound)\\n elif job.Y1LowerBound:\\n ax.set_ylim(bottom=job.Y1LowerBound)\\n elif job.Y1UpperBound:\\n ax.set_ylim(top=job.Y1UpperBound) \\n \\n ax.get_yaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=8))\\n ax.get_xaxis().set_major_locator(MaxNLocator(nbins=10,min_n_ticks=5))\\n ax.yaxis.set_major_formatter(tick.FuncFormatter(self.y_fmt))\\n ax.set_xlabel(job.X1header,fontsize=job.fontSize)\\n ax.set_ylabel(job.Y1headers[0],fontsize=job.fontSize)\\n p1=ax.plot(X1,Y1)\\n title=job.name+\\\"_\\\"\\n title = title + \\\"vs_\\\" + job.X1header\\n \\n if job.X2header != None and not job.X1header.lower() == job.X2header.lower():\\n title = title + \\\"_\\\" + job.X2header\\n \\n # Override the constructed title if desired\\n if job.titleOverride != None and not len(job.titleOverride)==0 and not job.titleOverride.lower() == \\\"None\\\".lower():\\n title = job.titleOverride\\n if job.log>=1:\\n logging.info(\\\"Creating Graph:\\\"+title)\\n \\n if job.titleOverride !=\\\"None\\\":\\n plt.title(title,fontsize=job.fontSize)\\n \\n if job.showGridLines:\\n plt.grid(b=True, which='major', color='r', linestyle='--')\\n \\n if not job.removeAllLegends:\\n labs=job.Y1headers\\n ax.legend(p1, labs)\\n \\n if \\\"(\\\" and \\\")\\\" in job.outputFilename:\\n job.outputFilename=job.outputFilename.split(\\\"(\\\")[0]+\\\".jpg\\\"\\n plt.savefig(os.path.join(job.outputDir,job.outputFilename),dpi=my_dpi)\\n plt.close(\\\"all\\\")\",\n \"def plot_results(self):\\n\\n\\n f1, ax1 = plt.subplots()\\n h1, = ax1.plot(self.history[\\\"step\\\"], self.history[\\\"trainLoss\\\"],\\\\\\n \\\"b-\\\", label=\\\"Loss - Train\\\")\\n h2, = ax1.plot(self.history[\\\"step\\\"], self.history[\\\"validLoss\\\"],\\\\\\n \\\"b.\\\", label=\\\"Loss - Validation\\\")\\n\\n ax1.set_ylabel(\\\"Loss\\\", color = \\\"blue\\\")\\n ax1.tick_params(\\\"y\\\", color = \\\"blue\\\")\\n ax1.yaxis.label.set_color(\\\"blue\\\")\\n ax1.set_xlabel(\\\"Training Steps [{}]\\\".format(self.FLAGS.eval_every))\\n\\n ax2 = ax1.twinx()\\n h3, = ax2.plot(self.history[\\\"step\\\"], self.history[\\\"trainAccr\\\"], \\\"r-\\\",\\\\\\n label = \\\"Accuracy - Train\\\")\\n h4, = ax2.plot(self.history[\\\"step\\\"], self.history[\\\"validAccr\\\"], \\\"r.\\\",\\\\\\n label = \\\"Accuracy - Validation\\\")\\n\\n ax2.set_ylabel(\\\"Accuracy\\\", color = \\\"red\\\")\\n ax2.tick_params(\\\"y\\\", color = \\\"red\\\")\\n ax2.yaxis.label.set_color(\\\"red\\\")\\n\\n hds = [h1,h2,h3,h4]\\n lbs = [l.get_label() for l in hds]\\n ax1.legend(hds, lbs)\\n f1.tight_layout()\\n plt.savefig(\\\"trainingHistory.png\\\")\\n\\n plt.close(f1)\\n #plt.show()\",\n \"def PlotProfile():\\n (metadata, data) = Parse('/tmp/sdcard-scalability.txt')\\n gp = Gnuplot.Gnuplot(persist=1)\\n gp('set data style impulses')\\n gp('set xtics 1')\\n gp('set pointsize 2')\\n gp.clear()\\n gp.xlabel('writer process')\\n gp.ylabel('duration in second')\\n gp.title(metadata.AsTitle())\\n\\n dataset = data[0]\\n x = numpy.array(dataset.time, dtype='int_')\\n d = Gnuplot.Data(x, dataset.data,\\n title=dataset.name,\\n with_='linespoints')\\n gp.replot(d)\\n gp.hardcopy('/tmp/%s-%s-%f.png' %\\n (metadata.name, metadata.kernel, metadata.duration),\\n terminal='png')\",\n \"def plot_path_statistics( self, path_file=\\\"tse_ensemble.json\\\" ):\\n from matplotlib import pyplot as plt\\n with open(path_file,'r') as infile:\\n data = json.load(infile)\\n try:\\n paths = data[\\\"transition_paths\\\"]\\n except KeyError:\\n paths = [data]\\n total_product_indicator = np.zeros(len(paths[0][\\\"symbols\\\"]))\\n total_reactant_indicator = np.zeros(len(paths[0][\\\"symbols\\\"]))\\n self.nuc_mc.min_size_product = paths[0][\\\"min_size_product\\\"]\\n self.nuc_mc.max_size_reactant = paths[0][\\\"max_size_reactant\\\"]\\n for path in paths:\\n product_indicator = []\\n reactant_indicator = []\\n reactant_indicator, product_indicator = self.get_basin_indicators(path)\\n\\n total_product_indicator += np.cumsum(product_indicator)/float( len(product_indicator) )\\n total_reactant_indicator += np.cumsum(reactant_indicator)/float( len(reactant_indicator) )\\n\\n total_reactant_indicator /= float( len(paths) )\\n total_product_indicator /= float( len(paths) )\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(1,1,1)\\n ax.plot( total_product_indicator, label=\\\"Product\\\" )\\n ax.plot( total_reactant_indicator, label=\\\"Reactant\\\" )\\n ax.set_xlabel( \\\"MC sweeps\\\" )\\n ax.set_ylabel( \\\"Indicator\\\" )\\n ax.spines[\\\"right\\\"].set_visible(False)\\n ax.spines[\\\"top\\\"].set_visible(False)\\n ax.legend( frameon=False, loc=\\\"best\\\" )\\n return fig\",\n \"def plot_oneshot_task(pairs):\\n fig,(ax1,ax2) = plt.subplots(2)\\n ax1.matshow(pairs[0][0].reshape(300,300),cmap='gray')\\n img = concat_images(pairs[1])\\n ax1.get_yaxis().set_visible(False)\\n ax1.get_xaxis().set_visible(False)\\n ax2.matshow(img,cmap='gray')\\n plt.xticks([])\\n plt.yticks([])\\n plt.show()\",\n \"def plot_visco_profiles(pointsh5, skip=slice(None,None,1), xscale=1e3, yscale=1e-2, tscale=3.1536e7, adjustRadial=False, benchmark=[], title=None):\\n\\tplt.figure()\\n\\n\\tcoords,data,number,times = pu.load_h5_visco(pointsh5)\\n\\n\\t#x = 1e3*np.loadtxt(points,usecols=[0]) # output_points2.txt\\n\\t#y = np.zeros_like(x)\\n\\tx = coords[:,0]\\n\\ty = np.zeros_like(x)\\n\\n\\t# NOTE: plot elastic solution by passing dictionary as showelastic\\n\\t# Plot analytic elastic solution (t=0)\\n\\t#print(benchmark)\\n\\tif len(benchmark)>=1:\\n\\t\\tur = zeros_like(x)\\n\\t\\tuz = np.zeros_like(x)\\n\\t\\tfor b in benchmark:\\n\\t\\t\\turi,uzi = m.calc_mogi_dp(x,y,**params)\\n\\t\\t\\tur += uri\\n\\t\\t\\tuz += uzi\\n\\t\\tplt.plot(x*xscale,uz*yscale,'ko',label='benchmark')\\n\\n\\t# Convert units\\n\\t#ur = np.hypot(data[:,:,0], data[:,:,1]) #assume progiles are along EW profile\\n\\tur = data[:,:,0]\\n\\tuz = data[:,:,2]\\n\\tx = x / xscale\\n\\tur = ur / yscale #cm\\n\\tuz = uz / yscale #cm\\n\\ttimes = times / tscale\\n\\t#times = times / 8.64e4 #days\\n\\t#times = times / 31536000 #years\\n\\n\\t#plots = np.arange(0,times.size,skip)\\n\\t#print(plots.size)\\n\\t#way to cycle through markers if plotting many lines\\n\\t#marker = itertools.cycle(['o','^','s','D']) #plot(marker=marker.next() iterates list)\\n\\t#way to use gradually changing colors from a colormap\\n\\t#color = plt.cm.jet(1.0*i/plots.size)\\n\\tindplots = np.arange(times.size-1)\\n\\tprint(indplots)\\n\\tindplots = indplots[skip]\\n\\tprint(indplots)\\n\\tfor i in indplots:\\n\\t\\tline, = plt.plot(x, uz[i], color=plt.cm.jet(1.0*i/indplots[-1]), label='{:.1f}'.format(times[i]))\\n\\t\\tplt.plot(x, ur[i], ls='dashed', color=line.get_color())\\n\\t#print uz[i]\\n\\t#print uz[i-1]\\n\\n\\tif title:\\n\\t\\tplt.title(title)\\n\\telse:\\n\\t\\tplt.title(pointsh5)\\n\\n\\tplt.axhline(color='k',linestyle='dashed')\\n\\tplt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n\\tplt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\\n\\tplt.show()\\n\\tplt.legend(title='{}'.format(get_unit(tscale)))\\n\\tplt.grid()\",\n \"def xx_plot(epoch, model, features, filters, figname, fgal=0.5):\\n # fetch Stripe 82 data\\n X, Xcov = fetch_prepped_s82data(epoch, fgal, features, filters)\\n Xcoadd, Xcoaddcov = fetch_prepped_s82data(epoch, fgal, features,\\n filters, use_single=False)\\n N = 20000\\n X = X[:N]\\n Xcov = Xcov[:N]\\n Xcoadd = Xcoadd[:N]\\n Xcoaddcov = Xcoaddcov[:N]\\n\\n # unpickle the XD model\\n if type(model) == str: \\n f = open(model, 'rb')\\n model = cPickle.load(f)\\n f.close()\\n\\n # Calculate the posteriors, draw samples\\n a, m, v = model.posterior(X, Xcov)\\n posts = np.zeros_like(X)\\n for i in range(X.shape[0]):\\n posts[i] = model.sample(a[i], m[i], v[i], size=1)\\n\\n lo = [0.01, 0.02, 0.06]\\n hi = [0.99, 0.96, 0.98]\\n idx = [0, 1, 4]\\n bins = [100, 100, 300]\\n label = ['psfmag $r$', 'modelmag $u-g$', 'modelmag $i-z$']\\n N = len(idx)\\n fs = 5\\n lsize = 20\\n f = pl.figure(figsize=(N * fs, 2 * fs))\\n pl.subplots_adjust(wspace=0.3)\\n for i in range(N):\\n x = X[:, idx[i]]\\n y = Xcoadd[:, idx[i]]\\n p = posts[:, idx[i]]\\n ind = (y > -999) & (Xcoaddcov[:, idx[i]][:, idx[i]] < 10.)\\n x = x[ind]\\n y = y[ind]\\n p = p[ind]\\n ax = pl.subplot(2, N, i + 1)\\n v = np.sort(x)\\n mn, mx = v[np.int(lo[i] * x.shape[0])], v[np.int(hi[i] * x.shape[0])]\\n hist2d(x, y, ax=ax, bins=bins[i], plot_contours=True,\\n plot_datapoints=True)\\n pl.plot([mn, mx], [mn, mx], 'r', lw=2)\\n pl.ylabel('Coadd ' + label[i], fontsize=lsize)\\n pl.xlabel('Single Epoch ' + label[i], fontsize=lsize)\\n pl.xlim(mn, mx)\\n pl.ylim(mn, mx)\\n ax = pl.subplot(2, N, i + 4)\\n hist2d(p, y, ax=ax, bins=bins[i], plot_contours=True,\\n plot_datapoints=True)\\n pl.plot([mn, mx], [mn, mx], 'r', lw=2)\\n pl.xlim(mn, mx)\\n pl.ylim(mn, mx)\\n pl.ylabel('Coadd ' + label[i], fontsize=lsize)\\n pl.xlabel('XD Posterior ' + label[i], fontsize=lsize)\\n f.savefig(figname, bbox_inches='tight')\",\n \"def display_dataset(path, save, dset='sum'):\\n # List datasets\\n files_surf = os.listdir(path[0])\\n files_surf.sort()\\n files_deep = os.listdir(path[1])\\n files_deep.sort()\\n files_calc = os.listdir(path[2])\\n files_calc.sort()\\n\\n # Corrected names\\n files = os.listdir(r'Y:\\\\3DHistoData\\\\Subvolumes_2mm')\\n files.sort()\\n\\n k = 0\\n # Loop for displaying images\\n for fsurf, fdeep, fcalc in zip(files_surf, files_deep, files_calc):\\n # Load images\\n im_surf = loadh5(path[0], fsurf, dset)\\n im_deep = loadh5(path[1], fdeep, dset)\\n im_calc = loadh5(path[2], fcalc, dset)\\n # Create figure\\n fig = plt.figure(dpi=300)\\n ax1 = fig.add_subplot(131)\\n ax1.imshow(im_surf, cmap='gray')\\n plt.title(fsurf + ', Surface')\\n ax2 = fig.add_subplot(132)\\n ax2.imshow(im_deep, cmap='gray')\\n plt.title('Deep')\\n ax3 = fig.add_subplot(133)\\n ax3.imshow(im_calc, cmap='gray')\\n plt.title('Calcified')\\n if save is not None:\\n while files[k] == 'Images' or files[k] == 'MeanStd':\\n k += 1\\n\\n # Save figure\\n if not os.path.exists(save):\\n os.makedirs(save, exist_ok=True)\\n plt.tight_layout()\\n fig.savefig(os.path.join(save, files[k]), bbox_inches=\\\"tight\\\", transparent=True)\\n plt.close()\\n\\n # Save h5\\n if not os.path.exists(save + '\\\\\\\\MeanStd\\\\\\\\'):\\n os.makedirs(save + '\\\\\\\\MeanStd\\\\\\\\', exist_ok=True)\\n\\n h5 = h5py.File(save + \\\"\\\\\\\\MeanStd\\\\\\\\\\\" + files[k] + '.h5', 'w')\\n h5.create_dataset('surf', data=im_surf)\\n h5.create_dataset('deep', data=im_deep)\\n h5.create_dataset('calc', data=im_calc)\\n h5.close()\\n else:\\n plt.show()\\n k += 1\",\n \"def plot_profiles(self, parameters, fig=1):\\n # Make sure the parameters are a list\\n if isinstance(parameters, str) or isinstance(parameters, unicode):\\n parameters = [parameters]\\n \\n # Decide how many subplots to create\\n nrows = int(len(parameters) / 3)\\n if len(parameters) % 3 > 0:\\n nrows += 1\\n \\n # Initialize a figure for plotting\\n width = 8\\n height = 4 * nrows\\n plt.figure(fig, figsize=(width, height))\\n plt.clf()\\n \\n # Plot each parameter\\n for parm in parameters:\\n ax = plt.subplot(nrows, 3, parameters.index(parm)+1)\\n self.plot_parameter(parm)\\n \\n plt.tight_layout()\\n \\n plt.show()\",\n \"def problemFour(self):\\n # Initialize plot figures\\n\\n plot_41 = plt.figure(figsize=(12, 15))\\n plot_41.subplots_adjust(left=.1, right=.98, top=.98, bottom=.08)\\n pitot = plot_41.add_subplot(1, 1, 1)\\n plt.tick_params(labelsize=16)\\n pitot.set_xlabel('$\\\\\\\\frac{(y-y_o)}{D}$', fontsize=24)\\n pitot.set_ylabel('Turbulence Intensity', fontsize=24)\\n pitot.grid(linewidth=1, color='gray', linestyle='--')\\n plot_42 = plt.figure(figsize=(12, 15))\\n plot_42.subplots_adjust(left=.09, right=.98, top=.98, bottom=.08)\\n hot = plot_42.add_subplot(1, 1, 1)\\n plt.tick_params(labelsize=16)\\n hot.set_xlabel('$\\\\\\\\frac{(y-y_o)}{D}$', fontsize=24)\\n hot.set_ylabel('Turbulence Intensity', fontsize=24)\\n hot.grid(linewidth=1, color='gray', linestyle='--')\\n # Get plot data from each file\\n for file_loc in self.filenames:\\n file = os.path.basename(file_loc).replace('.csv', '')\\n index = self.filenames.index(file_loc)\\n if 'calibration' not in file:\\n self.hot_vel = self.data[file]['hot vel'].tolist()\\n self.pitot_vel = self.data[file]['pitot vel'].tolist()\\n hot_std = self.data[file]['hot std'].tolist()\\n pitot_std = self.data[file]['pitot std'].tolist()\\n self.y_pos = self.data[file]['y pos'].tolist()\\n # Calc v_inf for hotwire and pitot velocity profiles\\n v_inf_hot = statistics.mean([sum(self.hot_vel[:6])/len(self.hot_vel[:6]), sum(self.hot_vel[-6:])/len(self.hot_vel[-6:])])\\n v_inf_pitot = statistics.mean([sum(self.pitot_vel[:6])/len(self.pitot_vel[:6]), sum(self.pitot_vel[-6:])/len(self.pitot_vel[-6:])])\\n # Normalize velocity to the freestream velocity\\n hot_nondim = [i / v_inf_hot for i in self.hot_vel]\\n pitot_nondim = [i / v_inf_pitot for i in self.pitot_vel]\\n # Normalize the y position with cylinder diameter\\n y0_hot = self.y_pos[hot_nondim.index(min(hot_nondim))]\\n y0_pitot = self.y_pos[pitot_nondim.index(min(pitot_nondim))]\\n y_pos_nondim_hot = [(i - y0_hot) / self.cylinder_diam for i in self.y_pos]\\n y_pos_nondim_pitot = [(i - y0_pitot) / self.cylinder_diam for i in self.y_pos]\\n # Get turbulence intensity\\n hot_turb = [i / v_inf_hot for i in hot_std]\\n pitot_turb = [i / v_inf_pitot for i in pitot_std]\\n # Find peaks\\n peak1_h = y_pos_nondim_hot[hot_turb.index(max(hot_turb[:30]))]\\n peak2_h = y_pos_nondim_hot[hot_turb.index(max(hot_turb[-30:]))]\\n peak1_p = y_pos_nondim_pitot[pitot_turb.index(max(pitot_turb[:30]))]\\n peak2_p = y_pos_nondim_pitot[pitot_turb.index(max(pitot_turb[-30:]))]\\n print(file)\\n print(peak1_h, peak2_h)\\n print(peak1_p, peak2_p)\\n # Plot the turbulence intensity\\n pitot.plot(y_pos_nondim_pitot, pitot_turb, color=self.plot_color[index], label=f'{file}mm', linewidth=2)\\n hot.plot(y_pos_nondim_hot, hot_turb, color=self.plot_color[index], label=f'{file}mm', linewidth=2)\\n pitot.legend(loc='upper right', fontsize=18)\\n hot.legend(loc='upper right', fontsize=18)\\n plot_41.savefig(os.path.join(os.getcwd(), r'plots\\\\prob4_pitot'))\\n plot_42.savefig(os.path.join(os.getcwd(), r'plots\\\\prob4_hot'))\\n plt.draw()\",\n \"def matplotlib_plot(self, output_dir: Union[str, Path]):\\n keys2 = set.union(*[set(self.get_keys2(k)) for k in self.get_keys()])\\n for key2 in keys2:\\n keys = [k for k in self.get_keys() if key2 in self.get_keys2(k)]\\n plt = self._plot_stats(keys, key2)\\n p = Path(output_dir) / f\\\"{key2}.png\\\"\\n p.parent.mkdir(parents=True, exist_ok=True)\\n plt.savefig(p)\",\n \"def plot_it(self, ui=None, res_dir=None):\\r\\n print_it(\\\"plotting results\\\")\\r\\n plt_profile(self.sun, PltOpts.DD.value, res_dir, SubDir.profiles.value)\\r\\n plt_profile(self.sun, PltOpts.DDD.value, res_dir, SubDir.profiles.value)\\r\\n plt_profile(self.planet, PltOpts.DD.value, res_dir,\\r\\n SubDir.profiles.value)\\r\\n plt_profile(self.planet, PltOpts.DDD.value, res_dir,\\r\\n SubDir.profiles.value)\\r\\n plt_profile_approx(res_dir, SubDir.profiles.value)\\r\\n plt_contact(self.sun, self.planet, PltOpts.DD.value, res_dir,\\r\\n SubDir.contacts.value)\\r\\n plt_contact(self.sun, self.planet, PltOpts.DDD.value, res_dir,\\r\\n SubDir.contacts.value)\\r\\n\\r\\n plt_3d(self.sun.x_axis, self.sun.y_axis, self.sun.press,\\r\\n self.sun.x_label, self.sun.y_label, 'pressure in MPa',\\r\\n 'contact_pressure_sun', res_dir, SubDir.pressures.value,\\r\\n 'contact_pressure_sun')\\r\\n plt_2d_scatt_line(self.sun.x_axis, self.pv, self.sun.x_axis, self.pv,\\r\\n self.sun.x_label,\\r\\n 'pv_rel in {}'.format(Unit.pvrel.value), 'pv_rel',\\r\\n res_dir, SubDir.energy.value, 'pv_rel')\\r\\n plt_2d_scatt_line(self.sun.x_axis, self.sun.e_akin, self.sun.x_axis,\\r\\n self.sun.e_akin, self.sun.x_label,\\r\\n 'e_akin in {}'.format(Unit.eakin.value), 'e_akin',\\r\\n res_dir, SubDir.energy.value, 'sun.e_akin')\\r\\n plt_2d_scatt_line(self.planet.x_axis, self.planet.e_akin,\\r\\n self.planet.x_axis, self.planet.e_akin,\\r\\n self.planet.x_label,\\r\\n 'e_akin in {}'.format(Unit.eakin.value), 'e_akin',\\r\\n res_dir,\\r\\n SubDir.energy.value, 'planet.e_akin')\\r\\n plt_energy_ring_on_ring(self, res_dir, SubDir.energy.value,\\r\\n 'e-akin-vs-pv-rel')\",\n \"def compare_hist_2(results_dir_root):\\n plot_style = [\\n {'color': 'k', 'marker': 'none', 'lw': 1.5},\\n {'color': 'r', 'marker': 'none', 'lw': 1.5}\\n ]\\n unwrap_levels = ['r08']\\n\\n fig, axes = plt.subplots(figsize=(8, 10), nrows=5, ncols=2, sharex=True,\\n sharey=False)\\n fig.subplots_adjust(left=0.1, bottom=0.08, right=0.98, top=0.98,\\n hspace=0.05, wspace=0.15)\\n\\n print(axes.shape)\\n\\n results_dirs = [results_dir_root + '_0h', results_dir_root + '_4h']\\n\\n fig.text(0.5, 0.02, r'Baseline length (m)', ha='center')\\n fig.text(0.01, 0.5, r'Baseline count per bin', va='center',\\n rotation='vertical')\\n\\n # Loop over models\\n for i in range(7, 8):\\n models = ['ska1_v5', 'model%02i' % (i + 1)]\\n # Loop over 0h or 4h\\n for j in range(1):\\n idx = 0\\n ax = axes[i, j]\\n for model in models:\\n # Load saved psf results.\\n filename = join(results_dirs[j], '%s_uv_hist.p' % model)\\n print('-- Loading: %s' % filename)\\n hist = pickle.load(open(filename, 'rb'))\\n # Plot comparison of PSF profiles.\\n for tel in hist:\\n if tel == 'ska1_v5' or any(s in tel for s in unwrap_levels):\\n style = plot_style[idx % len(plot_style)]\\n x = hist[tel]['log']['hist_x']\\n y = hist[tel]['log']['hist_n']\\n cut_idx = np.argmax(x > 5e3)\\n x = x[:cut_idx]\\n y = y[:cut_idx]\\n ax.plot(x, y, color=style['color'],\\n linestyle='-',\\n label=tel + ' max')\\n idx += 1\\n length_str = 'snapshot' if j == 0 else '4 hours'\\n ax.text(0.02, 0.95, ('SKA1 v5 vs. Model %i\\\\n' % (i + 1)) + length_str,\\n weight='bold',\\n ha='left', va='top', transform=ax.transAxes,\\n fontsize='small')\\n # ax.legend(loc='best', fontsize='small', ncol=1)\\n # ax.set_xlabel('Baseline length (m)')\\n # ax.set_ylabel('Number of baselines per bin')\\n ax.set_xlim(10, 1e4)\\n if j == 1:\\n ax.set_ylim(1.5e3)\\n if j == 0:\\n ax.set_ylim(5)\\n ax.set_yscale('log')\\n ax.set_xscale('log')\\n # if i == 4:\\n # ax.set_xlabel('Baseline length (m)')\\n # ax.set_ylabel('Baseline count per bin')\\n ax.grid()\\n plt.show(True)\\n fig.savefig(join('compare_hist_%s.png' %\\n ('_'.join(unwrap_levels))))\\n plt.close(fig)\",\n \"def figure_1():\\n exp_list = os.listdir(BASE_DATA_DIR)\\n exp_list.remove(\\\"tmp\\\")\\n\\n # Draw common plots\\n print(exp_list)\\n data = get_data(exp_list[0])\\n plt.figure(num=\\\"state 1\\\", figsize=[6.4, 4.8])\\n plt.plot(\\n data[\\\"time\\\"], data[\\\"cmd\\\"],\\n **FORMATTING[\\\"command\\\"]\\n )\\n plt.plot(\\n data[\\\"time\\\"], data[\\\"state\\\"][\\\"reference_system\\\"][:, 0],\\n **FORMATTING[\\\"reference\\\"]\\n )\\n plt.ylabel(r\\\"$x_1$\\\")\\n plt.xlabel(\\\"Time, sec\\\")\\n\\n plt.figure(num=\\\"state 2\\\", figsize=[6.4, 4.8])\\n plt.plot(\\n data[\\\"time\\\"], data[\\\"state\\\"][\\\"reference_system\\\"][:, 1],\\n **FORMATTING[\\\"reference\\\"]\\n )\\n plt.ylabel(r\\\"$x_2$\\\")\\n plt.xlabel(\\\"Time, sec\\\")\\n\\n plt.figure(num=\\\"control\\\")\\n plt.ylabel(r\\\"$u$\\\")\\n plt.xlabel(\\\"Time, sec\\\")\\n\\n def general_figures(exp):\\n data = get_data(exp)\\n plt.figure(num=\\\"state 1\\\")\\n ax = plt.gca()\\n ax.plot(\\n data[\\\"time\\\"], data[\\\"state\\\"][\\\"main_system\\\"][:, 0],\\n **FORMATTING[exp],\\n )\\n\\n plt.figure(num=\\\"state 2\\\")\\n plt.plot(\\n data[\\\"time\\\"], data[\\\"state\\\"][\\\"main_system\\\"][:, 1],\\n **FORMATTING[exp],\\n )\\n\\n plt.figure(num=\\\"control\\\")\\n plt.plot(\\n data[\\\"time\\\"], data[\\\"control\\\"],\\n **FORMATTING[exp],\\n )\\n\\n for exp in exp_list:\\n general_figures(exp)\\n\\n # Estimation error\\n for exp in exp_list:\\n data = get_data(exp)\\n error = nla.norm(\\n data[\\\"state\\\"][\\\"adaptive_system\\\"] - data[\\\"real_param\\\"],\\n axis=1\\n )\\n plt.figure(num=\\\"Estimation error\\\")\\n plt.plot(data[\\\"time\\\"], error, **FORMATTING[exp])\\n plt.xlabel(\\\"Time, sec\\\")\\n plt.ylabel(\\\"Error norm\\\")\\n\\n # Real parameter\\n data = get_data(exp_list[0])\\n plt.plot(data[\\\"time\\\"], data[\\\"real_param\\\"].squeeze())\\n\\n\\n exp_list.remove(\\\"mrac-nullagent\\\")\\n\\n def eig_figures(exp, minmax):\\n data = get_data(exp)\\n if minmax == \\\"min\\\":\\n eig = np.min(data[\\\"eigs\\\"], axis=1)\\n elif minmax == \\\"max\\\":\\n eig = np.max(data[\\\"eigs\\\"], axis=1)\\n plt.plot(data[\\\"time\\\"], eig, **FORMATTING[exp])\\n\\n fig, (ax_min, ax_max) = plt.subplots(2, 1, num=\\\"Eigenvalues\\\", sharex=True)\\n\\n plt.subplot(211)\\n plt.ticklabel_format(style=\\\"sci\\\", scilimits=(0, 0), useOffset=True)\\n for exp in exp_list:\\n eig_figures(exp, \\\"min\\\")\\n plt.ylabel(r\\\"Minimum $\\\\lambda$\\\")\\n plt.legend()\\n\\n plt.subplot(212)\\n for exp in exp_list:\\n eig_figures(exp, \\\"max\\\")\\n plt.ylabel(r\\\"Maximum $\\\\lambda$\\\")\\n plt.xlabel(\\\"Time, sec\\\")\\n\\n # Saving\\n def savefig(name):\\n path = os.path.join(args.save_dir, name + \\\".\\\" + args.save_ext)\\n plt.savefig(path, bbox_inches=\\\"tight\\\")\\n\\n plt.figure(num=\\\"state 1\\\")\\n plt.legend()\\n savefig(\\\"state-1\\\")\\n\\n plt.figure(num=\\\"state 2\\\")\\n plt.legend()\\n savefig(\\\"state-2\\\")\\n\\n plt.figure(num=\\\"control\\\")\\n plt.legend()\\n savefig(\\\"control\\\")\\n\\n plt.figure(num=\\\"Eigenvalues\\\")\\n savefig(\\\"eigs\\\")\\n\\n plt.figure(num=\\\"Estimation error\\\")\\n plt.legend()\\n savefig(\\\"estim-error\\\")\\n\\n plt.show()\",\n \"def show_data(self, samples=5):\\n self._samples = samples\\n \\n idx = 0\\n batch = next(iter(self._loader))\\n while idx <= self._samples:\\n\\n (img_batch, label_batch) = batch\\n\\n fig = plt.figure()\\n ax1 = fig.add_subplot(121)\\n ax2 = fig.add_subplot(122)\\n \\n ax1.imshow(np.transpose(img_batch[idx], (1, 2, 0)))\\n ax2.imshow(np.transpose(label_batch[idx], (1, 2, 0)).squeeze(dim=2))\\n\\n plt.show()\\n idx += 1\",\n \"def plot_data(data, par, par_names, par_fixed, output_dir='./'):\\n\\n datasets = dict()\\n\\n for data_point in data:\\n experiment_name = data_point.par['experiment_name']\\n datasets.setdefault(experiment_name, list()).append(data_point)\\n\\n for experiment_name, dataset in datasets.items():\\n\\n # ##### Matplotlib ######\\n\\n name_pdf = ''.join([experiment_name, '.pdf'])\\n name_pdf = os.path.join(output_dir, name_pdf)\\n\\n name_txt = ''.join([experiment_name, '.fit'])\\n name_txt = os.path.join(output_dir, name_txt)\\n\\n print(\\\" * {} [.fit]\\\".format(name_pdf))\\n\\n # #######################\\n\\n data_grouped = group_data(dataset)\\n profiles, r2_min, r2_max = compute_profiles(data_grouped)\\n ymin, ymax = set_lim([r2_min, r2_max], 0.10)\\n\\n with PdfPages(name_pdf) as file_pdf, open(name_txt, 'w') as file_txt:\\n\\n for (_index, id_), profile in sorted(profiles.items()):\\n write_profile(id_, profile, file_txt)\\n\\n ###### Matplotlib ######\\n\\n fig = plt.figure(1, frameon=True)\\n ax = fig.add_subplot(111)\\n\\n ax.axhline(0, color='black', alpha=0.87)\\n\\n ########################\\n\\n frq, r2_cal, r2_exp, r2_erd, r2_eru = profile[0]\\n\\n ax.plot(\\n frq,\\n r2_cal,\\n linestyle='-',\\n color=red200,\\n zorder=2,\\n )\\n\\n ax.errorbar(\\n frq,\\n r2_exp,\\n yerr=[r2_erd, r2_eru],\\n fmt='o',\\n color=red500,\\n zorder=3,\\n )\\n\\n xmin, xmax = set_lim(frq, 0.10)\\n\\n ax.set_xlim(xmin, xmax)\\n ax.set_ylim(ymin, ymax)\\n\\n ax.xaxis.set_major_locator(MaxNLocator(6))\\n ax.yaxis.set_major_locator(MaxNLocator(6))\\n\\n ax.set_xlabel(r'$\\\\mathregular{\\\\nu_{CPMG} \\\\ (Hz)}$')\\n ax.set_ylabel(\\n r'$\\\\mathregular{R_{2,eff} \\\\ (s^{-1})}$')\\n\\n ax.set_title('{:s}'.format(id_.upper()))\\n\\n fig.tight_layout()\\n\\n ########################\\n\\n file_pdf.savefig()\\n plt.close()\\n\\n ########################\\n\\n return\",\n \"def fig_6():\\n epoch = 3\\n N = 60000\\n Nr = N\\n K = 32\\n n_iter = 256\\n Nstar = 16\\n data = 'dr10'\\n factor = 100.\\n features = ['psf_mag', 'model_colors', 'psf_minus_model']\\n filters = ['r', 'ug gr ri iz', 'ugriz']\\n message = 'pm_mc_pmm_r_all_all'\\n model = 'xdmodel_%s_%d_%d_%d_%d_%s.pkl' % (data, Nr, K, n_iter, Nstar,\\n message)\\n model = os.environ['xddata'] + model\\n figname = os.environ['xdplots'] + 'fig6.png'\\n psfminusmodel_plot(epoch, model, features, filters, figname, idx=-3)\",\n \"def plotBatch(inp,output='spectra_plot.pdf',comparisons=None,classify=False,normalize=False,normrange=[0.9,1.4],layout=[2,2],basecolors=['k','m'],legend=[],fontscale=0.7,classify_kwargs={},plot_kwargs={},**kwargs):\\n\\n# alt keyword check\\n for k in ['file','filename']: \\n if kwargs.get(k,'') != '': output = kwargs[k]\\n for k in ['legends','labels']: \\n if kwargs.get(k,'') != '': legend = kwargs[k]\\n\\n# force input into a list\\n if isinstance(inp,list): inputlist = copy.deepcopy(inp)\\n else: inputlist = [inp]\\n\\n# if input is a string of filenames, read in each file to a spectrum object\\n if isinstance(inputlist[0],str):\\n# try a glob search string \\n files = glob.glob(os.path.normpath(inputlist[0]))\\n if len(files) > 1 or (len(files) == 1 and inputlist[0].find('*') != -1):\\n inputlist = files\\n# try reading in files into Spectrum object\\n try:\\n splist = [splat.Spectrum(file = f) for f in inputlist]\\n except:\\n raise ValueError('\\\\nCould not read in list of files {} - make sure the full path is specified and the files are correctly formatted'.format(inputlist))\\n\\n# if filenames, read in each file to a spectrum object\\n elif isinstance(inputlist[0],splat.Spectrum):\\n splist = copy.deepcopy(inputlist)\\n else:\\n raise ValueError('\\\\nInput should be list of splat.Spectrum objects or filenames')\\n\\n# normalize if desired\\n if normalize==True:\\n tmp = [sp.normalize(normrange) for sp in splist]\\n\\n# comparison files are present\\n complist = []\\n if comparisons != None:\\n comp = copy.deepcopy(comparisons)\\n if not isinstance(comp,list): comp = [comp]\\n if isinstance(comp[0],str):\\n try:\\n complist = [splat.Spectrum(file = f) for f in comp]\\n except:\\n print('\\\\nCould not read in comparison files: ignoring comparisons')\\n if isinstance(comp[0],splat.Spectrum):\\n complist = comp\\n if len(complist) < len(splist):\\n while len(complist) < len(splist):\\n complist.append(complist[-1])\\n# normalize\\n if normalize==True:\\n tmp = [sp.normalize(normrange) for sp in complist]\\n\\n# set comparison files to be standards for spectral classification\\n# overrules input comparison sample\\n if classify == True:\\n complist = []\\n base_kwargs={\\n 'return_standard': True,\\n 'method': 'kirkpatrick',\\n }\\n base_kwargs.update(classify_kwargs)\\n for sp in splist:\\n complist.append(splat.classifyByStandard(sp,**base_kwargs))\\n\\n# prep for plotting\\n plotlist = []\\n clist = []\\n for i,sp in enumerate(splist):\\n if len(complist) == len(splist):\\n plotlist.append([sp,complist[i]])\\n clist.extend(basecolors)\\n else:\\n plotlist.append([sp])\\n clist.extend(basecolors[0])\\n\\n# manage legends\\n if len(legend) != 0:\\n if not isinstance(legend,list): legend = [legend]\\n if len(legend) < (len(splist)+len(complist)):\\n# guess: just left out the comparison legends \\n if len(complist) > 0 and len(legend) == len(splist):\\n legtmp = []\\n for i,l in enumerate(legend):\\n legtmp.extend([l,'{}'.format(complist[i].name)])\\n legend = legtmp\\n else:\\n# otherwise: pad the remaining legends with the last legend (pairs) \\n while len(legend) < (len(splist)+len(complist)):\\n if len(complist)>0:\\n legend.extend([legend[-2],legend[-1]])\\n else:\\n legend.extend([legend[-1]])\\n if len(legend) > (len(splist)+len(complist)):\\n legend = legend[0:(len(splist)+len(complist))]\\n else:\\n legend = []\\n for i,sp in enumerate(splist):\\n l = []\\n if 'name' in list(sp.__dict__.keys()): l.append(sp.name)\\n else: l.append(os.path.basename(sp.filename))\\n if len(complist)>0:\\n if 'name' in list(complist[i].__dict__.keys()): l.append(complist[i].name)\\n else: l.append(os.path.basename(complist[i].filename))\\n legend.extend(l)\\n\\n# generate plot\\n base_kwargs={\\n 'multiplot': True,\\n 'multipage': True,\\n 'legends': legend,\\n 'colors': clist,\\n 'layout': layout,\\n 'fontscale': fontscale,\\n 'output': output,\\n }\\n base_kwargs.update(plot_kwargs)\\n fig = plotSpectrum(plotlist,**base_kwargs)\\n\\n return fig\",\n \"def generate_figures():\\r\\n # create results directory if necessary\\r\\n try:\\r\\n makedirs(\\\"results\\\")\\r\\n except OSError as e:\\r\\n if e.errno != errno.EEXIST:\\r\\n raise\\r\\n \\r\\n for b in benchmarks:\\r\\n generate_figure(model[b], b)\",\n \"def plotPerBxStep(options):\\n name = options['scan'] + '_' + options['name'] + options['extra']\\n if 'method' in options:\\n name += '_' + options['method']\\n f = openRootFileR(name)\\n for bx in options['crossings']:\\n for step in range(len(O['nominalPos'][options['scan']])):\\n histname = plotName(name+'_bx'+str(bx)+'_step'+str(step), \\\\\\n timestamp=False)\\n filename = plotName(name+'_bx'+str(bx)+'_step'+str(step), \\\\\\n timestamp=True)\\n filepath = plotPath(name+'_bx'+str(bx)+'_step'+str(step), \\\\\\n timestamp=True)\\n print '<<< Save plot:', filepath\\n hist = f.Get(histname)\\n canvas = TCanvas()\\n canvas.SetLogx(options['logx'])\\n canvas.SetLogy(options['logy'])\\n gStyle.SetOptStat(options['optstat'])\\n gStyle.SetOptFit(options['optfit'])\\n hist.Draw()\\n gPad.Update()\\n hist.GetXaxis().SetTitle(options['xtitle'])\\n hist.GetXaxis().SetRangeUser(options['xmin'], options['xmax'])\\n hist.GetYaxis().SetTitle(options['ytitle'])\\n hist.GetYaxis().SetTitleOffset(1.2)\\n for axis in [hist.GetXaxis(), hist.GetYaxis()]:\\n axis.SetTitleFont(133)\\n axis.SetTitleSize(16)\\n axis.SetLabelFont(133)\\n axis.SetLabelSize(12)\\n axis.CenterTitle()\\n stats = hist.FindObject('stats')\\n stats.SetTextFont(133)\\n stats.SetTextSize(16)\\n drawSignature(filename)\\n gPad.Modified()\\n gPad.Update()\\n if 'custom' in options:\\n extragraphs = options['custom'](hist)\\n canvas.Print(filepath)\\n canvas.Close()\\n closeRootFile(f, name)\",\n \"def plot_results(param_names, param_options, results, params):\\n\\n\\t# circuit/run_num where run_num is one before the existing one\\n\\tdirectory = params.circuit\\n\\tif not os.path.isdir(directory):\\n\\t\\tos.mkdir(directory)\\n\\truns = immediate_subdir(directory)\\n\\tlatest_run = 0\\n\\tif runs:\\n\\t\\tnatural_sort(runs)\\n\\t\\tlatest_run = get_trailing_num(runs[-1])\\n\\tdirectory = os.path.join(directory, \\\"run\\\" + str(latest_run+1))\\n\\n\\tprint(directory)\\n\\tif not os.path.isdir(directory):\\n\\t\\tos.mkdir(directory)\\n\\n\\twith Chdir(directory):\\n\\n\\t\\texport_results_to_csv(param_names, results, params)\\n\\n\\t\\tx = results.keys()\\n\\t\\ty = []\\n\\t\\tnext_figure = True\\n\\n\\t\\tp = 0\\n\\t\\tplt.figure()\\n\\t\\twhile p < len(param_names):\\n\\t\\t\\tprint(param_names[p])\\n\\n\\t\\t\\tif param_options[p]:\\n\\t\\t\\t\\tnf = True\\n\\t\\t\\t\\tfor option in param_options[p].split():\\n\\t\\t\\t\\t\\t# stopping has veto power (must all be True to pass)\\n\\t\\t\\t\\t\\tnf = nf and plot_options(option)\\n\\t\\t\\t\\tnext_figure = nf\\n\\n\\t\\t\\tif not next_figure:\\n\\t\\t\\t\\t# y becomes list of lists (for use with stackable plots)\\n\\t\\t\\t\\ty.append([result[p] for result in results.values()])\\n\\t\\t\\t\\tp += 1\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\telif not y:\\n\\t\\t\\t\\ty = [result[p] for result in results.values()]\\n\\n\\t\\t\\tlx = x[-1]\\n\\t\\t\\tly = y[-1]\\n\\t\\t\\tplot_method(x,y)\\n\\t\\t\\tplt.xlabel('iteration')\\n\\t\\t\\tplt.xlim(xmin=0)\\n\\t\\t\\t\\n\\t\\t\\tplt.ylabel(param_names[p])\\n\\n\\t\\t\\t# annotate the last value\\n\\t\\t\\tannotate_last(lx,ly)\\n\\n\\t\\t\\tif next_figure:\\n\\t\\t\\t\\tplt.savefig(param_names[p])\\n\\t\\t\\t\\tplt.figure()\\n\\n\\t\\t\\tp += 1\\n\\t\\t# in case the last figure hasn't been shuffled onto file yet\\n\\t\\tif not next_figure:\\n\\t\\t\\tplot_method(x,y)\\n\\t\\t\\tplt.savefig(param_names[-1])\",\n \"def save_images(self):\\n for q in range(self.N_itr):\\n plt.clf()\\n self.plot_EM_estimate(q)\\n plt.savefig('img%d.png' % (100 + q))\",\n \"def display_some_traffic_sign_examples(path):\\n\\n images_paths = glob.glob(path + \\\"\\\\\\\\*.png\\\") # image paths\\n plt.figure(figsize = (10, 10))\\n\\n for i in range(25):\\n # select a random index in the dataset\\n idx = np.random.randint(0, len(images_paths) - 1)\\n img = imread(images_paths[idx])\\n\\n # subplot the dataset examples\\n plt.subplot(5, 5, i + 1)\\n plt.tight_layout(rect = [0, 0, 1, 0.95])\\n plt.imshow(img)\\n\\n plt.suptitle(\\\"Dataset Examples\\\")\\n plt.show()\",\n \"def plot_PDs(output_path,M_max,max_dim,normalized=False,output_name=None):\\n plots_folder = os.path.join(output_path,'plots')\\n if output_name is None: \\n aux = ['PDs']\\n input_file = os.path.join(output_path,'outputs_PDS.csv')\\n else:\\n aux = [output_name,'PDs']\\n input_file = os.path.join(output_path,'%s_PDS.csv' % output_name)\\n if normalized is True:\\n aux.append('normalized')\\n plot_file_name = '-'.join(aux)+'.png'\\n plot_file_name = os.path.join(plots_folder,plot_file_name)\\n\\n \\n data = pd.read_csv(input_file,index_col = 0)\\n \\n\\n fig_size_aux = 15/(3-max_dim)\\n plt.figure(figsize=(fig_size_aux,5))\\n if(normalized):\\n for i in range(1,max_dim+2):\\n plt.subplot(1,max_dim+1,i, aspect='equal')\\n plt.plot(data[data.dimH==i-1].birth.values/np.float(M_max),data[data.dimH==i-1].death.values/np.float(M_max),'bo',alpha=.3,label='dim %i'%(i-1))\\n plt.xlim((0,1)); plt.ylim((0,1))\\n frame = plt.legend(loc=4,frameon=True,title='normalized')\\n frame = frame.get_frame()\\n frame.set_edgecolor('black')\\n plt.xlabel('birth'); plt.ylabel('death')\\n plt.plot([0, 1], [0, 1], ls=\\\"--\\\", c=\\\".3\\\")\\n plt.suptitle('Persistence Diagrams')\\n plt.savefig(plot_file_name)\\n print 'Saved PDs plots in %s'%plot_file_name\\n else:\\n for i in range(1,max_dim+2):\\n plt.subplot(1,max_dim+1,i, aspect='equal')\\n plt.plot(data[data.dimH==i-1].birth.values,data[data.dimH==i-1].death.values,'bo',alpha=.3,label='dim %i'%(i-1))\\n plt.xlim((0,M_max)); plt.ylim((0,M_max))\\n frame = plt.legend(loc=4,frameon=True)\\n frame = frame.get_frame()\\n frame.set_edgecolor('black')\\n plt.xlabel('birth'); plt.ylabel('death')\\n plt.plot([0, M_max], [0, M_max], ls=\\\"--\\\", c=\\\".3\\\")\\n plt.suptitle('Persistence Diagrams')\\n plt.savefig(plot_file_name)\\n print 'Saved PDs plots in %s'%plot_file_name\\n return()\",\n \"def main():\\n Nrep = 8 # number of repetition of EM steps\\n nm = 3 # number of mixed gaussians.\\n ns = 300 # number of samples.\\n \\n mu, sg, lm, lm_ind, smp, L_true = generate_synthetic_data(nm, ns)\\n plt.figure(1, figsize=(5,4))\\n plt.clf()\\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\\n \\n mue, sge, lme = generate_initial_state(nm, ns)\\n axi = 0 # subplot number\\n plt.figure(2, figsize=(12,9))\\n plt.clf()\\n for rep in range(Nrep):\\n # E-step\\n r, L_infer = e_step(smp, mue, sge, lme, nm, ns)\\n axi += 1 \\n ax = plt.subplot(Nrep/2, 6, axi)\\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\\n ax.set_title('E-step : %d' % (rep + 1))\\n ax.set_yticklabels([])\\n ax.set_xticklabels([])\\n ax.set_ylim((-0.1, 0.3))\\n\\n # M-step\\n mue, sge, lme = m_step(smp, r, nm, ns)\\n axi += 1 \\n ax = plt.subplot(Nrep/2, 6, axi)\\n plot_em_steps(smp, r, mue, sge, lme, nm, ns)\\n ax.set_title('M-step : %d' % (rep + 1))\\n ax.set_yticklabels([])\\n ax.set_xticklabels([])\\n ax.set_ylim((-0.1, 0.3))\\n\\n # plot the ground truth for comparison\\n axi += 1 \\n ax = plt.subplot(Nrep/2, 6, axi)\\n plot_synthetic_data(smp, mu, sg, lm, lm_ind, nm, ns)\\n ax.set_title('grn_truth')\\n ax.set_yticklabels([])\\n ax.set_xticklabels([])\\n ax.set_ylim((-0.1, 0.3))\\n\\n print('L_infer = %2.6f , L_true = %2.6f' % (L_infer, L_true))\",\n \"def plot_results(epochs: int = 20, segments: int = 5, plot: bool = True):\\n \\\"\\\"\\\"\\n plt.figure(0)\\n plot_approximation(\\\"product\\\", modelSetProd, 1, epochs, gpus=0)\\n \\\"\\\"\\\"\\n\\n data = [\\n {\\n \\\"title\\\": \\\"Piecewise Discontinuous Function Approximation\\\",\\n \\\"layer\\\": \\\"discontinuous\\\",\\n \\\"model_set\\\": modelSetD,\\n },\\n {\\n \\\"title\\\": \\\"Piecewise Continuous Function Approximation\\\",\\n \\\"layer\\\": \\\"continuous\\\",\\n \\\"model_set\\\": modelSetC,\\n },\\n {\\n \\\"title\\\": \\\"Polynomial function approximation\\\",\\n \\\"layer\\\": \\\"polynomial\\\",\\n \\\"model_set\\\": modelSetP,\\n },\\n {\\n \\\"title\\\": \\\"Fourier function approximation\\\",\\n \\\"layer\\\": \\\"fourier\\\",\\n \\\"model_set\\\": modelSetF,\\n },\\n ]\\n\\n for index, element in enumerate(data):\\n if plot is True:\\n plt.figure(index)\\n plot_approximation(\\n element[\\\"layer\\\"],\\n element[\\\"model_set\\\"],\\n 5,\\n epochs,\\n accelerator=\\\"cpu\\\",\\n periodicity=2,\\n )\\n\\n if plot is True:\\n plt.title(\\\"Piecewise Discontinuous Function Approximation\\\")\\n\\n if plot is True:\\n plt.show()\",\n \"def plot_folder(folder, title, stochastic=True):\\n results = open_folder(folder, stochastic=stochastic)\\n assert len(results) > 0, 'Cannot find any results'\\n ce_values = np.concatenate(\\n [np.expand_dims(r.item()['train_xent'][:-1], 1) for r in results],\\n axis=1)\\n steps = np.concatenate(\\n [np.expand_dims(r.item()['step'][:-1], 1) for r in results], axis=1)\\n alpha_eff_values = np.concatenate(\\n [\\n np.expand_dims(r.item()['lr'] / (1.0 - r.item()['momentum']), 1)\\n for r in results\\n ],\\n axis=1)\\n condition = ['Manual', 'SMD']\\n plot_report_figure_combined(\\n steps,\\n ce_values,\\n alpha_eff_values,\\n condition,\\n title,\\n 'Loss',\\n 'Eff. Learning Rate',\\n os.path.join(\\n folder, 'combined_{}.pdf'.format('stoc' if stochastic else 'det')),\\n include_legend=True)\",\n \"def plot_profile(outdir, xval='x', xscale=1, yscale=1, comp2los=False, adjustRadial=False,\\n fig=True):\\n #Load data\\n path = os.path.join(outdir,'points.h5')\\n x,y,z,ux,uy,uz = pu.extract_points(path)\\n\\n Y = uz / yscale\\n if xval == 'x':\\n X = x / xscale\\n Y1 = ux / yscale\\n elif xval == 'r':\\n X = np.hypot(x,y) / xscale\\n ur = np.hypot(ux,uy)\\n Y1 = ur / yscale\\n if adjustRadial: #fix sign from hypot square root\\n ur = pu.radial2negative(Y1)\\n\\n if fig:\\n plt.figure()\\n # otherwise profile added to active plot\\n\\n #plt.plot(X,uy/yscale,'r.-',label='Uy') #should be zero along EW axis\\n de = 90e3 / xscale #eastern data extent\\n if comp2los != False:\\n data_extents = (X<=de)\\n if comp2los == 'west': #switch sign of radial profile\\n #ux = -ux #move to comp2los function\\n X = -X\\n Y1 = -Y1\\n de = -de\\n data_extents = (X>=de)\\n\\n los = pu.comp2los(x,ux,uy,uz,track=comp2los)\\n plt.plot(X, los/yscale, 'k-', lw=2, label='Ulos_' + comp2los)\\n plt.fill_between(X,los/yscale, where=data_extents, color='gray',alpha=0.5)\\n\\n plt.plot(X, Y, 'b-', lw=2, label='Uz')\\n plt.plot(X, Y1, 'b--',lw=2, mfc='None',label='U{0}'.format(xval))\\n\\n # Annotate\\n plt.title(outdir)\\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n plt.ylabel('Uz [{}]'.format(get_unit(yscale)))\\n plt.axhline(color='k')\\n plt.axvline(de,color='k', linestyle='dashed', label='EW data extent') #EW extent of InSAR coverage\\n plt.legend(loc='best')\\n plt.grid(True)\\n plt.show()\",\n \"def generate_plots(self, env):\\n print(' Generating diagnostic plots for : {0}'.format(self.__class__.__name__))\\n\\n # chdir into the working directory\\n os.chdir(env['WORKDIR'])\\n\\n for nclPlotFile in self._ncl:\\n # copy the NCL command to the workdir\\n shutil.copy2('{0}/{1}'.format(env['NCLPATH'],nclPlotFile), '{0}/{1}'.format(env['WORKDIR'], nclPlotFile))\\n\\n nclFile = '{0}/{1}'.format(env['WORKDIR'],nclPlotFile)\\n rc, err_msg = cesmEnvLib.checkFile(nclFile, 'read')\\n if rc:\\n try:\\n print(' calling NCL plot routine {0}'.format(nclPlotFile))\\n subprocess.check_call(['ncl', '{0}'.format(nclFile)], env=env)\\n except subprocess.CalledProcessError as e:\\n print('WARNING: {0} call to {1} failed with error:'.format(self.name(), nclFile))\\n print(' {0}'.format(e.cmd))\\n print(' rc = {0}'.format(e.returncode))\\n else:\\n print('{0}... continuing with additional plots.'.format(err_msg))\",\n \"def plot(self, job):\\n # fill PlotJob with needed data if it doesn't exist\\n # Plotter will look for the files it needs relative to the work directory\\n # If this fails it will fall back to a baseline location if one was \\n # Provided to cmake at the time this file was generated\\n if job.dataPath == None :\\n job.dataPath = \\\"Scenarios/\\\" + job.verificationDirectory + \\\"/baselines/\\\"\\n \\n if job.dataFile == None:\\n job.dataFile = job.name + \\\"Results.zip\\\"\\n \\n if job.outputFilename==None:\\n job.outputFilename=job.titleOverride+\\\".jpg\\\"\\n \\n if len(job.outputFilename.split(\\\".\\\"))==1:\\n job.outputFilename+=\\\".jpg\\\"\\n \\n if job.imageWidth==None and job.imageHeight==None:\\n job.imageWidth=1600\\n job.imageHeight=800\\n \\n if not os.path.exists(job.dataPath):\\n job.dataPath = os.path.join(job.basedir,job.dataPath)\\n \\n if not os.path.isfile(os.path.join(job.dataPath,job.dataFile)):\\n job.dataPath = os.path.join(job.basedir,job.dataPath)\\n \\n if not job.fontSize:\\n job.fontSize=22\\n \\n if not os.path.exists(os.path.dirname(job.outputDir)):\\n os.mkdir(os.path.dirname(job.outputDir))\\n \\n self.drawgraph(job,os.path.join(job.dataPath,job.dataFile),os.path.join(job.outputDir,job.outputFilename))\",\n \"def plotPaperFigures(folder='results/'):\\n #model Example\\n _AiryDisc(amplitude=1e6, center_x=10.0, center_y=10.0, radius=0.5, focus=0.4, size=21)\\n _CCDkernel(CCDx=10, CCDy=10, width_x=0.35, width_y=0.4, size=21)\\n plotModelExample()\\n\\n #simulation figures\\n theta1 = (2.e5, 9.9, 10.03, 0.41, 0.51, 10., 10., 0.291, 0.335)\\n try:\\n _plotDifferenceIndividualVsJoined(individuals='simulatedResults/RunI*.pkl',\\n joined='results/simulated800nmJoint.pkl',\\n title='Simulated Data: CCD PSF Recovery', truthx=theta1[7], truthy=theta1[8],\\n requirementE=None, requirementFWHM=None, requirementR2=None)\\n _plotModelResiduals(id='RunI1', folder='simulatedResults/', out='Residual1.pdf', individual=True)\\n except:\\n print 'No simulated data to plot...'\\n\\n #real data\\n _plotDifferenceIndividualVsJoined(individuals=folder+'I800nm?.pkl', joined=folder+'J800nm.pkl', title='800nm',\\n FWHMlims=(7.3, 11.8))\\n\\n _plotModelResiduals(id='I800nm2', folder=folder, out='ResidualData.pdf', individual=True)\\n _plotModelResiduals(id='RunI2', folder='simulatedResults/', out='Residual2.pdf', individual=True)\\n\\n #_plotModelResiduals(id='G600nm0', folder=folder, out='ResidualG600.pdf', individual=True)\\n #_plotModelResiduals(id='G700nm0', folder=folder, out='ResidualG700.pdf', individual=True)\\n _plotModelResiduals(id='G800nm0', folder=folder, out='ResidualG800.pdf', individual=True)\\n #_plotModelResiduals(id='G890nm0', folder=folder, out='ResidualG890.pdf', individual=True)\\n\\n #wavelength dependency\\n plotLambdaDependency()\\n\\n #brighter fatter\\n plotBrighterFatter()\",\n \"def plot(self) -> List[matplotlib.figure.Figure]:\\n figs = []\\n\\n title_prefix = self.trial_name + ' ' + self.segment_name + ' '\\n # Figure 1, position in 3 subplots\\n pos_fig_sub = self.plot_subplots(self.fig_num_start, title_prefix + 'Position (mm)', self.pos_raw,\\n self.pos_smooth, self.pos_legend)\\n figs.append(pos_fig_sub)\\n\\n # Figure 2, orientation in 3 subplots\\n eul_fig_sub = self.plot_subplots(self.fig_num_start + 1, title_prefix + 'Euler Angles (deg)', self.eul_raw,\\n self.eul_smooth, self.euler_legend)\\n figs.append(eul_fig_sub)\\n\\n # Figure 3, velocity in 3 subplots\\n vel_fig_sub = self.plot_subplots_vel(self.fig_num_start + 2, title_prefix + 'Velocity', 'Velocity (mm/s)',\\n self.vel)\\n figs.append(vel_fig_sub)\\n\\n # Figure 4, angular velocity in 3 subplots\\n ang_vel_fig_sub = self.plot_subplots_vel(self.fig_num_start + 3, title_prefix + 'Angular Velocity',\\n 'Angular Velocity (deg/s)', self.ang_vel)\\n figs.append(ang_vel_fig_sub)\\n\\n # Figure 5, position in one axes\\n pos_fig_one = self.plot_one_axes(self.fig_num_start + 4, title_prefix + 'Position', 'Position (mm)',\\n self.pos_raw, self.pos_smooth, self.pos_legend)\\n figs.append(pos_fig_one)\\n\\n # Figure 6, orientation in one axes\\n eul_fig_one = self.plot_one_axes(self.fig_num_start + 5, title_prefix + 'Euler Angles', 'Angle (deg)',\\n self.eul_raw, self.eul_smooth, self.euler_legend)\\n figs.append(eul_fig_one)\\n\\n # Figure 7, velocity in one axes\\n vel_fig_one = self.plot_one_axes_vel(self.fig_num_start + 6, title_prefix + 'Velocity', 'Velocity (mm/s)',\\n self.vel, self.pos_legend)\\n figs.append(vel_fig_one)\\n\\n # Figure 8, angular velocity in one axes\\n ang_vel_fig_one = self.plot_one_axes_vel(self.fig_num_start + 7, title_prefix + 'Angular Velocity',\\n 'Angular Velocity (deg/s)', self.ang_vel, self.pos_legend)\\n figs.append(ang_vel_fig_one)\\n\\n return figs\",\n \"def fig_2():\\n epoch = 3\\n N = 60000\\n Nr = N\\n K = 32\\n n_iter = 256\\n Nstar = 16\\n data = 'dr10'\\n factor = 100.\\n features = ['psf_mag', 'model_colors', 'psf_minus_model']\\n filters = ['r', 'ug gr ri iz', 'ugriz']\\n message = 'pm_mc_pmm_r_all_all'\\n model = 'xdmodel_%s_%d_%d_%d_%d_%s.pkl' % (data, Nr, K, n_iter, Nstar,\\n message)\\n model = os.environ['xddata'] + model\\n figname = os.environ['xdplots'] + 'fig2.png'\\n posteriors_plot(model, features, filters, figname, idx=-3)\",\n \"def _plot(self, step, rewards, losses):\\n plt.figure(figsize=(20, 5))\\n plt.subplot(131)\\n plt.title('Total Episode Reward')\\n plt.plot(rewards)\\n plt.subplot(132)\\n plt.title('MSE Loss')\\n plt.plot(losses)\\n plt.show()\",\n \"def visualize(**images):\\n n_images = len(images)\\n plt.figure(figsize=(20,8))\\n for idx, (name, image) in enumerate(images.items()):\\n plt.subplot(1, n_images, idx + 1)\\n plt.xticks([]); \\n plt.yticks([])\\n # get title from the parameter names\\n plt.title(name.replace('_',' ').title(), fontsize=20)\\n plt.imshow(image)\\n plt.savefig('sample_gt_pred_2_max.jpeg')\\n plt.show()\",\n \"def plot_steps(out_dict, units):\\n from bokeh.models import BoxAnnotation\\n from bokeh.plotting import figure, show, output_notebook\\n import bokeh.models as bmd\\n\\n tooltips = [\\n (\\\"Step (total)\\\", \\\"@index\\\"),\\n (\\\"Step (stage)\\\", \\\"@step\\\"),\\n (\\\"Energy\\\", \\\"@energy eV/atom\\\"),\\n (\\\"Energy (dispersion)\\\", \\\"@dispersion_energy_au Ha\\\"),\\n (\\\"SCF converged\\\", \\\"@scf_converged\\\"),\\n (\\\"Cell A\\\", \\\"@cell_a_angs Angs\\\"),\\n (\\\"Cell Vol\\\", \\\"@cell_vol_angs3 Angs^3\\\"),\\n (\\\"MAX Step\\\", \\\"@max_step_au Bohr\\\"),\\n (\\\"Pressure\\\", \\\"@pressure_bar bar\\\")\\n ]\\n hover = bmd.HoverTool(tooltips=tooltips)\\n TOOLS = [\\\"pan\\\", \\\"wheel_zoom\\\", \\\"box_zoom\\\", \\\"reset\\\", \\\"save\\\", hover]\\n\\n natoms = out_dict['natoms']\\n values = [ x/natoms*ha2u[units] for x in out_dict['step_info']['energy_au'] ]\\n values = [ x-min(values) for x in values ]\\n\\n data = bmd.ColumnDataSource(data=dict( index=range(len(values)),\\n step=out_dict['step_info']['step'],\\n energy=values,\\n dispersion_energy_au=out_dict['step_info']['dispersion_energy_au'],\\n scf_converged=out_dict['step_info']['scf_converged'],\\n cell_a_angs=out_dict['step_info']['cell_a_angs'],\\n cell_vol_angs3=out_dict['step_info']['cell_vol_angs3'],\\n max_step_au=out_dict['step_info']['max_step_au'],\\n pressure_bar=out_dict['step_info']['pressure_bar'],\\n ))\\n\\n p = figure(tools=TOOLS, title='Energy profile of the DFT minimization',\\n height=350, width=550)\\n\\n p.xgrid.grid_line_color=None\\n p.xaxis.axis_label = 'Steps'\\n p.yaxis.axis_label = 'Energy ({}/atom)'.format(units)\\n\\n # Colored background\\n colors = ['red','orange','green','yellow','cyan','pink','palegreen']\\n start = 0\\n for i,steps in enumerate(out_dict['stage_info']['nsteps']):\\n end = start+steps\\n p.add_layout(BoxAnnotation(left=start, right=end, fill_alpha=0.2, fill_color=colors[i]))\\n start = end\\n\\n # Trace line and markers\\n p.line('index', 'energy', source=data, line_color='blue')\\n p.circle('index', 'energy', source=data, line_color='blue', size=3)\\n return p\",\n \"def make_plots(self,indices=None,hardcopy=False,hardcopydir='.',hardcopyprefix='',hardcopytype='png'):\\n\\t\\tfor (i,E) in enumerate(self.experiments):\\n\\t\\t\\tif(indices==None) or (i in indices):\\n\\t\\t\\t\\tE.show_plot(hardcopy,hardcopydir,hardcopyprefix,hardcopytype)\",\n \"def do_compare_plots(cat7, cat7s, subdir,label):\\n #Check the effect of the 5km/s split\\n #dNdX\\n cat7.plot_line_density(zmax=5)\\n cat7s.plot_line_density(zmax=5, label=label)\\n plt.legend(loc=0)\\n save_figure(path.join(subdir,\\\"dndx_\\\"+label))\\n plt.clf()\\n\\n #Omega_DLA\\n cat7.plot_cddf(zmax=4,color=\\\"blue\\\")\\n cat7s.plot_cddf(zmax=4,color=\\\"red\\\",label=label)\\n plt.xlim(1e20, 1e23)\\n plt.ylim(1e-28, 5e-21)\\n plt.legend(loc=0)\\n save_figure(path.join(subdir, \\\"cddf_\\\"+label))\\n plt.clf()\\n\\n #Omega_DLA\\n cat7.plot_omega_dla(zmax=5)\\n cat7s.plot_omega_dla(zmax=5, label=label)\\n plt.legend(loc=0)\\n save_figure(path.join(subdir,\\\"omega_\\\"+label))\\n plt.clf()\",\n \"def fdd_plot(result_file_list,default_fdds,ion_default):\\n # Getting data from the file\\n fdd_param_keys = [result_file.split('_')[0] for result_file in result_file_list]\\n# print \\\" Parameters to plot for:\\\", fdd_param_keys\\n fig = plt.figure(figsize=(14,12))#(8.27,11.69))\\n axs = [None]*(len(result_file_list)*5 + 1) # List of axes: 2 ions x (1 uncert + 1 value) + 1 for iterations (axs[0] will not be used)\\n for j,result_file_name in enumerate(result_file_list):\\n with open(result_file_name,'r') as res_file:\\n res_data = res_file.read().split('\\\\n')\\n if res_data[-1] == \\\"\\\": # delete empty line if present\\n del res_data[-1]\\n else:\\n pass\\n fdd_list, H_list, Hunc_list, D_list, Dunc_list, n_iter_list,fdd_iter_list = [[] for i in range(7)]\\n for line in res_data:\\n line_split = line.split()\\n if line_split[1] == '0' or line_split[1] == '-1':\\n fdd_list.append(float(line_split[0].split('_')[-1])) # fdd_list\\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\\n if line_split[1] == '0':\\n n_iter_list.append(int(line_split[2])) # number of iterations list\\n else:\\n n_iter_list.append(-1) # 125, number of iterations\\n H_list.append(float(line_split[3])) # H_list\\n Hunc_list.append(float(line_split[4])) # Hunc_list\\n D_list.append(float(line_split[5])) # D_list\\n Dunc_list.append(float(line_split[6])) # Dunc_list\\n elif line_split[1] == '1':\\n print \\\" {} = {} <- excluded: error '1' (no f26 file was found, check 'stdout.dat' and 'stderr.dat')\\\".format(fdd_param_keys[j], line_split[0])\\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\\n n_iter_list.append(0) # number of iterations list\\n elif line_split[1] == '2':\\n print \\\" {} = {} <- excluded: error '2' (error happened during VPFITing, check 'stderr.dat')\\\".format(fdd_param_keys[j], line_split[0])\\n\\t\\tfdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\\n\\t\\tn_iter_list.append(0) # number of iterations list\\n elif line_split[1] == '3':\\n print \\\" {} = {} <- excluded: error '3' (zero size f26 file, check 'stdout.dat')\\\".format(fdd_param_keys[j], line_split[0])\\n\\t\\tfdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\\n\\t\\tn_iter_list.append(0) # number of iterations list\\n elif line_split[1] == '4':\\n print \\\" {} = {} <- excluded: error '4' (new and original f26's have different number of lines, check 'stdout.dat')\\\".format(fdd_param_keys[j], line_split[0])\\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\\n\\t\\tn_iter_list.append(-3) # number of iterations list\\n elif line_split[1] == '5':\\n print \\\" {} = {} <- excluded: error '5' ('****' uncertainty was found for one of specified ion! Check f26 file)\\\".format(fdd_param_keys[j], line_split[0])\\n fdd_iter_list.append(float(line_split[0].split('_')[-1])) # fdd_list for iteration subplot\\n\\t\\tn_iter_list.append(-2) # number of iterations list\\n else:\\n print \\\" Unknown error code was specified in {}\\\".format(result_file_name)\\n\\n # Data are ready to plot\\n # First column of subplots (uncertainties)\\n axs[5*j+1] = plt.subplot(len(fdd_param_keys),3,3*j+1)\\n axs[5*j+1].plot(fdd_list,Dunc_list,color='b',drawstyle=\\\"steps-mid\\\") # Plotting data\\n axs[5*j+1].plot(default_fdds[fdd_param_keys[j]],ion_default[3],'bo',mew=0.0) # plotting default result\\n axs[5*j+1].set_ylabel(r'$\\\\Delta$N(D I)',color='b')\\n axs[5*j+1].tick_params('y',colors='b')\\n axs[5*j+1].ticklabel_format(useOffset=False)\\n axs[5*j+1].set_xscale('log')\\n if fdd_param_keys[j] == 'fdbstep':\\n axs[5*j+1].set_xlabel('{} [{:g}], km/s'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\\n else:\\n axs[5*j+1].set_xlabel('{} [{:g}]'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\\n axs[5*j+1].axvline(default_fdds[fdd_param_keys[j]],linewidth=1,color='g') # indicate fdd from vp_setup.dat\\n# axs[5*j+1].margins(y=np.ptp(Dunc_list)/2.0) # Include marging above and below the data to show default fdds\\n axs[5*j+2] = axs[5*j+1].twinx() # second plot on the same axis\\n axs[5*j+2].plot(fdd_list,Hunc_list,color='r',drawstyle=\\\"steps-mid\\\")\\n axs[5*j+2].plot(default_fdds[fdd_param_keys[j]],ion_default[1],'ro',mew=0.0)\\n axs[5*j+2].set_ylabel(r'$\\\\Delta$N(H I)',color='r')\\n axs[5*j+2].tick_params('y',colors='r')\\n axs[5*j+2].ticklabel_format(useOffset=False,axis='y')\\n # Second column of subplots (middle values)\\n axs[5*j+3] = plt.subplot(len(fdd_param_keys),3,3*j+2)\\n plot_interal = False # Add 1-sigma interval\\n if plot_interal == True:\\n median = np.median(D_list)\\n med_unc = np.median(Dunc_list)\\n print \\\"median = {} +/- {} for {}\\\".format(median,med_unc,fdd_param_keys[j])\\n axs[5*j+3].fill_between(fdd_list, median-med_unc, median+med_unc,facecolor='green', alpha=0.4)\\n axs[5*j+3].plot(fdd_list,D_list,color='b',drawstyle=\\\"steps-mid\\\",zorder=2) # Plotting data\\n axs[5*j+3].plot(default_fdds[fdd_param_keys[j]],ion_default[2],'bo',zorder=10,mew=0.0)\\n axs[5*j+3].set_ylabel(r'N(D I)',color='b')\\n axs[5*j+3].ticklabel_format(useOffset=False)\\n axs[5*j+3].tick_params('y',colors='b')\\n axs[5*j+3].set_xscale('log')\\n if fdd_param_keys[j] == 'fdbstep':\\n axs[5*j+3].set_xlabel('{} [{:g}], km/s'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\\n else:\\n axs[5*j+3].set_xlabel('{} [{:g}]'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\\n axs[5*j+3].axvline(default_fdds[fdd_param_keys[j]],linewidth=1,color='g') # indicate fdd from vp_setup.dat\\n# axs[5*j+3].margins(y=np.ptp(D_list),tight=False) # Include marging above and below the data to show default fdds\\n axs[5*j+4] = axs[5*j+3].twinx()\\n axs[5*j+4].plot(fdd_list,H_list,color='r',drawstyle=\\\"steps-mid\\\",zorder=1)\\n axs[5*j+4].plot(default_fdds[fdd_param_keys[j]],ion_default[0],'ro',zorder=10,mew=0.0)\\n axs[5*j+4].set_ylabel(r'N(H I)',color='r')\\n axs[5*j+4].tick_params('y',colors='r')\\n axs[5*j+4].ticklabel_format(useOffset=False,axis='y')\\n # Third column of subplots (number of iterations)\\n axs[5*j+5] = plt.subplot(len(fdd_param_keys),3,3*j+3)\\n axs[5*j+5].plot(fdd_iter_list,n_iter_list,drawstyle=\\\"steps-mid\\\") # Plotting n_iter_list\\n# axs[5*j+5].yaxis.tick_right()\\n# axs[5*j+5].yaxis.set_label_position(\\\"right\\\")\\n axs[5*j+5].set_ylabel('N iterations')\\n axs[5*j+5].ticklabel_format(useOffset=False)\\n axs[5*j+5].set_xscale('log')\\n if fdd_param_keys[j] == 'fdbstep':\\n axs[5*j+5].set_xlabel('{} [{:g}], km/s'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\\n else:\\n axs[5*j+5].set_xlabel('{} [{:g}]'.format(fdd_param_keys[j],default_fdds[fdd_param_keys[j]]))\\n axs[5*j+5].axvline(default_fdds[fdd_param_keys[j]],linewidth=1,color='g') # indicate fdd from vp_setup.dat\\n axs[5*j+5].axhline(0,linewidth=1,color='grey',ls=\\\":\\\") # indicate fdd from vp_setup.dat\\n\\n# plt.tight_layout()\\n fig.subplots_adjust(hspace=0.3,wspace=0.9) # Set up spaces between subplots\\n plt.savefig(\\\"fdd_plot.pdf\\\",bbox_inches='tight', pad_inches=0)\\n plt.show()\\n plt.close()\\n print \\\" Plot is done!\\\"\",\n \"def run(self):\\n # fill the x_values,y_values,z_values dictionaries\\n if not self.__fillCoordinatesFromSource():\\n self.raiseAWarning('Nothing to Plot Yet. Returning.')\\n return\\n\\n self.counter += 1\\n if self.counter > 1:\\n self.actcm = None\\n clusterDict = deepcopy(self.outStreamTypes)\\n\\n # start plotting.... loop over the plots that need to be included in this figure\\n for pltIndex in range(len(self.outStreamTypes)):\\n plotSettings = self.options['plotSettings']['plot'][pltIndex]\\n if 'gridLocation' in plotSettings:\\n x = None\\n y = None\\n if 'x' in plotSettings['gridLocation']:\\n x = list(map(int, plotSettings['gridLocation']['x'].strip().split(' ')))\\n else:\\n x = None\\n if 'y' in plotSettings['gridLocation'].keys():\\n y = list(map(int, plotSettings['gridLocation']['y'].strip().split(' ')))\\n else:\\n y = None\\n if pltIndex == 0:\\n self.ax.remove() # remove axis so that there is not an extra axis on plot with subplots\\n if (len(x) == 1 and len(y) == 1):\\n if self.dim == 2:\\n self.ax = self.fig.add_subplot(self.gridSpace[x[0], y[0]])\\n else:\\n self.ax = self.fig.add_subplot(self.gridSpace[x[0], y[0]], projection='3d')\\n elif (len(x) == 1 and len(y) != 1):\\n if self.dim == 2:\\n self.ax = self.fig.add_subplot(self.gridSpace[x[0], y[0]:y[-1]])\\n else:\\n self.ax = self.fig.add_subplot(self.gridSpace[x[0], y[0]:y[-1]], projection='3d')\\n elif (len(x) != 1 and len(y) == 1):\\n if self.dim == 2:\\n self.ax = self.fig.add_subplot(self.gridSpace[x[0]:x[-1], y[0]])\\n else:\\n self.ax = self.fig.add_subplot(self.gridSpace[x[0]:x[-1], y[0]], projection='3d')\\n else:\\n if self.dim == 2:\\n self.ax = self.fig.add_subplot(self.gridSpace[x[0]:x[-1], y[0]:y[-1]])\\n else:\\n self.ax = self.fig.add_subplot(self.gridSpace[x[0]:x[-1], y[0]:y[-1]], projection='3d')\\n\\n if 'gridSpace' in self.options['plotSettings']:\\n self.ax.locator_params(axis='y', nbins=4)\\n self.ax.locator_params(axis='x', nbins=2)\\n if 'range' in plotSettings:\\n axes_range = plotSettings['range']\\n if 'ymin' in axes_range:\\n self.ax.set_ylim(bottom=ast.literal_eval(axes_range['ymin']))\\n if 'ymax' in axes_range:\\n self.ax.set_ylim(top=ast.literal_eval(axes_range['ymax']))\\n if 'xmin' in axes_range:\\n self.ax.set_xlim(left=ast.literal_eval(axes_range['xmin']))\\n if 'xmax' in axes_range:\\n self.ax.set_xlim(right=ast.literal_eval(axes_range['xmax']))\\n if self.dim == 3:\\n if 'zmin' in axes_range.options['plotSettings']['plot'][pltIndex]:\\n if 'zmax' not in axes_range.options['plotSettings']:\\n self.raiseAWarning('zmin inputted but not zmax. zmin ignored! ')\\n else:\\n self.ax.set_zlim(bottom=ast.literal_eval(axes_range['zmin']), top=ast.literal_eval(self.options['plotSettings']['zmax']))\\n if 'zmax' in axes_range:\\n if 'zmin' not in axes_range:\\n self.raiseAWarning('zmax inputted but not zmin. zmax ignored! ')\\n else:\\n self.ax.set_zlim(bottom=ast.literal_eval(axes_range['zmin']), top=ast.literal_eval(axes_range['zmax']))\\n if 'xlabel' not in plotSettings:\\n self.ax.set_xlabel('x')\\n else:\\n self.ax.set_xlabel(plotSettings['xlabel'])\\n if 'ylabel' not in plotSettings:\\n self.ax.set_ylabel('y')\\n else:\\n self.ax.set_ylabel(plotSettings['ylabel'])\\n if 'zlabel' in plotSettings:\\n if self.dim == 2:\\n self.raiseAWarning('zlabel keyword does not make sense in 2-D Plots!')\\n elif self.dim == 3 and self.zCoordinates:\\n self.ax.set_zlabel(plotSettings['zlabel'])\\n elif self.dim == 3 and self.zCoordinates:\\n self.ax.set_zlabel('z')\\n else:\\n if 'xlabel' not in self.options['plotSettings']:\\n self.ax.set_xlabel('x')\\n else:\\n self.ax.set_xlabel(self.options['plotSettings']['xlabel'])\\n if 'ylabel' not in self.options['plotSettings']:\\n self.ax.set_ylabel('y')\\n else:\\n self.ax.set_ylabel(self.options['plotSettings']['ylabel'])\\n if 'zlabel' in self.options['plotSettings']:\\n if self.dim == 2:\\n self.raiseAWarning('zlabel keyword does not make sense in 2-D Plots!')\\n elif self.dim == 3 and self.zCoordinates:\\n self.ax.set_zlabel(self.options['plotSettings']['zlabel'])\\n elif self.dim == 3 and self.zCoordinates:\\n self.ax.set_zlabel('z')\\n\\n if 'legend' in self.options['plotSettings']:\\n if 'label' not in plotSettings.get('attributes', {}):\\n if 'attributes' not in plotSettings:\\n plotSettings['attributes'] = {}\\n plotSettings['attributes']['label'] = self.outStreamTypes[pltIndex] + ' ' + str(pltIndex)\\n #################\\n # SCATTER PLOT #\\n #################\\n self.raiseADebug(f'creating plot {self.name}')\\n if self.outStreamTypes[pltIndex] == 'scatter':\\n if 's' not in plotSettings:\\n plotSettings['s'] = '20'\\n if 'c' not in plotSettings:\\n plotSettings['c'] = 'b'\\n if 'marker' not in plotSettings:\\n plotSettings['marker'] = 'o'\\n if 'alpha' not in plotSettings:\\n plotSettings['alpha'] = 'None'\\n if 'linewidths' not in plotSettings:\\n plotSettings['linewidths'] = 'None'\\n if self.colorMapCoordinates[pltIndex] is not None:\\n # Find the max and min colormap values\\n firstKey = utils.first(self.xValues[pltIndex].keys())\\n vmin = np.amin(self.colorMapValues[pltIndex][firstKey])\\n vmax = np.amax(self.colorMapValues[pltIndex][firstKey])\\n for key in self.xValues[pltIndex]:\\n vmin = min(vmin,np.amin(self.colorMapValues[pltIndex][key]))\\n vmax = max(vmax,np.amax(self.colorMapValues[pltIndex][key]))\\n plotSettings['norm'] = matplotlib.colors.Normalize(vmin,vmax)\\n for key in self.xValues[pltIndex]:\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n scatterPlotOptions = {'s': ast.literal_eval(plotSettings['s']),\\n 'marker': (plotSettings['marker']),\\n 'alpha': ast.literal_eval(plotSettings['alpha']),\\n 'linewidths': ast.literal_eval(plotSettings['linewidths'])}\\n if self.colorMapCoordinates[pltIndex] is not None:\\n scatterPlotOptions['norm'] = plotSettings['norm']\\n scatterPlotOptions.update(plotSettings.get('attributes', {}))\\n if self.dim == 2:\\n if self.colorMapCoordinates[pltIndex] is not None:\\n scatterPlotOptions['c'] = self.colorMapValues[pltIndex][key][xIndex]\\n scatterPlotOptions['cmap'] = matplotlib.cm.get_cmap(\\\"winter\\\")\\n if self.actcm:\\n first = False\\n else:\\n first = True\\n if plotSettings['cmap'] == 'None':\\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n **scatterPlotOptions)\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n if first:\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_array(self.colorMapValues[pltIndex][key])\\n self.actcm = self.fig.colorbar(m)\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n try:\\n self.actcm.draw_all()\\n # this is not good, what exception will be thrown?\\n except:\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_array(self.colorMapValues[pltIndex][key])\\n self.actcm = self.fig.colorbar(m)\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n scatterPlotOptions['cmap'] = plotSettings['cmap']\\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n **scatterPlotOptions)\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n if first:\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_array(self.colorMapValues[pltIndex][key])\\n self.actcm = self.fig.colorbar(m, ax=self.ax)\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_clim(vmin = min(self.colorMapValues[pltIndex][key][-1]), vmax=max(self.colorMapValues[pltIndex][key][-1]))\\n self.actcm.draw_all()\\n else:\\n if 'color' not in scatterPlotOptions:\\n scatterPlotOptions['c'] = plotSettings['c']\\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n **scatterPlotOptions)\\n else:\\n for zIndex in range(len(self.zValues[pltIndex][key])):\\n if self.colorMapCoordinates[pltIndex] is not None:\\n scatterPlotOptions['c'] = self.colorMapValues[pltIndex][key][zIndex]\\n if self.actcm:\\n first = False\\n else:\\n first = True\\n if plotSettings['cmap'] == 'None':\\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], self.zValues[pltIndex][key][zIndex], **scatterPlotOptions)\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n if first:\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_array(self.colorMapValues[pltIndex][key])\\n self.actcm = self.fig.colorbar(m)\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n self.actcm.draw_all()\\n else:\\n scatterPlotOptions['cmap'] = plotSettings['cmap']\\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], self.zValues[pltIndex][key][zIndex], **scatterPlotOptions)\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n if first:\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_array(self.colorMapValues[pltIndex][key])\\n self.actcm = self.fig.colorbar(m)\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n m = matplotlib.cm.ScalarMappable(cmap = self.actPlot.cmap, norm = self.actPlot.norm)\\n m.set_clim(vmin = min(self.colorMapValues[pltIndex][key][-1]), vmax=max(self.colorMapValues[pltIndex][key][-1]))\\n self.actcm.draw_all()\\n else:\\n if 'color' not in scatterPlotOptions:\\n scatterPlotOptions['c'] = plotSettings['c']\\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], self.zValues[pltIndex][key][zIndex], **scatterPlotOptions)\\n #################\\n # LINE PLOT #\\n #################\\n elif self.outStreamTypes[pltIndex] == 'line':\\n minV = 0\\n maxV = 0\\n # If the user does not define an appropriate cmap, then use matplotlib's default.\\n if 'cmap' not in plotSettings or plotSettings['cmap'] not in matplotlib.cm.datad:\\n plotSettings['cmap'] = None\\n if bool(self.colorMapValues):\\n for key in self.xValues[pltIndex]:\\n minV = min(minV,self.colorMapValues[pltIndex][key][-1][-1])\\n maxV = max(maxV,self.colorMapValues[pltIndex][key][-1][-1])\\n cmap = matplotlib.cm.ScalarMappable(matplotlib.colors.Normalize(minV, maxV, True), plotSettings['cmap'])\\n cmap.set_array([minV,maxV])\\n for key in self.xValues[pltIndex]:\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n if self.colorMapCoordinates[pltIndex] is not None:\\n plotSettings['interpPointsX'] = str(max(200, len(self.xValues[pltIndex][key][xIndex])))\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n if self.dim == 2:\\n if self.yValues[pltIndex][key][yIndex].size < 2:\\n return\\n xi, yi = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], plotSettings, returnCoordinate=True)\\n if self.colorMapCoordinates[pltIndex] is not None:\\n self.ax.plot(xi, yi, c=cmap.cmap(self.colorMapValues[pltIndex][key][-1][-1]/(maxV-minV)))\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n if self.actcm is None:\\n self.actcm = self.fig.colorbar(cmap)\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n self.actcm.draw_all()\\n else:\\n self.actPlot = self.ax.plot(xi, yi, **plotSettings.get('attributes', {}))\\n else:\\n for zIndex in range(len(self.zValues[pltIndex][key])):\\n if self.zValues[pltIndex][key][zIndex].size <= 3:\\n return\\n if self.colorMapCoordinates[pltIndex] is not None:\\n self.ax.plot(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n self.zValues[pltIndex][key][zIndex],\\n c=cmap.cmap(self.colorMapValues[pltIndex][key][-1][-1]/(maxV-minV)))\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n if self.actcm is None:\\n self.actcm = self.fig.colorbar(cmap)\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n self.actcm.draw_all()\\n else:\\n self.actPlot = self.ax.plot(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n self.zValues[pltIndex][key][zIndex],\\n **plotSettings.get('attributes', {}))\\n ##################\\n # HISTOGRAM PLOT #\\n ##################\\n elif self.outStreamTypes[pltIndex] == 'histogram':\\n if 'bins' not in plotSettings:\\n if self.dim == 2:\\n plotSettings['bins'] = '10'\\n else:\\n plotSettings['bins'] = '4'\\n if 'normed' not in plotSettings:\\n plotSettings['normed'] = 'False'\\n if 'weights' not in plotSettings:\\n plotSettings['weights'] = 'None'\\n if 'cumulative' not in plotSettings:\\n plotSettings['cumulative'] = 'False'\\n if 'histtype' not in plotSettings:\\n plotSettings['histtype'] = 'bar'\\n if 'align' not in plotSettings:\\n plotSettings['align'] = 'mid'\\n if 'orientation' not in plotSettings:\\n plotSettings['orientation'] = 'vertical'\\n if 'rwidth' not in plotSettings:\\n plotSettings['rwidth'] = 'None'\\n if 'log' not in plotSettings:\\n plotSettings['log'] = 'None'\\n if 'color' not in plotSettings:\\n plotSettings['color'] = 'b'\\n if 'stacked' not in plotSettings:\\n plotSettings['stacked'] = 'None'\\n if self.sourceData[0].type.strip() == 'HistorySet':\\n #####################################################################################################################################\\n # @MANDD: This 'if' condition has been added in order to allow the user the correctly create an histogram out of an historySet #\\n # If the histogram is created out of the input variables, then the plot has an identical meaning of the one generated by a pointSet #\\n # However, if the histogram is created out of the output variables, then the plot consider only the last value of the array #\\n #####################################################################################################################################\\n data = {}\\n data['x'] = np.empty(0)\\n data['y'] = np.empty(0)\\n for index in range(len(self.outStreamTypes)):\\n for key in self.xValues[index]:\\n data['x'] = np.append(data['x'], self.xValues[index][key][0][-1])\\n if self.dim == 3:\\n data['y'] = np.append(data['y'], self.yValues[index][key][0][-1])\\n del self.xValues[index]\\n self.xValues = {}\\n self.xValues[index] = {}\\n self.xValues[index][0] = []\\n self.xValues[index][0].append(deepcopy(data['x']))\\n if self.dim == 3:\\n del self.yValues[index]\\n self.yValues = {}\\n self.yValues[index] ={ }\\n self.yValues[index][0] = []\\n self.yValues[index][0].append(deepcopy(data['y']))\\n\\n for key in self.xValues[pltIndex]:\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n try:\\n colorss = ast.literal_eval(plotSettings['color'])\\n # unknown what specific error is anticipated here, but I don't like a bare except...\\n # ast.literal_eval can raise the exceptions listed below (see library docs):\\n except (ValueError, TypeError, SyntaxError, MemoryError, RecursionError):\\n colorss = plotSettings['color']\\n if self.dim == 2:\\n self.ax.hist(self.xValues[pltIndex][key][xIndex],\\n bins=ast.literal_eval(plotSettings['bins']),\\n density=ast.literal_eval(plotSettings['normed']),\\n weights=ast.literal_eval(plotSettings['weights']),\\n cumulative=ast.literal_eval(plotSettings['cumulative']),\\n histtype=plotSettings['histtype'],\\n align=plotSettings['align'],\\n orientation=plotSettings['orientation'],\\n rwidth=ast.literal_eval(plotSettings['rwidth']),\\n log=ast.literal_eval(plotSettings['log']),\\n color=colorss,\\n stacked=ast.literal_eval(plotSettings['stacked']),\\n **plotSettings.get('attributes', {}))\\n else:\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n hist, xedges, yedges = np.histogram2d(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n bins=ast.literal_eval(plotSettings['bins']))\\n elements = (len(xedges) - 1) * (len(yedges) - 1)\\n if 'x_offset' in plotSettings:\\n xoffset = float(plotSettings['x_offset'])\\n else:\\n xoffset = 0.25\\n if 'y_offset' in plotSettings:\\n yoffset = float(plotSettings['y_offset'])\\n else:\\n yoffset = 0.25\\n if 'dx' in plotSettings:\\n dxs = float(plotSettings['dx'])\\n else:\\n dxs = (self.xValues[pltIndex][key][xIndex].max() - self.xValues[pltIndex][key][xIndex].min()) / float(plotSettings['bins'])\\n if 'dy' in plotSettings:\\n dys = float(plotSettings['dy'])\\n else:\\n dys = (self.yValues[pltIndex][key][yIndex].max() - self.yValues[pltIndex][key][yIndex].min()) / float(plotSettings['bins'])\\n xpos, ypos = np.meshgrid(xedges[:-1] + xoffset, yedges[:-1] + yoffset)\\n self.actPlot = self.ax.bar3d(xpos.flatten(),\\n ypos.flatten(),\\n np.zeros(elements),\\n dxs*np.ones_like(elements),\\n dys*np.ones_like(elements),\\n hist.flatten(),\\n color=colorss,\\n zsort='average',\\n **plotSettings.get('attributes', {}))\\n ##################\\n # STEM PLOT #\\n ##################\\n elif self.outStreamTypes[pltIndex] == 'stem':\\n if 'linefmt' not in plotSettings:\\n plotSettings['linefmt'] = 'b-'\\n if 'markerfmt' not in plotSettings:\\n plotSettings['markerfmt'] = 'bo'\\n if 'basefmt' not in plotSettings:\\n plotSettings['basefmt'] = 'r-'\\n for key in self.xValues[pltIndex]:\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n if self.dim == 2:\\n self.actPlot = self.ax.stem(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n linefmt=plotSettings['linefmt'],\\n markerfmt=plotSettings['markerfmt'],\\n basefmt = plotSettings['linefmt'],\\n use_line_collection=True,\\n **plotSettings.get('attributes', {}))\\n else:\\n # it is a basic stem plot constructed using a standard line plot. For now we do not use the previous defined keywords...\\n for zIndex in range(len(self.zValues[pltIndex][key])):\\n for xx, yy, zz in zip(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], self.zValues[pltIndex][key][zIndex]):\\n self.ax.plot([xx, xx], [yy, yy], [0, zz], '-')\\n ##################\\n # STEP PLOT #\\n ##################\\n elif self.outStreamTypes[pltIndex] == 'step':\\n if self.dim == 2:\\n if 'where' not in plotSettings:\\n plotSettings['where'] = 'mid'\\n for key in self.xValues[pltIndex]:\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n if self.xValues[pltIndex][key][xIndex].size < 2:\\n xi = self.xValues[pltIndex][key][xIndex]\\n else:\\n xi = np.linspace(self.xValues[pltIndex][key][xIndex].min(), self.xValues[pltIndex][key][xIndex].max(), ast.literal_eval(plotSettings['interpPointsX']))\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n if self.yValues[pltIndex][key][yIndex].size <= 3:\\n return\\n yi = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], plotSettings)\\n self.actPlot = self.ax.step(xi, yi, where=plotSettings['where'], **plotSettings.get('attributes', {}))\\n else:\\n self.raiseAWarning('step Plot not available in 3D')\\n return\\n ########################\\n # PSEUDOCOLOR PLOT #\\n ########################\\n elif self.outStreamTypes[pltIndex] == 'pseudocolor':\\n if self.dim == 2:\\n for key in self.xValues[pltIndex]:\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n # Hopefully, x,y, and z are all the same length, so checking this\\n # here should be good enough.\\n # The problem is you cannot interpolate any amount of space if\\n # you only have a single data point.\\n if self.xValues[pltIndex][key][xIndex].size == 1:\\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\\n continue\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n if not self.colorMapCoordinates:\\n self.raiseAMessage('pseudocolor Plot needs coordinates for color map... Returning without plotting')\\n return\\n for zIndex in range(len(self.colorMapValues[pltIndex][key])):\\n if self.colorMapValues[pltIndex][key][zIndex].size <= 3:\\n return\\n xig, yig, Ci = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n plotSettings,\\n z=self.colorMapValues[pltIndex][key][zIndex],\\n returnCoordinate=True)\\n if plotSettings['cmap'] == 'None':\\n self.actPlot = self.ax.pcolormesh(xig,\\n yig,\\n ma.masked_where(np.isnan(Ci), Ci),\\n **plotSettings.get('attributes', {}))\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n else:\\n self.actPlot = self.ax.pcolormesh(xig,\\n yig,\\n ma.masked_where(np.isnan(Ci), Ci),\\n cmap=matplotlib.cm.get_cmap(name = plotSettings['cmap']),\\n **plotSettings.get('attributes', {}))\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_array(ma.masked_where(np.isnan(Ci), Ci))\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n actcm = self.fig.colorbar(m)\\n actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n self.raiseAWarning('pseudocolor Plot is considered a 2D plot, not a 3D!')\\n return\\n ########################\\n # SURFACE PLOT #\\n ########################\\n elif self.outStreamTypes[pltIndex] == 'surface':\\n if self.dim == 2:\\n self.raiseAWarning('surface Plot is NOT available for 2D plots, IT IS A 3D!')\\n return\\n else:\\n if 'rstride' not in plotSettings:\\n plotSettings['rstride'] = '1'\\n if 'cstride' not in plotSettings:\\n plotSettings['cstride'] = '1'\\n if 'antialiased' not in plotSettings:\\n plotSettings['antialiased'] = 'False'\\n if 'linewidth' not in plotSettings:\\n plotSettings['linewidth'] = '0'\\n for key in self.xValues[pltIndex]:\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n # Hopefully, x,y, and z are all the same length, so checking this\\n # here should be good enough.\\n # The problem is you cannot interpolate any amount of space if\\n # you only have a single data point.\\n if self.xValues[pltIndex][key][xIndex].size == 1:\\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\\n continue\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n for zIndex in range(len(self.zValues[pltIndex][key])):\\n if self.zValues[pltIndex][key][zIndex].size <= 3:\\n return\\n if self.colorMapCoordinates[pltIndex] is not None:\\n xig, yig, Ci = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n plotSettings,\\n z=self.colorMapValues[pltIndex][key][zIndex],\\n returnCoordinate=True)\\n xig, yig, zi = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n plotSettings,\\n z=self.zValues[pltIndex][key][zIndex],\\n returnCoordinate=True)\\n if self.colorMapCoordinates[pltIndex] is not None:\\n if self.actcm:\\n first = False\\n else:\\n first = True\\n if plotSettings['cmap'] == 'None':\\n plotSettings['cmap'] = 'jet'\\n self.actPlot = self.ax.plot_surface(xig,\\n yig,\\n ma.masked_where(np.isnan(zi), zi),\\n rstride=ast.literal_eval(plotSettings['rstride']),\\n cstride=ast.literal_eval(plotSettings['cstride']),\\n facecolors=matplotlib.cm.get_cmap(name=plotSettings['cmap'])(ma.masked_where(np.isnan(Ci), Ci)),\\n cmap=matplotlib.cm.get_cmap(name = plotSettings['cmap']),\\n linewidth=ast.literal_eval(plotSettings['linewidth']),\\n antialiased=ast.literal_eval(plotSettings['antialiased']),\\n **plotSettings.get('attributes', {}))\\n if first:\\n self.actPlot.cmap = matplotlib.cm.get_cmap(name=plotSettings['cmap'])\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n if first:\\n m = matplotlib.cm.ScalarMappable(cmap = self.actPlot.cmap, norm = self.actPlot.norm)\\n m.set_array(self.colorMapValues[pltIndex][key])\\n self.actcm = self.fig.colorbar(m)\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_clim(vmin=min(self.colorMapValues[pltIndex][key][-1]), vmax=max(self.colorMapValues[pltIndex][key][-1]))\\n self.actcm.draw_all()\\n else:\\n if plotSettings['cmap'] == 'None':\\n self.actPlot = self.ax.plot_surface(xig,\\n yig,\\n ma.masked_where(np.isnan(zi), zi),\\n rstride=ast.literal_eval(plotSettings['rstride']),\\n cstride=ast.literal_eval(plotSettings['cstride']),\\n linewidth=ast.literal_eval(plotSettings['linewidth']),\\n antialiased=ast.literal_eval(plotSettings['antialiased']),\\n **plotSettings.get('attributes', {}))\\n if 'color' in plotSettings.get('attributes', {}):\\n self.actPlot.set_color = plotSettings.get('attributes', {})['color']\\n else:\\n self.actPlot.set_color = 'blue'\\n else:\\n self.actPlot = self.ax.plot_surface(xig,\\n yig,\\n ma.masked_where(np.isnan(zi), zi),\\n rstride=ast.literal_eval(plotSettings['rstride']),\\n cstride=ast.literal_eval(plotSettings['cstride']),\\n cmap=matplotlib.cm.get_cmap(name = plotSettings['cmap']),\\n linewidth=ast.literal_eval(plotSettings['linewidth']),\\n antialiased=ast.literal_eval(plotSettings['antialiased']),\\n **plotSettings.get('attributes', {}))\\n ########################\\n # TRI-SURFACE PLOT #\\n ########################\\n elif self.outStreamTypes[pltIndex] == 'tri-surface':\\n if self.dim == 2:\\n self.raiseAWarning('TRI-surface Plot is NOT available for 2D plots, it is 3D!')\\n return\\n else:\\n if 'color' not in plotSettings:\\n plotSettings['color'] = 'b'\\n if 'shade' not in plotSettings:\\n plotSettings['shade'] = 'False'\\n for key in self.xValues[pltIndex]:\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n # Hopefully, x,y, and z are all the same length, so checking this\\n # here should be good enough.\\n # The problem is you cannot interpolate any amount of space if\\n # you only have a single data point.\\n if self.xValues[pltIndex][key][xIndex].size == 1:\\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\\n continue\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n for zIndex in range(len(self.zValues[pltIndex][key])):\\n metric = (self.xValues[pltIndex][key][xIndex] ** 2 + self.yValues[pltIndex][key][yIndex] ** 2) ** 0.5\\n metricIndeces = np.argsort(metric)\\n xs = np.zeros(self.xValues[pltIndex][key][xIndex].shape)\\n ys = np.zeros(self.yValues[pltIndex][key][yIndex].shape)\\n zs = np.zeros(self.zValues[pltIndex][key][zIndex].shape)\\n for sindex in range(len(metricIndeces)):\\n xs[sindex] = self.xValues[pltIndex][key][xIndex][metricIndeces[sindex]]\\n ys[sindex] = self.yValues[pltIndex][key][yIndex][metricIndeces[sindex]]\\n zs[sindex] = self.zValues[pltIndex][key][zIndex][metricIndeces[sindex]]\\n surfacePlotOptions = {'color': plotSettings['color'],\\n 'shade': ast.literal_eval(plotSettings['shade'])}\\n surfacePlotOptions.update(plotSettings.get('attributes', {}))\\n if self.zValues[pltIndex][key][zIndex].size <= 3:\\n return\\n if self.colorMapCoordinates[pltIndex] is not None:\\n if self.actcm:\\n first = False\\n else:\\n first = True\\n if plotSettings['cmap'] == 'None':\\n plotSettings['cmap'] = 'jet'\\n surfacePlotOptions['cmap'] = matplotlib.cm.get_cmap(name = plotSettings['cmap'])\\n self.actPlot = self.ax.plot_trisurf(xs, ys, zs, **surfacePlotOptions)\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n if first:\\n self.actPlot.cmap = matplotlib.cm.get_cmap(name=plotSettings['cmap'])\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_array(self.colorMapValues[pltIndex][key])\\n self.actcm = self.fig.colorbar(m)\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_clim(vmin=min(self.colorMapValues[pltIndex][key][-1]), vmax=max(self.colorMapValues[pltIndex][key][-1]))\\n self.actcm.draw_all()\\n else:\\n if plotSettings['cmap'] != 'None':\\n surfacePlotOptions[\\\"cmap\\\"] = matplotlib.cm.get_cmap(name=plotSettings['cmap'])\\n self.actPlot = self.ax.plot_trisurf(xs, ys, zs, **surfacePlotOptions)\\n ########################\\n # WIREFRAME PLOT #\\n ########################\\n elif self.outStreamTypes[pltIndex] == 'wireframe':\\n if self.dim == 2:\\n self.raiseAWarning('wireframe Plot is NOT available for 2D plots, IT IS A 3D!')\\n return\\n else:\\n if 'rstride' not in plotSettings:\\n plotSettings['rstride'] = '1'\\n if 'cstride' not in plotSettings:\\n plotSettings['cstride'] = '1'\\n for key in self.xValues[pltIndex]:\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n # Hopefully, x,y, and z are all the same length, so checking this\\n # here should be good enough.\\n # The problem is you cannot interpolate any amount of space if\\n # you only have a single data point.\\n if self.xValues[pltIndex][key][xIndex].size == 1:\\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\\n continue\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n for zIndex in range(len(self.zValues[pltIndex][key])):\\n if self.zValues[pltIndex][key][zIndex].size <= 3:\\n return\\n if self.colorMapCoordinates[pltIndex] is not None:\\n xig, yig, Ci = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n plotSettings,\\n z=self.colorMapValues[pltIndex][key][zIndex],\\n returnCoordinate=True)\\n xig, yig, zi = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n plotSettings,\\n z=self.zValues[pltIndex][key][zIndex],\\n returnCoordinate=True)\\n if self.colorMapCoordinates[pltIndex] is not None:\\n self.raiseAWarning(f'Currently, ax.plot_wireframe() in MatPlotLib version: {matplotlib.__version__} does not support a colormap! Wireframe plotted on a surface plot...')\\n if self.actcm:\\n first = False\\n else:\\n first = True\\n if plotSettings['cmap'] == 'None':\\n plotSettings['cmap'] = 'jet'\\n self.actPlot = self.ax.plot_wireframe(xig,\\n yig,\\n ma.masked_where(np.isnan(zi), zi),\\n rstride=ast.literal_eval(plotSettings['rstride']),\\n cmap=matplotlib.cm.get_cmap(name = plotSettings['cmap']),\\n cstride=ast.literal_eval(plotSettings['cstride']),\\n **plotSettings.get('attributes', {}))\\n self.actPlot = self.ax.plot_surface(xig,\\n yig,\\n ma.masked_where(np.isnan(zi), zi),\\n alpha=0.4,\\n rstride=ast.literal_eval(plotSettings['rstride']),\\n cmap=matplotlib.cm.get_cmap(name=plotSettings['cmap']),\\n cstride=ast.literal_eval(plotSettings['cstride']),\\n **plotSettings.get('attributes', {}))\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n if first:\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_array(self.colorMapValues[pltIndex][key])\\n self.actcm = self.fig.colorbar(m)\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_clim(vmin=min(self.colorMapValues[pltIndex][key][-1]), vmax=max(self.colorMapValues[pltIndex][key][-1]))\\n self.actcm.draw_all()\\n else:\\n if plotSettings['cmap'] == 'None':\\n self.actPlot = self.ax.plot_wireframe(xig,\\n yig,\\n ma.masked_where(np.isnan(zi), zi),\\n rstride=ast.literal_eval(plotSettings['rstride']),\\n cstride=ast.literal_eval(plotSettings['cstride']),\\n **plotSettings.get('attributes', {}))\\n if 'color' in plotSettings.get('attributes', {}):\\n self.actPlot.set_color = plotSettings.get('attributes', {})['color']\\n else:\\n self.actPlot.set_color = 'blue'\\n else:\\n self.actPlot = self.ax.plot_wireframe(xig,\\n yig,\\n ma.masked_where(np.isnan(zi), zi),\\n rstride=ast.literal_eval(plotSettings['rstride']),\\n cstride=ast.literal_eval(plotSettings['cstride']),\\n **plotSettings.get('attributes', {}))\\n ########################\\n # CONTOUR PLOT #\\n ########################\\n elif self.outStreamTypes[pltIndex] == 'contour' or self.outStreamTypes[pltIndex] == 'filledContour':\\n if self.dim == 2:\\n if 'numberBins' in plotSettings:\\n nbins = int(plotSettings['numberBins'])\\n else:\\n nbins = 5\\n for key in self.xValues[pltIndex]:\\n if not self.colorMapCoordinates:\\n self.raiseAWarning(self.outStreamTypes[pltIndex] + ' Plot needs coordinates for color map... Returning without plotting')\\n return\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n # Hopefully, x,y, and z are all the same length, so checking this\\n # here should be good enough.\\n # The problem is you cannot interpolate any amount of space if\\n # you only have a single data point.\\n if self.xValues[pltIndex][key][xIndex].size == 1:\\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\\n continue\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n for zIndex in range(len(self.colorMapValues[pltIndex][key])):\\n if self.actcm:\\n first = False\\n else:\\n first = True\\n xig, yig, Ci = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n plotSettings,\\n z=self.colorMapValues[pltIndex][key][zIndex],\\n returnCoordinate=True)\\n if self.outStreamTypes[pltIndex] == 'contour':\\n if plotSettings['cmap'] == 'None':\\n if 'color' in plotSettings.get('attributes', {}):\\n color = plotSettings.get('attributes', {})['color']\\n else:\\n color = 'blue'\\n self.actPlot = self.ax.contour(xig,\\n yig,\\n ma.masked_where(np.isnan(Ci), Ci),\\n nbins,\\n colors=color,\\n **plotSettings.get('attributes', {}))\\n else:\\n self.actPlot = self.ax.contour(xig,\\n yig,\\n ma.masked_where(np.isnan(Ci), Ci),\\n nbins,\\n **plotSettings.get('attributes', {}))\\n else:\\n if plotSettings['cmap'] == 'None':\\n plotSettings['cmap'] = 'jet'\\n self.actPlot = self.ax.contourf(xig,\\n yig,\\n ma.masked_where(np.isnan(Ci), Ci),\\n nbins,\\n **plotSettings.get('attributes', {}))\\n self.ax.clabel(self.actPlot, inline=1, fontsize=10)\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n if first:\\n self.actcm = self.fig.colorbar(self.actPlot, shrink=0.8, extend='both')\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n m = matplotlib.cm.ScalarMappable(cmap = self.actPlot.cmap, norm = self.actPlot.norm)\\n m.set_clim(vmin = min(self.colorMapValues[pltIndex][key][-1]), vmax = max(self.colorMapValues[pltIndex][key][-1]))\\n self.actcm.draw_all()\\n else:\\n self.raiseAWarning('contour/filledContour is a 2-D plot, where x,y are the surface coordinates and colorMap vector is the array to visualize!\\\\n contour3D/filledContour3D are 3-D! ')\\n return\\n # These should be combined: ^^^ & vvv\\n elif self.outStreamTypes[pltIndex] == 'contour3D' or self.outStreamTypes[pltIndex] == 'filledContour3D':\\n if self.dim == 2:\\n self.raiseAWarning('contour3D/filledContour3D Plot is NOT available for 2D plots, IT IS A 2D! Check \\\"contour/filledContour\\\"!')\\n return\\n else:\\n if 'numberBins' in plotSettings:\\n nbins = int(plotSettings['numberBins'])\\n else:\\n nbins = 5\\n if 'extend3D' in plotSettings:\\n ext3D = bool(plotSettings['extend3D'])\\n else:\\n ext3D = False\\n for key in self.xValues[pltIndex]:\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n # Hopefully, x,y, and z are all the same length, so checking this\\n # here should be good enough.\\n # The problem is you cannot interpolate any amount of space if\\n # you only have a single data point.\\n if self.xValues[pltIndex][key][xIndex].size == 1:\\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\\n continue\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n for zIndex in range(len(self.colorMapValues[pltIndex][key])):\\n if self.actcm:\\n first = False\\n else:\\n first = True\\n xig, yig, Ci = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n plotSettings,\\n z=self.colorMapValues[pltIndex][key][zIndex],\\n returnCoordinate=True)\\n if self.outStreamTypes[pltIndex] == 'contour3D':\\n if plotSettings['cmap'] == 'None':\\n if 'color' in plotSettings.get('attributes', {}):\\n color = plotSettings.get('attributes', {})['color']\\n else:\\n color = 'blue'\\n self.actPlot = self.ax.contour3D(xig,\\n yig,\\n ma.masked_where(np.isnan(Ci), Ci),\\n nbins,\\n colors=color,\\n extend3d=ext3D,\\n **plotSettings.get('attributes', {}))\\n else:\\n self.actPlot = self.ax.contour3D(xig,\\n yig,\\n ma.masked_where(np.isnan(Ci), Ci),\\n nbins,\\n extend3d=ext3D,\\n cmap=matplotlib.cm.get_cmap(name=plotSettings['cmap']),\\n **plotSettings.get('attributes', {}))\\n else:\\n if plotSettings['cmap'] == 'None':\\n plotSettings['cmap'] = 'jet'\\n self.actPlot = self.ax.contourf3D(xig,\\n yig,\\n ma.masked_where(np.isnan(Ci), Ci),\\n nbins,\\n cmap=matplotlib.cm.get_cmap(name=plotSettings['cmap']),\\n **plotSettings.get('attributes', {}))\\n self.ax.clabel(self.actPlot, inline=1, fontsize=10)\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n if first:\\n self.actcm = self.fig.colorbar(self.actPlot, shrink = 0.8, extend = 'both')\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n m = matplotlib.cm.ScalarMappable(cmap = self.actPlot.cmap, norm = self.actPlot.norm)\\n m.set_clim(vmin = min(self.colorMapValues[pltIndex][key][-1]), vmax = max(self.colorMapValues[pltIndex][key][-1]))\\n self.actcm.draw_all()\\n ########################\\n # DataMining PLOT #\\n ########################\\n elif self.outStreamTypes[pltIndex] == 'dataMining':\\n colors = cycle(['#88CCEE', '#DDCC77', '#AA4499', '#117733', '#332288', '#999933', '#44AA99', '#882255', '#CC6677', '#CD6677', '#DC6877', '#886677', '#AA6677', '#556677', '#CD7865'])\\n if 's' not in plotSettings:\\n plotSettings['s'] = '20'\\n if 'c' not in plotSettings:\\n plotSettings['c'] = 'b'\\n if 'marker' not in plotSettings:\\n plotSettings['marker'] = 'o'\\n if 'alpha' not in plotSettings:\\n plotSettings['alpha'] = 'None'\\n if 'linewidths' not in plotSettings:\\n plotSettings['linewidths'] = 'None'\\n clusterDict[pltIndex] = {}\\n for key in self.xValues[pltIndex]:\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n dataMiningPlotOptions = {'s': ast.literal_eval(plotSettings['s']),\\n 'marker': (plotSettings['marker']),\\n 'alpha': ast.literal_eval(plotSettings['alpha']),\\n 'linewidths': ast.literal_eval(plotSettings['linewidths'])}\\n if self.colorMapCoordinates[pltIndex] is not None:\\n self.raiseAWarning('ColorMap values supplied, however DataMining plots do not use colorMap from input.')\\n if plotSettings['cmap'] == 'None':\\n self.raiseAWarning('ColorSet supplied, however DataMining plots do not use color set from input.')\\n if 'cluster' == plotSettings['SKLtype']:\\n # TODO: include the cluster Centers to the plot\\n if 'noClusters' in plotSettings.get('attributes', {}):\\n clusterDict[pltIndex]['noClusters'] = int(plotSettings.get('attributes', {})['noClusters'])\\n plotSettings.get('attributes', {}).pop('noClusters')\\n else:\\n clusterDict[pltIndex]['noClusters'] = np.amax(self.clusterValues[pltIndex][1][0]) + 1\\n dataMiningPlotOptions.update(plotSettings.get('attributes', {}))\\n if self.dim == 2:\\n clusterDict[pltIndex]['clusterValues'] = np.zeros(shape=(len(self.xValues[pltIndex][key][xIndex]), 2))\\n else:\\n clusterDict[pltIndex]['clusterValues'] = np.zeros(shape=(len(self.xValues[pltIndex][key][xIndex]), 3))\\n clusterDict[pltIndex]['clusterValues'][:, 0] = self.xValues[pltIndex][key][xIndex]\\n clusterDict[pltIndex]['clusterValues'][:, 1] = self.yValues[pltIndex][key][yIndex]\\n if self.dim == 2:\\n for k, col in zip(range(int(clusterDict[pltIndex]['noClusters'])), colors):\\n myMembers = self.clusterValues[pltIndex][1][0] == k\\n self.actPlot = self.ax.scatter(clusterDict[pltIndex]['clusterValues'][myMembers, 0],\\n clusterDict[pltIndex]['clusterValues'][myMembers, 1],\\n color=col,\\n **dataMiningPlotOptions)\\n\\n # Handle all of the outlying data\\n myMembers = self.clusterValues[pltIndex][1][0] == -1\\n # resize the points\\n dataMiningPlotOptions['s'] /= 2\\n # and hollow out their markers\\n if 'facecolors' in dataMiningPlotOptions:\\n faceColors = dataMiningPlotOptions['facecolors']\\n else:\\n faceColors = None\\n dataMiningPlotOptions['facecolors'] = 'none'\\n\\n self.actPlot = self.ax.scatter(clusterDict[pltIndex]['clusterValues'][myMembers, 0],\\n clusterDict[pltIndex]['clusterValues'][myMembers, 1],\\n color='#000000',\\n **dataMiningPlotOptions)\\n\\n # Restore the plot options to their original values\\n dataMiningPlotOptions['s'] *= 2\\n if faceColors is not None:\\n dataMiningPlotOptions['facecolors'] = faceColors\\n else:\\n del dataMiningPlotOptions['facecolors']\\n\\n else:\\n for zIndex in range(len(self.zValues[pltIndex][key])):\\n clusterDict[pltIndex]['clusterValues'][:, 2] = self.zValues[pltIndex][key][zIndex]\\n for k, col in zip(range(int(clusterDict[pltIndex]['noClusters'])), colors):\\n myMembers = self.clusterValues[pltIndex][1][0] == k\\n self.actPlot = self.ax.scatter(clusterDict[pltIndex]['clusterValues'][myMembers, 0],\\n clusterDict[pltIndex]['clusterValues'][myMembers, 1],\\n clusterDict[pltIndex]['clusterValues'][myMembers, 2],\\n color=col,\\n **dataMiningPlotOptions)\\n\\n # Handle all of the outlying data\\n myMembers = self.clusterValues[pltIndex][1][0] == -1\\n # resize the points\\n dataMiningPlotOptions['s'] /= 2\\n # and hollow out their markers\\n if 'facecolors' in dataMiningPlotOptions:\\n faceColors = dataMiningPlotOptions['facecolors']\\n else:\\n faceColors = None\\n dataMiningPlotOptions['facecolors'] = 'none'\\n\\n self.actPlot = self.ax.scatter(clusterDict[pltIndex]['clusterValues'][myMembers, 0],\\n clusterDict[pltIndex]['clusterValues'][myMembers, 1],\\n clusterDict[pltIndex]['clusterValues'][myMembers, 2],\\n color='#000000',\\n **dataMiningPlotOptions)\\n\\n # Restore the plot options to their original values\\n dataMiningPlotOptions['s'] *= 2\\n if faceColors is not None:\\n dataMiningPlotOptions['facecolors'] = faceColors\\n else:\\n del dataMiningPlotOptions['facecolors']\\n\\n elif 'bicluster' == plotSettings['SKLtype']:\\n self.raiseAnError(IOError, 'SKLType Bi-Cluster Plots are not implemented yet!..')\\n elif 'mixture' == plotSettings['SKLtype']:\\n if 'noMixtures' in plotSettings.get('attributes', {}):\\n clusterDict[pltIndex]['noMixtures'] = int(plotSettings.get('attributes', {})['noMixtures'])\\n plotSettings.get('attributes', {}).pop('noMixtures')\\n else:\\n clusterDict[pltIndex]['noMixtures'] = np.amax(self.mixtureValues[pltIndex][1][0]) + 1\\n if self.dim == 3:\\n self.raiseAnError(IOError, 'SKLType Mixture Plots are only available in 2-Dimensions')\\n else:\\n clusterDict[pltIndex]['mixtureValues'] = np.zeros(shape = (len(self.xValues[pltIndex][key][xIndex]), 2))\\n clusterDict[pltIndex]['mixtureValues'][:, 0] = self.xValues[pltIndex][key][xIndex]\\n clusterDict[pltIndex]['mixtureValues'][:, 1] = self.yValues[pltIndex][key][yIndex]\\n if 'mixtureCovars' in plotSettings.get('attributes', {}):\\n split = self.__splitVariableNames('mixtureCovars', (pltIndex, 0))\\n # mixtureCovars = self.sourceData[pltIndex].getParam(split[1], split[2], nodeId = 'ending')\\n plotSettings.get('attributes', {}).pop('mixtureCovars')\\n # else:\\n # mixtureCovars = None\\n if 'mixtureMeans' in plotSettings.get('attributes', {}):\\n split = self.__splitVariableNames('mixtureMeans', (pltIndex, 0))\\n # mixtureMeans = self.sourceData[pltIndex].getParam(split[1], split[2], nodeId = 'ending')\\n plotSettings.get('attributes', {}).pop('mixtureMeans')\\n # else:\\n # mixtureMeans = None\\n # mixtureCovars.reshape(3, 4)\\n # mixtureMeans.reshape(3, 4)\\n # for i, (mean, covar, col) in enumerate(zip(mixtureMeans, mixtureCovars, colors)):\\n for i, col in zip(range(clusterDict[pltIndex]['noMixtures']), colors):\\n if not np.any(self.mixtureValues[pltIndex][1][0] == i):\\n continue\\n myMembers = self.mixtureValues[pltIndex][1][0] == i\\n self.actPlot = self.ax.scatter(clusterDict[pltIndex]['mixtureValues'][myMembers, 0],\\n clusterDict[pltIndex]['mixtureValues'][myMembers, 1],\\n color=col,\\n **dataMiningPlotOptions)\\n elif 'manifold' == plotSettings['SKLtype']:\\n if self.dim == 2:\\n manifoldValues = np.zeros(shape=(len(self.xValues[pltIndex][key][xIndex]), 2))\\n else:\\n manifoldValues = np.zeros(shape=(len(self.xValues[pltIndex][key][xIndex]), 3))\\n manifoldValues[:, 0] = self.xValues[pltIndex][key][xIndex]\\n manifoldValues[:, 1] = self.yValues[pltIndex][key][yIndex]\\n if 'clusterLabels' in plotSettings.get('attributes', {}):\\n split = self.__splitVariableNames('clusterLabels', (pltIndex, 0))\\n clusterDict[pltIndex]['clusterLabels'] = self.sourceData[pltIndex].getParam(split[1], split[2], nodeId = 'ending')\\n plotSettings.get('attributes', {}).pop('clusterLabels')\\n else:\\n clusterDict[pltIndex]['clusterLabels'] = None\\n if 'noClusters' in plotSettings.get('attributes', {}):\\n clusterDict[pltIndex]['noClusters'] = int(plotSettings.get('attributes', {})['noClusters'])\\n plotSettings.get('attributes', {}).pop('noClusters')\\n else:\\n clusterDict[pltIndex]['noClusters'] = np.amax(self.clusterValues[pltIndex][1][0]) + 1\\n if self.clusterValues[pltIndex][1][0] is not None:\\n if self.dim == 2:\\n for k, col in zip(range(clusterDict[pltIndex]['noClusters']), colors):\\n myMembers = self.clusterValues[pltIndex][1][0] == k\\n self.actPlot = self.ax.scatter(manifoldValues[myMembers, 0],\\n manifoldValues[myMembers, 1],\\n color=col,\\n **dataMiningPlotOptions)\\n else:\\n for zIndex in range(len(self.zValues[pltIndex][key])):\\n manifoldValues[:, 2] = self.zValues[pltIndex][key][zIndex]\\n for k, col in zip(range(clusterDict[pltIndex]['noClusters']), colors):\\n myMembers = self.clusterValues[pltIndex][1][0] == k\\n self.actPlot = self.ax.scatter(manifoldValues[myMembers, 0],\\n manifoldValues[myMembers, 1],\\n manifoldValues[myMembers, 2],\\n color=col,\\n **dataMiningPlotOptions)\\n else:\\n if self.dim == 2:\\n self.actPlot = self.ax.scatter(manifoldValues[:, 0],\\n manifoldValues[:, 1],\\n **dataMiningPlotOptions)\\n else:\\n for zIndex in range(len(self.zValues[pltIndex][key])):\\n manifoldValues[:, 2] = self.zValues[pltIndex][key][zIndex]\\n self.actPlot = self.ax.scatter(manifoldValues[:, 0],\\n manifoldValues[:, 1],\\n manifoldValues[:, 2],\\n **dataMiningPlotOptions)\\n elif 'decomposition' == plotSettings['SKLtype']:\\n if self.dim == 2:\\n decompositionValues = np.zeros(shape = (len(self.xValues[pltIndex][key][xIndex]), 2))\\n else:\\n decompositionValues = np.zeros(shape = (len(self.xValues[pltIndex][key][xIndex]), 3))\\n decompositionValues[:, 0] = self.xValues[pltIndex][key][xIndex]\\n decompositionValues[:, 1] = self.yValues[pltIndex][key][yIndex]\\n if 'noClusters' in plotSettings.get('attributes', {}):\\n clusterDict[pltIndex]['noClusters'] = int(plotSettings.get('attributes', {})['noClusters'])\\n plotSettings.get('attributes', {}).pop('noClusters')\\n else:\\n clusterDict[pltIndex]['noClusters'] = np.amax(self.clusterValues[pltIndex][1][0]) + 1\\n if self.clusterValues[pltIndex][1][0] is not None:\\n if self.dim == 2:\\n for k, col in zip(range(clusterDict[pltIndex]['noClusters']), colors):\\n myMembers = self.clusterValues[pltIndex][1][0] == k\\n self.actPlot = self.ax.scatter(decompositionValues[myMembers, 0],\\n decompositionValues[myMembers, 1],\\n color=col,\\n **dataMiningPlotOptions)\\n else:\\n for zIndex in range(len(self.zValues[pltIndex][key])):\\n decompositionValues[:, 2] = self.zValues[pltIndex][key][zIndex]\\n for k, col in zip(range(clusterDict[pltIndex]['noClusters']), colors):\\n myMembers = self.clusterValues[pltIndex][1][0] == k\\n self.actPlot = self.ax.scatter(decompositionValues[myMembers, 0],\\n decompositionValues[myMembers, 1],\\n decompositionValues[myMembers, 2],\\n color=col,\\n **dataMiningPlotOptions)\\n else:\\n # no ClusterLabels\\n if self.dim == 2:\\n self.actPlot = self.ax.scatter(decompositionValues[:, 0],\\n decompositionValues[:, 1],\\n **dataMiningPlotOptions)\\n else:\\n for zIndex in range(len(self.zValues[pltIndex][key])):\\n decompositionValues[:, 2] = self.zValues[pltIndex][key][zIndex]\\n self.actPlot = self.ax.scatter(decompositionValues[:, 0],\\n decompositionValues[:, 1],\\n decompositionValues[:, 2],\\n **dataMiningPlotOptions)\\n else:\\n # Let's try to \\\"write\\\" the code for the plot on the fly\\n self.raiseAWarning('Trying to create a non-predefined plot of type ' + self.outStreamTypes[pltIndex] + '. If this fails, please refer to the and/or the related matplotlib method specification.')\\n kwargs = {}\\n for kk in plotSettings:\\n if kk != 'attributes' and kk != self.outStreamTypes[pltIndex]:\\n try:\\n kwargs[kk] = ast.literal_eval(plotSettings[kk])\\n except ValueError:\\n kwargs[kk] = plotSettings[kk]\\n try:\\n if self.dim == 2:\\n customFunctionCall = getattr(self.ax, self.outStreamTypes[pltIndex])\\n else:\\n customFunctionCall = getattr(self.ax, self.outStreamTypes[pltIndex])\\n self.actPlot = customFunctionCall(**kwargs)\\n except AttributeError as ae:\\n self.raiseAnError(RuntimeError, '<' + str(ae) + '> -> in execution custom plot \\\"' + self.outStreamTypes[pltIndex] + '\\\" in Plot ' + self.name + '.\\\\nSTREAM MANAGER: ERROR -> command has been called in the following way: ' + 'ax.' + self.outStreamTypes[pltIndex])\\n\\n if 'legend' in self.options['plotSettings']:\\n self.fig.legend(**self.options['plotSettings']['legend'])\\n\\n # SHOW THE PICTURE\\n self.__executeActions()\\n self.fig.canvas.draw_idle()\\n\\n if 'screen' in self.destinations and display:\\n def handle_close(event):\\n \\\"\\\"\\\"\\n This method is aimed to handle the closing of figures (overall when in interactive mode)\\n @ In, event, instance, the event to close\\n @ Out, None\\n \\\"\\\"\\\"\\n self.fig.canvas.stop_event_loop()\\n self.raiseAMessage('Closed Figure')\\n self.fig.canvas.mpl_connect('close_event', handle_close)\\n # self.plt.pause(1e-6)\\n # The following code is extracted from pyplot.pause without actually\\n # needing to force the code to sleep, according to MPL's documentation,\\n # this feature is experimental, hopefully by not calling the pause\\n # function, we can obtain consistent results.\\n # We are skipping a few of the sanity checks done in that function,\\n # since we are sure we have an interactive backend and access to the\\n # correct type of canvas and figure.\\n self.fig.canvas.draw()\\n # If your graphs are unresponsive to user input, you may want to consider\\n # adjusting this timeout, to allow more time for the input to be handled.\\n self.fig.canvas.start_event_loop(1e-3)\\n\\n # self.fig.canvas.flush_events()\\n\\n for fileType in self.destinations:\\n if fileType == 'screen':\\n continue\\n\\n if not self.overwrite:\\n prefix = str(self.counter) + '-'\\n else:\\n prefix = ''\\n\\n if len(self.filename) > 0:\\n name = self.filename\\n else:\\n name = prefix + self.name + '_' + str(self.outStreamTypes).replace(\\\"'\\\", \\\"\\\").replace(\\\"[\\\", \\\"\\\").replace(\\\"]\\\", \\\"\\\").replace(\\\",\\\", \\\"-\\\").replace(\\\" \\\", \\\"\\\")\\n\\n if self.subDirectory is not None:\\n name = os.path.join(self.subDirectory,name)\\n\\n self.fig.savefig(name + '.' + fileType, format=fileType)\\n\\n if 'screen' not in self.destinations:\\n plt.close(fig=self.fig)\\n\\n gc.collect()\",\n \"def app_SN_last_24h_plots(self, dfs, phase_dirs, sizer_val, styler_val):\\n\\n print('Currently plotting con_last_24h_plots')\\n\\n for df, direc in zip(dfs, phase_dirs):\\n df = self.data_processor.create_24h_subset(df)\\n self.plotter.plot_SN_separate_temperature_series(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['06_last_24_hours'],\\n sizer=self.formatter.sizer[sizer_val]['1x1_full_width'],\\n styler=self.formatter.styler[styler_val],\\n xaxis_type='datetime',\\n last_day=True\\n )\\n self.plotter.plot_SN_separate_moisture_series(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['06_last_24_hours'],\\n sizer=self.formatter.sizer[sizer_val]['1x1_full_width'],\\n styler=self.formatter.styler[styler_val],\\n xaxis_type='datetime',\\n last_day=True\\n )\\n self.plotter.plot_SN_combined_temperature_series(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['06_last_24_hours'],\\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\\n styler=self.formatter.styler[styler_val],\\n xaxis_type='datetime',\\n last_day=True,\\n )\\n self.plotter.plot_SN_combined_moisture_series(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['06_last_24_hours'],\\n sizer=self.formatter.sizer[sizer_val]['3x1_full_width'],\\n styler=self.formatter.styler[styler_val],\\n xaxis_type='datetime',\\n last_day=True,\\n )\\n\\n print('Done\\\\n')\",\n \"def plot_folder(path):\\r\\n plt.figure(figsize=(20, 10))\\r\\n for filename in glob.glob(path + '/*.pspec'):\\r\\n x, y= np.loadtxt(fname=filename, delimiter='\\\\t',dtype=int, usecols = (1,2),\\r\\n skiprows=100, unpack = True)\\r\\n plt.plot(x, y)\\r\\n return plt.show()\",\n \"def check_plots(tracklist_subset, tracklist):\\n\\n for trial in tracklist_subset: # Iterates over all available trials\\n\\n # Scale time for colormap\\n scaled_time = (tracklist[trial]['data'].index.values -\\n tracklist[trial]['data'].index.values.min()) / \\\\\\n tracklist[trial]['data'].index.values.ptp()\\n timemax = max(tracklist[trial]['data'].index.values)\\n data = tracklist[trial]['data']\\n colors = plt.cm.cubehelix(scaled_time)\\n m = cm.ScalarMappable(cmap=cm.cubehelix)\\n m.set_array(tracklist[trial]['data'].index.values)\\n\\n # filename = str(trial) + '.pdf'\\n\\n fig = plt.figure(figsize=(20, 20))\\n fig.suptitle(tracklist[trial]['sequence'] + ' ' +\\n tracklist[trial]['behavior'])\\n\\n ax1 = fig.add_subplot(4, 2, 1, projection='3d')\\n ax1.set_title('Pt 1 Position')\\n ax1.scatter3D(xs=tracklist[trial]['data']['pt1x_smth'],\\n ys=tracklist[trial]['data']['pt1y_smth'],\\n zs=tracklist[trial]['data']['pt1z_smth'],\\n zdir='z', s=3, c=colors, marker='o',\\n edgecolor='none') # 3D Scatter plot\\n ax1.autoscale(enable=True, tight=True)\\n ax1.set_xlabel('X position')\\n ax1.set_ylabel('Y position')\\n ax1.set_zlabel('Z position')\\n plt.colorbar(m, shrink=0.5, aspect=10)\\n\\n ax2 = fig.add_subplot(4, 2, 3)\\n ax2.plot(data.index.values, data['pt1y_v_smth'], 'bo')\\n ax2.set_ylabel('Y velocity (cm/s)', color='b')\\n ax2.tick_params('y', colors='b')\\n\\n ax3 = fig.add_subplot(4, 2, 5)\\n ax3.plot(data.index.values, data['pt1_net_v'], 'bo')\\n ax3.set_ylabel('Net Velocity (cm/s)', color='b')\\n ax3.tick_params('y', colors='b')\\n\\n ax4 = fig.add_subplot(4, 2, 7)\\n ax4.plot(data.index.values, data['pt1_net_a'], 'bo')\\n ax4.set_ylabel('Net accel (cm/s2)', color='b')\\n ax4.tick_params('y', colors='b')\\n\\n ax5 = fig.add_subplot(4, 2, 2, projection='3d')\\n ax5.set_title('Pt 2 Position')\\n ax5.scatter3D(xs=tracklist[trial]['data']['pt2x_smth'],\\n ys=tracklist[trial]['data']['pt2y_smth'],\\n zs=tracklist[trial]['data']['pt2z_smth'],\\n zdir='z', s=3, c=colors, marker='o',\\n edgecolor='none') # 3D Scatter plot\\n ax5.autoscale(enable=True, tight=True)\\n ax5.set_xlabel('X position')\\n ax5.set_ylabel('Y position')\\n ax5.set_zlabel('Z position')\\n plt.colorbar(m, shrink=0.5, aspect=10)\\n\\n ax6 = fig.add_subplot(4, 2, 4)\\n ax6.plot(data.index.values, data['pt2y_v_smth'], 'bo')\\n ax6.set_ylabel('Y velocity (cm/s)', color='b')\\n ax6.tick_params('y', colors='b')\\n\\n ax7 = fig.add_subplot(4, 2, 6)\\n ax7.plot(data.index.values, data['pt2_net_v'], 'bo')\\n ax7.set_ylabel('Net Velocity (cm/s)', color='b')\\n ax7.tick_params('y', colors='b')\\n\\n ax8 = fig.add_subplot(4, 2, 8)\\n ax8.plot(data.index.values, data['pt2_net_a'], 'bo')\\n ax8.set_ylabel('Net accel (cm/s2)', color='b')\\n ax8.tick_params('y', colors='b')\\n\\n plt.show()\",\n \"def viz(inpath, outpath='sample/', save_fig=False):\\n for sub_dir in os.listdir(inpath):\\n dir = os.path.join(inpath, sub_dir)\\n out_dir = os.path.join(outpath, sub_dir)\\n frame_list = os.listdir(dir)\\n frame_list = [frame for frame in frame_list if frame.endswith('.png')]\\n for frame in frame_list:\\n imgpath = os.path.join(dir, frame)\\n kp_path = dir + frame[0:4] + '_joint2D.txt'\\n kp = read_kp(kp_path)\\n img = cv2.imread(imgpath)\\n plothand(img, kp)\\n if save_fig:\\n if not os.path.exists(out_dir):\\n os.makedirs(out_dir, exist_ok=True)\\n cv2.imwrite(os.path.join(outpath, frame[0:4]+'.jpg'), img)\\n else:\\n cv2.imshow(frame, img)\",\n \"def save_dataset_visual(lines, output_dir):\\n\\n # Ensure output directory exists\\n if not os.path.exists(output_dir):\\n os.makedirs(output_dir)\\n\\n cols = 3\\n rows = 3\\n fig_size = (7 * cols, 4 * rows) # Figure width and height, in inches\\n # Random sample of images\\n save_name = \\\"training_data_sample.png\\\"\\n fig, ax = plt.subplots(rows, cols, figsize=fig_size)\\n for row in range(rows):\\n for col in range(cols):\\n idx = np.random.randint(0, len(lines))\\n ax[row, col].imshow(ndimage.imread(lines[idx][0]))\\n ax[row, col].set_title(\\\"Angle = \\\" + str(round(lines[idx][1], 3)))\\n plt.savefig(output_dir + save_name, bbox_inches='tight')\\n # Distribution of steering angles\\n save_name = \\\"data_histogram.png\\\"\\n fig_size = (5, 3) # Figure width and height, in inches\\n num_bins = 100\\n angles = np.array([line[1] for line in lines])\\n hist, bins = np.histogram(angles, bins=num_bins)\\n fig = plt.figure(figsize=fig_size)\\n plt.bar(bins[:-1], hist)\\n plt.xlabel(\\\"Steering Angle\\\")\\n plt.ylabel(\\\"Frequency\\\")\\n plt.title(\\\"Distribution of Steering Angles in Training Data\\\")\\n plt.savefig(output_dir + save_name, bbox_inches='tight')\",\n \"def Diagnostic_plot3(self):\\n\\n floc = glob.glob('/home/mxs191/Desktop/MathewSchofield/TRG/DetTest/DetTest1_results/Info2Save/*.csv')\\n fig = plt.figure()\\n plt.rc('font', size=18)\\n #fig, ax = generalPlot(xaxis=r'$\\\\nu / \\\\mu$Hz', yaxis=r'$P_{\\\\rm det}$')\\n gs = gridspec.GridSpec(1, 2, width_ratios=(4,1))\\n ax = fig.add_subplot(gs[0])\\n\\n for idx, i in enumerate(floc):\\n\\n d = pd.read_csv(i)\\n\\n if idx == 0:\\n fullpdet = d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']]\\n else:\\n fullpdet = pd.concat([ fullpdet,\\\\\\n d[['f0', 'Pdet_Kepler', 'Pdet_TESS365', 'Pdet_TESS27']] ])\\n\\n plt.scatter(d['f0'], d['Pdet_Kepler'], color='b',\\\\\\n label=r\\\"$\\\\rm Kepler - 4\\\\ yrs$\\\" if idx == 0 else '')\\n plt.scatter(d['f0'], d['Pdet_TESS365'], color='orange',\\\\\\n label=r'$\\\\rm TESS - 1\\\\ yr$' if idx == 0 else '')\\n plt.scatter(d['f0'], d['Pdet_TESS27'], color='g',\\\\\\n label=r'$\\\\rm TESS - 27\\\\ days$' if idx == 0 else '')\\n\\n plt.axhline(fullpdet['Pdet_Kepler'].median(), color='b')\\n plt.axhline(fullpdet['Pdet_TESS365'].median(), color='orange')\\n plt.axhline(fullpdet['Pdet_TESS27'].median(), color='g')\\n ax.legend(loc='lower right')\\n plt.ylim([0,1])\\n ax.set_ylabel(r'$P_{\\\\rm det}$')\\n ax.set_xlabel(r'$\\\\nu / \\\\mu \\\\rm Hz$')\\n\\n bx = fig.add_subplot(gs[1])\\n import seaborn as sns\\n bw = 0.4\\n sns.kdeplot(fullpdet['Pdet_Kepler'].values, shade=True, vertical=True, \\\\\\n ax=bx, color='b', bw=bw)\\n sns.kdeplot(fullpdet['Pdet_TESS365'].values, shade=True, vertical=True, \\\\\\n ax=bx, color='orange', bw=bw)\\n sns.kdeplot(fullpdet['Pdet_TESS27'].values, shade=True, vertical=True, \\\\\\n ax=bx, color='g', bw=bw)\\n bx.set_ylim([0.0,1.0])\\n bx.set_xticks([])\\n bx.set_yticks([])\\n bx.set_xlabel(r'$\\\\rm Density$')\\n plt.tight_layout()\\n\\n plt.show()\\n fig.savefig(os.getcwd() + os.sep + 'DetTest1_plots' + os.sep +\\\\\\n 'DetTest_Diagnostic_plot3.pdf')\\n sys.exit()\",\n \"def plot_results(path: Path, output_dir: Path, skip: int = 100) -> Path:\\n with xr.open_dataset(path) as ds:\\n lons = ds.lon.values\\n lats = ds.lat.values\\n status = ds.status.values\\n stranded_flag = get_stranded_flag_from_status(ds)\\n\\n _ = plt.figure(figsize=(10, 10))\\n ax = plt.axes(projection=ccrs.PlateCarree(central_longitude=180))\\n ax.set_extent(\\n [-210, -140, 45, 75],\\n crs=ccrs.PlateCarree()\\n )\\n nparticles = len(lons)\\n if nparticles > skip:\\n iter_particles = np.arange(0, nparticles, skip)\\n else:\\n iter_particles = np.arange(0, nparticles)\\n\\n for particle in iter_particles:\\n # Create mask for stranded or not moving particles\\n mask = np.logical_and(\\n status[particle, :] <= 1,\\n status[particle, :] >= 0\\n )\\n # Cannot save figure if you plot something that is completely masked\\n # Cartopy will raise an error on save\\n if not np.any(mask):\\n continue\\n ax.plot(\\n lons[particle, mask],\\n lats[particle, mask],\\n color='g',\\n transform=ccrs.PlateCarree()\\n )\\n\\n # Starting position\\n ax.scatter(\\n ds.lon[particle, 0],\\n ds.lat[particle, 0],\\n c='b',\\n transform=ccrs.PlateCarree()\\n )\\n stranded_ix = ds.status[particle, :] == stranded_flag\\n\\n # Stranded particles\\n if np.any(stranded_ix):\\n ax.scatter(\\n ds.lon[particle, stranded_ix],\\n ds.lat[particle, stranded_ix],\\n c='r',\\n transform=ccrs.PlateCarree()\\n )\\n\\n ax.coastlines()\\n ax.add_feature(cartopy.feature.LAND.with_scale('110m'))\\n ax.gridlines(draw_labels=True)\\n\\n fname = path.name.replace('.nc', '.png')\\n outpath = output_dir / fname\\n\\n plt.tight_layout()\\n plt.savefig(outpath)\\n plt.close()\\n\\n return outpath\",\n \"def fig_4():\\n epoch = 3\\n N = 60000\\n Nr = N\\n K = 32\\n n_iter = 256\\n Nstar = 16\\n data = 'dr10'\\n factor = 100.\\n features = ['psf_mag', 'model_colors', 'psf_minus_model']\\n filters = ['r', 'ug gr ri iz', 'ugriz']\\n message = 'pm_mc_pmm_r_all_all'\\n model = 'xdmodel_%s_%d_%d_%d_%d_%s.pkl' % (data, Nr, K, n_iter, Nstar,\\n message)\\n model = os.environ['xddata'] + model\\n figname = os.environ['xdplots'] + 'fig4.png'\\n xx_plot(epoch, model, features, filters, figname)\",\n \"def plot_number_steps(step_cache_qlearning, step_cache_SARSA): \\n cum_step_q = []\\n steps_mean = np.array(step_cache_qlearning).mean()\\n steps_std = np.array(step_cache_qlearning).std()\\n count = 0 # used to determine the batches\\n cur_step = 0 # accumulate reward for the batch\\n for cache in step_cache_qlearning:\\n count = count + 1\\n cur_step += cache\\n if(count == 10):\\n # normalize the sample\\n normalized_step = (cur_step - steps_mean)/steps_std\\n cum_step_q.append(normalized_step)\\n cur_step = 0\\n count = 0\\n \\n cum_step_SARSA = []\\n steps_mean = np.array(step_cache_SARSA).mean()\\n steps_std = np.array(step_cache_SARSA).std()\\n count = 0 # used to determine the batches\\n cur_step = 0 # accumulate reward for the batch\\n for cache in step_cache_SARSA:\\n count = count + 1\\n cur_step += cache\\n if(count == 10):\\n # normalize the sample\\n normalized_step = (cur_step - steps_mean)/steps_std\\n cum_step_SARSA.append(normalized_step)\\n cur_step = 0\\n count = 0 \\n # prepare the graph \\n plt.plot(cum_step_q, label = \\\"q_learning\\\")\\n plt.plot(cum_step_SARSA, label = \\\"SARSA\\\")\\n plt.ylabel('Number of iterations')\\n plt.xlabel('Batches of Episodes (sample size 10) ')\\n plt.title(\\\"Q-Learning/SARSA Iteration number untill game ends\\\")\\n plt.legend(loc='lower right', ncol=2, mode=\\\"expand\\\", borderaxespad=0.)\\n plt.show()\\n plt.savefig('number_steps.png')\",\n \"def run(config, workdir, files, output=None, n=1):\\n file = None\\n for i in range(1, n+1):\\n Logger.info(f'Starting run {i}/{n}')\\n\\n if output:\\n file = f'{output}/run_{i}.dat'\\n\\n # Make sure these directories are clean\\n for file in glob(f'{workdir}/lut_h2o/*'):\\n os.remove(file)\\n for file in glob(f'{workdir}/output/*'):\\n os.remove(file)\\n\\n profile(\\n args = SimpleNamespace(\\n input_radiance = files[0],\\n input_loc = files[1],\\n input_obs = files[2],\\n working_directory = workdir,\\n config_file = config,\\n wavelength_path = None,\\n log_file = None,\\n logging_level = 'DEBUG',\\n pressure_elevation = None\\n ),\\n output = file\\n )\",\n \"def plot(self):\\n # Get data\\n #print(self.file_name)\\n fig, ax = plb.subplots(1,1,figsize=(18,20))\\n for key,value in self.testTrend.items():\\n x = np.arange(len(self.data_array))\\n y = np.asarray(value)\\n plb.plot(x,y, label=key)\\n ax.scatter(x, y)\\n for i in range(0, len(value)):\\n ax.annotate(str(i), (x[i], y[i]))\\n # Title\\n plb.title(self.file_name)\\n # Legend\\n plb.legend(bbox_to_anchor=(.05, 1), loc='best', borderaxespad=0.)\\n # x ticks\\n plb.xticks(np.arange(min(x), max(x) + 1, 2.0))\\n #plb.ylim(-250, 1)\\n # Show image\\n plb.show()\",\n \"def plot(\\n self,\\n output: Optional[str] = None,\\n max_plot_points: Optional[int] = None,\\n **kwargs,\\n ):\\n import matplotlib.pyplot as plt\\n\\n fig, axes = plt.subplots(\\n 1,\\n len(self._records),\\n figsize=(6 * len(self._records), 6),\\n constrained_layout=True,\\n )\\n if not isinstance(axes, np.ndarray):\\n # when only one record, axes is not a list, so wrap it\\n axes = [axes]\\n\\n plt_kwargs = dict(alpha=0.8, linewidth=1)\\n plt_kwargs.update(kwargs)\\n\\n for idx, record in enumerate(self._records):\\n axes[idx].plot(\\n *self._sample_points(record.floats(), max_len=max_plot_points),\\n **plt_kwargs,\\n )\\n axes[idx].set_ylabel(record.name)\\n axes[idx].set_xlabel('Steps')\\n\\n if output:\\n plt.savefig(output, bbox_inches='tight', pad_inches=0.1)\\n else:\\n plt.show()\",\n \"def show_data_files(self):\\n for idx in self.plot_data:\\n self.plot_data[idx].show()\",\n \"def comp2profile(output):\\n\\n # Load components\\n data = '/home/scott/data/insar/cvz/los2xyz/components.txt_backup'\\n lon,lat,x,ur,uz = np.loadtxt(data,unpack=True)\\n\\n # Load FEM output\\n points = '/home/scott/research/models/pylith/3d/fialko2012/model3_agu/output_points.txt'\\n pointsh5 = '/home/scott/research/models/pylith/3d/fialko2012/model3_agu/output/elastic/apmb/points.h5'\\n x_fem, ur_fem, uz_fem = pu.extract_points(pointsh5)\\n #NOTE: in this case need radial distance b/c not on x-axis\\n #x = np.sqrt(2)*1e3*np.loadtxt(points,usecols=[0])\\n # NOTE: cludge fix for negative radial displacements in dipole model\\n ur_fem[x_fem >= 40000] = -ur_fem[x_fem >= 40000]\\n #ur_fem = np.abs(ur_fem)\\n\\n #Convert to cm units for plotting\\n x_fem = x_fem/1000\\n ur_fem = ur_fem * 100.0\\n uz_fem = uz_fem * 100.0\\n\\n #NOTE: must interpolate either insar data or FEM to compare at values at same radial distance\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n plt.plot(x, uz, 'b.-', lw=2, label='data')\\n plt.plot(x, ur, 'g.-', lw=2)\\n plt.plot(x_fem, uz_fem, marker='o', ls='None', lw=2, mec='b', mfc='None',label='FEM')\\n plt.plot(x_fem, ur_fem, marker='o', ls='None', lw=2, mec='g', mfc='None')\\n plt.axhline(color='k')\\n plt.title('FEM vs. Data')\\n plt.xlabel('Radial distance [km]')\\n plt.ylabel('Displacement [cm]')\\n plt.grid(True)\\n plt.xlim(0,150) #only show out to 150km\\n plt.legend()\",\n \"def setup_plot_by_stage(stage, inds=None):\\n if inds is not None:\\n stage = stage[inds]\\n ustage = np.unique(stage)\\n nplots = ustage.size + 1.\\n fig, (axs) = setup_multiplot(nplots, sharex=True, sharey=True, figsize=(12, 8))\\n return fig, (axs)\",\n \"def __init__(self):\\n super().__init__()\\n\\n # general attributes\\n self.printTag = 'OUTSTREAM PLOT'\\n self.options = {} # outstreaming options # no addl info from original developer\\n self.counter = 0 # keeps track of how many times the same plot has been plotted\\n self.dim = None # default plot is 2D\\n self.sourceName = [] # list of source names\\n self.sourceData = None # source of data\\n self.outStreamTypes = [] # list of the outstream types\\n self.destinations = None # where plots should go (screen, file, etc.)\\n\\n # plot types key is data dimension, value is list of available plot types\\n self.availableOutStreamTypes = {2: ['scatter',\\n 'line',\\n 'histogram',\\n 'stem',\\n 'step',\\n 'pseudocolor',\\n 'dataMining',\\n 'contour',\\n 'filledContour'],\\n 3: ['scatter',\\n 'line',\\n 'histogram',\\n 'stem',\\n 'surface',\\n 'wireframe',\\n 'tri-surface',\\n 'contour',\\n 'filledContour']}\\n\\n # interpolators that can be used in plots\\n self.availableInterpolators = ['nearest',\\n 'linear',\\n 'cubic',\\n 'multiquadric',\\n 'inverse',\\n 'gaussian',\\n 'Rbflinear',\\n 'Rbfcubic',\\n 'quintic',\\n 'thin_plate']\\n\\n # plot components\\n self.fig = None # figure\\n self.ax = None # axes\\n self.actPlot = None # plot action, ie., ax.plot()\\n self.gridSpace = None # subplot setup\\n self.actcm = None # colormap\\n self.xCoordinates = None # x coordinate name\\n self.yCoordinates = None # y coordinate name\\n self.zCoordinates = None # z coordinate name\\n self.xValues = None # dictionary of x values\\n self.yValues = None # dictionary of y values\\n self.zValues = None # dictionary of z values\\n self.colorMapCoordinates = {} # color map coordinates\\n self.colorMapValues = {} # color map values\\n\\n # For the data-mining plot, I think?\\n self.clusterLabels = None\\n self.clusterValues = None\\n\\n # Gaussian Mixtures\\n self.mixtureLabels = None\\n self.mixtureValues = None\\n self.mixtureMeans = None\\n self.mixtureCovars = None\",\n \"def subplottPNG(self):\\n os.chdir(self.mainDir)\\n folder = os.listdir(u'.')\\n folders = [f for f in folder if f[0] == 'S']\\n\\n for subject in folders:\\n\\n try: # go to the 'results' directory\\n resultsDir = os.path.join(os.path.join(self.mainDir, subject),'results')\\n os.chdir(resultsDir)\\n\\n # find all files with .png extension\\n pngfiles = glob.glob('*.png')\\n pngfiles.sort(key = lambda x:x[0])\\n pngfiles.sort(key = lambda x:x[1])\\n\\n fig = plt.figure()\\n\\n for ii, filename in enumerate(pngfiles):\\n f = plt.subplot(4,4,ii+1)\\n f.set_axis_off()\\n f.set_xlabel('ses:'+str(ii+1))# f.set_figheight(15)\\n fig.set_figwidth(30)\\n fig.set_figheight(30)\\n fig.tight_layout()\\n img = matplotlib.image.imread(filename)\\n plt.imshow(img)\\n\\n figname = subject + '_subplot'+ '.png'\\n matplotlib.pyplot.savefig(figname)\\n\\n except Exception as errMessage:\\n print(errMessage)\",\n \"def main(self, args):\\n for plot in args.plots:\\n if plot == 'no_plot':\\n break\\n print \\\"plotting\\\", plot\\n\\n fig = self.plot_figure(plot)\\n\\n fformat = '{plot}_{index}.{ext}'\\n fname = fformat.format(plot=plot, index=self.index, ext='png')\\n fpath = os.path.join(plot_dir, fname)\\n fig.savefig(fpath)\\n\\n if args.distributions == 'all':\\n distributions = ['Uf', 'Wf', 'uf_abs',\\n 'vorticity', 'vertical_shear']\\n else:\\n distributions = args.distributions\\n for dist in distributions:\\n range = self.properties[dist]['range']\\n name = self.properties[dist]['name']\\n print \\\"plotting distribution\\\", dist, name\\n fig = self.plot_distribution(getattr(self, dist), range, name)\\n\\n fformat = 'distribution_{q}_{index}.{ext}'\\n fname = fformat.format(q=dist, index=self.index, ext='png')\\n fpath = os.path.join(plot_dir, fname)\\n fig.savefig(fpath)\\n\\n if args.funcs:\\n for func in args.funcs:\\n print \\\"multiprocessing\\\", func\\n f = getattr(self, 'plot_' + func)\\n f()\",\n \"def spider(inputfiles, names, type=\\\"M1\\\", threshold=0.1, spinwindow=[], Eg_low=0, Eg_high=1e9, Ex_low=0, Ex_high=1e9, scale=2):\\n\\n Nsp = np.ceil(np.sqrt(len(inputfiles))).astype(int)\\n f, ax_list = plt.subplots(Nsp,Nsp,squeeze=False,sharex='col', sharey='row')\\n\\n for i in range(len(inputfiles)):\\n inputfile = inputfiles[i]\\n name = names[i]\\n ax = ax_list[i%Nsp][int((i-i%Nsp)/Nsp)]\\n\\n\\n levels = read_energy_levels(inputfile)\\n Egs = levels[0,0]\\n\\n Ex_high = min(Ex_high, levels[:,0].max()-Egs)\\n Eg_high = min(Eg_high, levels[:,0].max()-Egs)\\n \\n \\n levels_plot_J = []\\n levels_plot_Ex = []\\n for iEx in range(len(levels[:,0])):\\n # print levels[iEx,:]\\n J2 = levels[iEx,1]\\n par = levels[iEx,2]\\n if len(spinwindow) > 0 and not ([J2,par] in spinwindow or [J2-2,par] in spinwindow or [J2+2,par] in spinwindow):\\n continue\\n Ex = levels[iEx,0]-Egs\\n if Ex < Ex_low or Ex > Ex_high:\\n continue\\n \\n levels_plot_J.append(J2/2)\\n levels_plot_Ex.append(Ex)\\n \\n ax.plot(levels_plot_J, levels_plot_Ex, 'o', color='grey', linewidth=0.5)\\n ax.set_xlim([levels[:,1].min()/2-1,levels[:,1].max()/2+1])\\n ax.set_title(name+r'$\\\\,E_\\\\gamma\\\\in[{:.1f},{:.1f}]$'.format(Eg_low,Eg_high))\\n ax.set_ylabel(r'$E_x\\\\,\\\\mathrm{[MeV]}$')\\n ax.set_xlabel(r'$J\\\\,\\\\mathrm{[\\\\hbar]}$')\\n \\n \\n \\n transitions = read_transition_strengths(inputfile, type=type)\\n for iEx in range(len(transitions[:,0])):\\n J2i = int(transitions[iEx,0])\\n pari = int(transitions[iEx,1])\\n if len(spinwindow) > 0 and not [J2i,pari] in spinwindow:\\n continue\\n B = transitions[iEx,7]\\n Eg = transitions[iEx,6]\\n if B < threshold or Eg<Eg_low or Eg>Eg_high:\\n continue\\n Ei = transitions[iEx,2]-Egs\\n if Ei < Ex_low or Ei > Ex_high:\\n continue\\n J2f = int(transitions[iEx,3])\\n parf = int(transitions[iEx,4])\\n Ef = transitions[iEx,5]-Egs\\n ax.plot([J2i/2,J2f/2],[Ei,Ef], color='teal', linewidth=(scale*B))\\n \\n return f, ax_list\",\n \"def plot_gains(gains, gain_ref, TITLES, OUT_DIR):\\n\\n# print 'directory: %s' % OUT_DIR\\n# print 'TITLES:%s', TITLES\\n\\n gain_ref_np = np.array(gains[gain_ref].gain)\\n ratios = []\\n for gain in gains:\\n gain_np = np.array(gain.gain)\\n dim = (min(gain_ref_np.shape[0], gain_np.shape[0]),\\n min(gain_ref_np.shape[1], gain_np.shape[1])\\n )\\n# print 'dim = ', dim\\n ratios.append(gain_np[0:dim[0], 0:dim[1]] / gain_ref_np[0:dim[0], 0:dim[1]])\\n\\n# print 'Ratios = ', ratios\\n\\n rows = 2*((len(ratios) -1) / 6 + 1)\\n cmap = plt.get_cmap('gnuplot')\\n colors = [cmap(i) for i in np.linspace(0, 1, len(ratios))]\\n fig, axes = plt.subplots(nrows=rows, ncols=6)\\n fig.set_size_inches(20,20)\\n axfl = axes.flatten()\\n for i, ratio in enumerate(ratios):\\n# print 'Plotting %s', TITLES[i]\\n\\tj = (i / 6)*12 + i % 6\\n ax = axfl[j]\\n ax2 = axfl[j+6]\\n ax.hist(np.reshape(ratio, -1), 20, range=(0.9, 1.1), facecolor=colors[i])\\n ax.set_title(TITLES[i], size=20)\\n ax2.hist(np.reshape(ratio, -1), 50, range=(0., 2.), facecolor=colors[i])\\n\\n fig.suptitle(\\\"Gains with ref gain '%s'\\\" % TITLES[gain_ref], y=0.95, size=25)\\n # fig.tight_layout()\\n plt.savefig(OUT_DIR + 'gain.png')\\n plt.close(fig)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68558604","0.6830801","0.682716","0.6536897","0.6412557","0.6166356","0.61190796","0.60816085","0.6074869","0.60712504","0.598796","0.59763676","0.5945832","0.59333724","0.5919523","0.589908","0.58856714","0.58749056","0.5861554","0.5851671","0.58485967","0.5831483","0.58244705","0.5820081","0.58078563","0.577831","0.5776586","0.57755756","0.57658094","0.5759535","0.57588774","0.5748835","0.5748021","0.5746387","0.57463133","0.5740658","0.57406175","0.57376343","0.5737546","0.5720774","0.5713441","0.57049155","0.56946","0.5691393","0.56879914","0.56868875","0.5685298","0.5680502","0.56785303","0.567738","0.56689197","0.56635857","0.565659","0.56515175","0.5642445","0.564143","0.5638351","0.5638204","0.56313294","0.56283593","0.56060445","0.55911607","0.55904955","0.55838996","0.55836135","0.55813813","0.5576549","0.55764","0.55743825","0.5569916","0.55667716","0.5560693","0.55594724","0.5557762","0.55561227","0.55550045","0.55541766","0.5550424","0.554172","0.554123","0.5532216","0.55300486","0.55284727","0.55274206","0.55270064","0.55269915","0.55163276","0.5515237","0.54819626","0.54815567","0.54806346","0.5479615","0.5477968","0.5471675","0.54709536","0.54668057","0.54599625","0.54555136","0.54472816","0.54457825"],"string":"[\n \"0.68558604\",\n \"0.6830801\",\n \"0.682716\",\n \"0.6536897\",\n \"0.6412557\",\n \"0.6166356\",\n \"0.61190796\",\n \"0.60816085\",\n \"0.6074869\",\n \"0.60712504\",\n \"0.598796\",\n \"0.59763676\",\n \"0.5945832\",\n \"0.59333724\",\n \"0.5919523\",\n \"0.589908\",\n \"0.58856714\",\n \"0.58749056\",\n \"0.5861554\",\n \"0.5851671\",\n \"0.58485967\",\n \"0.5831483\",\n \"0.58244705\",\n \"0.5820081\",\n \"0.58078563\",\n \"0.577831\",\n \"0.5776586\",\n \"0.57755756\",\n \"0.57658094\",\n \"0.5759535\",\n \"0.57588774\",\n \"0.5748835\",\n \"0.5748021\",\n \"0.5746387\",\n \"0.57463133\",\n \"0.5740658\",\n \"0.57406175\",\n \"0.57376343\",\n \"0.5737546\",\n \"0.5720774\",\n \"0.5713441\",\n \"0.57049155\",\n \"0.56946\",\n \"0.5691393\",\n \"0.56879914\",\n \"0.56868875\",\n \"0.5685298\",\n \"0.5680502\",\n \"0.56785303\",\n \"0.567738\",\n \"0.56689197\",\n \"0.56635857\",\n \"0.565659\",\n \"0.56515175\",\n \"0.5642445\",\n \"0.564143\",\n \"0.5638351\",\n \"0.5638204\",\n \"0.56313294\",\n \"0.56283593\",\n \"0.56060445\",\n \"0.55911607\",\n \"0.55904955\",\n \"0.55838996\",\n \"0.55836135\",\n \"0.55813813\",\n \"0.5576549\",\n \"0.55764\",\n \"0.55743825\",\n \"0.5569916\",\n \"0.55667716\",\n \"0.5560693\",\n \"0.55594724\",\n \"0.5557762\",\n \"0.55561227\",\n \"0.55550045\",\n \"0.55541766\",\n \"0.5550424\",\n \"0.554172\",\n \"0.554123\",\n \"0.5532216\",\n \"0.55300486\",\n \"0.55284727\",\n \"0.55274206\",\n \"0.55270064\",\n \"0.55269915\",\n \"0.55163276\",\n \"0.5515237\",\n \"0.54819626\",\n \"0.54815567\",\n \"0.54806346\",\n \"0.5479615\",\n \"0.5477968\",\n \"0.5471675\",\n \"0.54709536\",\n \"0.54668057\",\n \"0.54599625\",\n \"0.54555136\",\n \"0.54472816\",\n \"0.54457825\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7218871"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21293,"cells":{"query":{"kind":"string","value":"Plot grid of surface displacement maps from each output/step folder if normalize=True, use step01 colorbar for all images"},"document":{"kind":"string","value":"def plot_directory_surface(path,figsize=(17,11), comp=2, nrow=1, norm=None,\n cbar='each', cloc='top', outname=None, labels='1', show=True):\n outdirs = np.sort(os.listdir(path))\n nplots = len(outdirs)\n ncol = np.ceil(nplots/nrow).astype(np.int)\n fig = plt.figure(figsize=figsize)\n\n grid = ImageGrid(fig, 111, # similar to subplot(111)\n nrows_ncols = (nrow, ncol),\n direction=\"row\",\n axes_pad = 0.25,\n add_all=True,\n label_mode = labels, #'all', 'L', '1'\n share_all = True,\n cbar_location=cloc, #top,right\n cbar_mode=cbar, #each,single,None\n cbar_size=0.1,#\"7%\",\n cbar_pad=0.0#,\"1%\",\n )\n\n #NOTE: if cbar='single',cloc='right', a way to automatically normalize by grid[0]\n #if normalize:\n # verts,data,tris = load_h5(os.path.join(path,'step01/surface.h5'))\n # if comp==3: #radial displacements\n # z = np.hypot(data[:,:,0], data[:,:,1]).flatten()\n # else:\n # z = data[:,:,comp].flatten()\n # norm = Normalize(vmin=np.nanmin(z), vmax=np.nanmax(z))\n #else:\n # norm=None\n\n for i,outdir in enumerate(outdirs):\n ax = grid[i]\n print(outdir)\n im = plotSurface(os.path.join(path,outdir,'surface.h5'), comp=comp, ax=ax,\n points=False, tris=False, profile=False, annotate=False, norm=norm,\n xscale=1e-3, yscale=1e-3)\n\n # colorbar settings, not sure what's up with set_xticks...\n ax.cax.colorbar(im)\n #cmin = np.nanmin(data)\n #cmax = np.nanmax(data)\n #ax.cax.set_xticks([cmin,0,cmax])\n\n # label upper left\n ax.text(0.05,0.95,outdir,\n weight='bold',\n ha='left',\n va='top',\n bbox=dict(facecolor='white'),\n transform=ax.transAxes)\n #ax.set_ylabel(outdir)\n #ax.tick_params(labelbottom=0,labeltop=0,labelleft=0,labelright=0,\n # bottom=0,top=0,left=0,right=0)\n\n #if cbar=='single':\n # grid[0].cax.colorbar(im)\n\n # Annotate Plot\n # don't show grid frames without data...\n Nextra = grid.ngrids - nplots\n if Nextra > 0:\n for ax in grid[-Nextra:]:\n #print(ax)\n ax.set_visible(False)\n ax.cax.set_visible(False)\n fig.suptitle(path, fontsize=14, fontweight='bold')\n if outname: plt.savefig(outname)\n if show: plt.show()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def debugplots(fig,data):\n grid = AxesGrid(fig, 111, # similar to subplot(142)\n nrows_ncols=(1, 6),\n axes_pad=0.0,\n share_all=True,\n label_mode=\"L\",\n cbar_location=\"right\",\n cbar_mode=\"none\",\n )\n\n Z0=data[0].real\n Z1=data[1].real\n Z2=data[2].real\n Z3=data[3].real\n Z4=data[4].real\n Z5=data[5].real\n \n Z=[Z0,Z1,Z2,Z3,Z4,Z5]\n \n for i in range(6):\n grid[i].set_title(r\"$t=%u\\Delta t$\"%(Timestep(i)),color='black',horizontalalignment='center',verticalalignment='bottom')\n im = grid[i].imshow(Z[i], extent=(-2, 2, -2, 2), interpolation=\"Nearest\",origin=\"lower\",cmap='seismic',vmin=-1,vmax=1)\n grid[i].set_aspect(ratio)\n grid[i].set_xlabel(\"$x/10$\",size=16)\n grid[0].set_ylabel(\"$y/10$\",size=16)\n pos2 = [0.905,0.25,0.01,0.5]\n position = fig.add_axes(pos2)\n fig.colorbar(im, ax=grid[2],cax=position,extend=\"both\")\n \n for cax in grid.cbar_axes:\n cax.toggle_label(True)\n \n # This affects all axes as share_all = True.\n grid.axes_llc.set_xticks([-2,-1, 0,1])\n #grid[0].set_xticks([-20,-10, 0,10, 20])\n grid.axes_llc.set_yticks([-2, -1, 0, 1,2])","def show_colormaps():\n maps = sorted(cmlist)\n nmaps = len(maps) + 1\n\n a = np.linspace(0, 1, 256).reshape(1, -1) # pylint: disable=E1103\n a = np.vstack((a, a))\n\n fig = plt.figure(figsize=(5, 10))\n fig.subplots_adjust(top=0.99, bottom=0.01, left=0.2, right=0.99)\n for i, name in enumerate(maps):\n ax = plt.subplot(nmaps, 1, i + 1)\n plt.axis(\"off\")\n plt.imshow(a, aspect='auto', cmap=get_cmap(name), origin='lower')\n pos = list(ax.get_position().bounds)\n fig.text(pos[0] - 0.01, pos[1], name, fontsize=10,\n horizontalalignment='right')\n\n plt.show()","def plot_final_grid(generated_images):\n\n fig = plt.figure(figsize=(8, 6))\n fig.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0.001, hspace=0.001)\n\n for ind in range(GRID_IMGS):\n ax = fig.add_subplot(GRID_SIZE, GRID_SIZE, ind + 1, xticks=[], yticks=[])\n ax.imshow(np.uint8(((generated_images[ind] + 1) / 2) * 255), cmap='gray')\n\n plt.savefig('/content/drive/My Drive/WGAN/generated_image_grid.png')\n plt.savefig('/content/drive/My Drive/WGAN/results/DCGAN.png')\n plt.show()","def ListColorMaps(self):\n p.rc('text', usetex=False)\n a=p.outerproduct(numpy.arange(0,1,0.01),numpy.ones(10))\n p.figure(figsize=(10,5))\n p.subplots_adjust(top=0.8,bottom=0.05,left=0.01,right=0.99)\n maps=[m for m in p.cm.datad.keys() if not m.endswith(\"_r\")]\n maps.sort()\n l=len(maps)+1\n i=1\n for m in maps:\n p.subplot(1,l,i)\n p.axis(\"off\")\n p.imshow(a,aspect='auto',cmap=p.get_cmap(m),origin=\"lower\")\n p.title(m,rotation=90,fontsize=10)\n i=i+1\n #savefig(\"colormaps.png\",dpi=100,facecolor='gray')\n p.show()","def visualize_M_gridworld(self, state=0):\n\n\t\tplt.subplot(221); plt.imshow(self.M[12,0,:].reshape(5,5)), plt.colorbar()\n\t\tplt.subplot(222); plt.imshow(self.M[12,1,:].reshape(5,5)), plt.colorbar()\n\t\tplt.subplot(223); plt.imshow(self.M[12,2,:].reshape(5,5)), plt.colorbar()\n\t\tplt.subplot(224); plt.imshow(self.M[12,3,:].reshape(5,5)), plt.colorbar()\n\t\tplt.show()","def plot_final_grid(generated_images):\n\n fig = plt.figure(figsize=(GRID_SIZE, GRID_SIZE))\n fig.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0.001, hspace=0.001)\n\n for ind in range(GRID_IMGS):\n ax = fig.add_subplot(GRID_SIZE, GRID_SIZE, ind + 1, xticks=[], yticks=[])\n ax.imshow(np.uint8(((generated_images[ind] + 1) / 2) * 255), cmap='gray')\n\n plt.savefig('/content/drive/My Drive/WGAN/generated_image_grid.png')\n plt.savefig('/content/drive/My Drive/WGAN/results/WGAN.png')\n plt.show()","def debugmyplots(fig,data):\n grid = AxesGrid(fig, 111, # similar to subplot(142)\n nrows_ncols=(1, 6),\n axes_pad=0.0,\n share_all=True,\n label_mode=\"L\",\n cbar_location=\"right\",\n cbar_mode=\"none\",\n )\n\n \n for i in range(6):\n Z = np.real(data[i])\n grid[i].set_title(r\"$t={:03.1f}$\".format(Timestep(i)),color='black',horizontalalignment='center',verticalalignment='bottom')\n im = grid[i].imshow(Z, extent=(-2, 2, -2, 2), interpolation=\"Gaussian\",origin=\"lower\",cmap='seismic',vmin=-1,vmax=1)\n grid[i].set_aspect(ratio)\n grid[i].set_xlabel(\"$x/10$\",size=16)\n #plt.colorbar(im, cax = grid.cbar_axes[0])\n #ticks = np.logspace(1e-6,1,7)\n #lf = LogFormatter(10, labelOnlyBase=False)\n grid[0].set_ylabel(\"$y/10$\",size=16)\n pos2 = [0.905,0.25,0.01,0.5]\n position = fig.add_axes(pos2)\n ticks=np.logspace(1e-6,1e-1,6)\n fig.colorbar(im, ax=grid[5],cax=position,extend=\"both\")\n \n for cax in grid.cbar_axes:\n cax.toggle_label(True)\n \n # This affects all axes as share_all = True.\n grid.axes_llc.set_xticks([-2,-1, 0,1])\n #grid[0].set_xticks([-20,-10, 0,10, 20])\n grid.axes_llc.set_yticks([-2, -1, 0, 1,2])","def plot_figure11():\n height_ceilings = [200., 300., 400.]\n height_ceiling_ids = [list(height_range_ceilings).index(height_ceiling) for height_ceiling in height_ceilings]\n\n baseline_height_ceiling = 500.\n baseline_height_ceiling_id = list(height_range_ceilings).index(baseline_height_ceiling)\n\n plot_item00 = {\n 'data': 100.-nc.variables[\"p_ceiling_rank40\"][height_ceiling_ids[0], :, :],\n 'contour_fill_levels': np.linspace(50, 100, 21),\n 'contour_line_levels': [70., 80., 90., 95.],\n 'contour_line_label_fmt': '%.0f',\n 'colorbar_ticks': np.linspace(50, 100, 21)[::4],\n 'colorbar_tick_fmt': '{:.0f}',\n 'colorbar_label': 'Availability [%]',\n 'extend': 'min',\n }\n plot_item01 = {\n 'data': 100.-nc.variables[\"p_ceiling_rank40\"][height_ceiling_ids[1], :, :],\n 'contour_fill_levels': np.linspace(70, 100, 21),\n 'contour_line_levels': [70., 80., 90., 95.],\n 'contour_line_label_fmt': '%.0f',\n 'colorbar_ticks': np.linspace(70, 100, 21)[::4],\n 'colorbar_tick_fmt': '{:.0f}',\n 'colorbar_label': 'Availability [%]',\n 'extend': 'min',\n }\n plot_item02 = {\n 'data': 100.-nc.variables[\"p_ceiling_rank40\"][height_ceiling_ids[2], :, :],\n 'contour_fill_levels': np.linspace(80, 100, 21),\n 'contour_line_levels': [70., 80., 90., 95.],\n 'contour_line_label_fmt': '%.0f',\n 'colorbar_ticks': np.linspace(80, 100, 21)[::4],\n 'colorbar_tick_fmt': '{:.0f}',\n 'colorbar_label': 'Availability [%]',\n 'extend': 'min',\n }\n\n column_titles = [\"200 m\", \"300 m\", \"400 m\"]\n plot_items = [plot_item00, plot_item01, plot_item02]\n\n eval_contour_fill_levels(plot_items)\n plot_panel_1x3_seperate_colorbar(plot_items, column_titles)\n\n linspace10 = np.linspace(0., 11., 21)\n plot_item10 = {\n 'data': -(100.-nc.variables[\"p_ceiling_rank40\"][height_ceiling_ids[0], :, :])+\n (100.-nc.variables[\"p_ceiling_rank40\"][baseline_height_ceiling_id, :, :]),\n 'contour_fill_levels': linspace10,\n 'contour_line_levels': sorted([1.1]+list(linspace10[::4])),\n 'contour_line_label_fmt': '%.1f',\n 'colorbar_ticks': linspace10[::4],\n 'colorbar_tick_fmt': '{:.0f}',\n 'colorbar_label': 'Availability decrease [%]',\n }\n linspace11 = np.linspace(0., 23., 21)\n plot_item11 = {\n 'data': (100.-nc.variables[\"p_ceiling_rank40\"][height_ceiling_ids[1], :, :])-\n (100.-nc.variables[\"p_ceiling_rank40\"][baseline_height_ceiling_id, :, :]),\n 'contour_fill_levels': linspace11,\n 'contour_line_levels': sorted([2.3]+list(linspace11[::4])),\n 'contour_line_label_fmt': '%.1f',\n 'colorbar_ticks': linspace11[::4],\n 'colorbar_tick_fmt': '{:.0f}',\n 'colorbar_label': 'Availability increase [%]',\n }\n linspace12 = np.linspace(0., 38., 21)\n plot_item12 = {\n 'data': (100.-nc.variables[\"p_ceiling_rank40\"][height_ceiling_ids[2], :, :])-\n (100.-nc.variables[\"p_ceiling_rank40\"][baseline_height_ceiling_id, :, :]),\n 'contour_fill_levels': linspace12,\n 'contour_line_levels': sorted([3.8]+list(linspace12[::4])),\n 'contour_line_label_fmt': '%.1f',\n 'colorbar_ticks': linspace12[::4],\n 'colorbar_tick_fmt': '{:.0f}',\n 'colorbar_label': 'Availability increase [%]',\n }\n\n column_titles = None\n plot_items = [plot_item10, plot_item11, plot_item12]\n\n eval_contour_fill_levels(plot_items)\n plot_panel_1x3_seperate_colorbar(plot_items, column_titles)","def plotmap(self):\n if self.plotfigure is None: return\n\n self.plotfigure.clf()\n collist = [\"#%.2x%.2x%.2x\" % (i, i, i) for i in self.currentshades]\n cmap = colors.ListedColormap(collist)\n if self.gs.isfixed:\n crange = [self.minvalue] + self.currentvalues\n elif self.gs.isperc:\n crange = np.percentile(self.imagearray, [0.0] + self.currentpercents)\n else:\n crange = np.array([self.minstdd] + self.currentnsigs) * self.stdvalue + self.meanvalue\n norm = colors.BoundaryNorm(crange, cmap.N)\n img = plt.imshow(self.imagearray, cmap=cmap, norm=norm, origin='lower')\n plt.colorbar(img, norm=norm, cmap=cmap, boundaries=crange, ticks=crange)\n if self.imagetitle is not None:\n plt.title(self.imagetitle)","def show_channels(chmaps, n_cols=8, normalize=None, ofpath=None):\n n_rows = (chmaps.shape[0] - 1) // n_cols + 1\n\n if n_rows == 1:\n n_cols = chmaps.shape[0]\n\n if normalize is None:\n vmin, vmax = None, None\n else:\n vmin, vmax = normalize\n\n fig = plt.figure()\n\n grid = AxesGrid(fig, 111,\n nrows_ncols=(n_rows, n_cols),\n axes_pad=0.0,\n share_all=True)\n\n for i, chmap in enumerate(chmaps):\n grid[i].imshow(chmap, vmin=vmin, vmax=vmax)\n\n grid.axes_llc.get_xaxis().set_ticks([])\n grid.axes_llc.get_yaxis().set_ticks([])\n\n if ofpath is None:\n plt.get_current_fig_manager().window.showMaximized()\n plt.show()\n else:\n fig.savefig(ofpath)\n plt.close(fig)","def plot_locations_np(self, c_img, locations, file_name_prefix=''):\n other_axes = [[1, 2], [2, 0], [1, 0]]\n shape_str = str(c_img.shape)\n create_folder(self._output_folder)\n for id_loc, c_loc in enumerate(locations):\n plt.subplots(1, 3, squeeze=True, figsize=(8 * 3, 8))\n for id_plane, plane in enumerate([PlaneTypes.AXIAL, PlaneTypes.SAGITTAL, PlaneTypes.CORONAL]):\n c_loc = np.array(c_loc)\n c_dim = get_axis_idx(plane)\n c_slice = c_loc[c_dim]\n\n if c_slice < c_img.shape[c_dim]:\n pt = c_loc[other_axes[c_dim]]\n ax = plt.subplot(1, 3, id_plane + 1)\n ax.imshow(get_proper_plane(c_img, plane, c_slice), cmap='gray')\n ax.scatter(pt[0],pt[1], color=self._COLORS[id_loc])\n c_title = F'{c_slice} {pt} -- {plane.value} -- {shape_str} '\n plt.title(c_title, fontsize=20)\n else:\n raise Exception(\n F'The slice {c_slice} is larger than the shape of the array {c_img.shape[c_dim]}')\n\n pylab.savefig(join(self._output_folder, F'{file_name_prefix}_Loc_{id_loc}.jpg'), bbox_inches='tight')\n self._close_figure()","def testing():\n\n from matplotlib import pyplot as plt\n\n dem_fn = \"../../tests/testdata/ca_dem_30s/ca_dem_30s/\"\n dir_fn = \"../../tests/testdata/ca_dir_30s/ca_dir_30s/\"\n\n fv = -32768\n\n grid = Grid.from_raster(dir_fn, \"dir\", nodata=fv)\n grid.read_raster(dem_fn, \"dem\", nodata=fv)\n\n lon, lat = -99.0619, 20.933\n\n fig, (ax1, ax2) = plt.subplots(1, 2)\n\n idem = ax1.imshow(\n grid.view(\"dem\"), extent=grid.extent, cmap=\"cubehelix\", zorder=1, vmin=0\n )\n plt.colorbar(idem, ax=ax1, label=\"Elevation (m)\")\n\n idir = ax2.imshow(\n grid.view(\"dir\"), extent=grid.extent, cmap=\"viridis\", zorder=2, vmin=0\n )\n boundaries = [0] + sorted(list(dirmap))\n plt.colorbar(idir, ax=ax2, boundaries=boundaries, values=sorted(dirmap))\n\n grid.catchment(\n data=\"dir\",\n x=lon,\n y=lat,\n dirmap=dirmap,\n out_name=\"catch\",\n xytype=\"label\",\n nodata_in=nodata,\n )\n catch = grid.polygonize(grid.catch.astype(\"int32\"), connectivity=8)\n grid.clip_to(\"catch\")\n\n for (p, v) in catch:\n poly = geometry.asShape(p)\n ax1.plot(*poly.exterior.xy, color=\"white\")\n plt.show()","def gridPlot12(img_stack):\r\n F = plt.figure(figsize = (30,30))\r\n F.subplots_adjust(left = 0.05, right = 0.95)\r\n grid = ImageGrid(F, 142, nrows_ncols = (3,4), axes_pad = 0.0, share_all = True,\r\n label_mode = \"L\", cbar_location = \"top\", cbar_mode = \"single\")\r\n \r\n i = 0\r\n for img in img_stack[0:12]:\r\n im = grid[i].imshow(img, interpolation = \"nearest\", vmin = 0, vmax = 255)\r\n i += 1 \r\n grid.cbar_axes[0].colorbar(im)\r\n plt.savefig('gplot12.png')\r\n# for cax in grid.cbar_axes:\r\n# cax.toggle_label(False)\r\n return","def myplots(fig,data):\n grid = AxesGrid(fig, 111, # similar to subplot(142)\n nrows_ncols=(1, 6),\n axes_pad=0.0,\n share_all=True,\n label_mode=\"L\",\n cbar_location=\"right\",\n cbar_mode=\"none\",\n )\n\n \n for i in range(6):\n Z = absolute(data[i])**2\n grid[i].set_title(r\"$t={:03.1f}$\".format(Timestep(i)),color='black',horizontalalignment='center',verticalalignment='bottom')\n im = grid[i].imshow(Z, extent=(-2, 2, -2, 2), interpolation=\"gaussian\",origin=\"lower\",cmap=cmap,norm=LogNorm(vmin=1e-5,vmax=1))\n grid[i].set_aspect(ratio)\n grid[i].set_xlabel(\"$x/10$\",size=16)\n #plt.colorbar(im, cax = grid.cbar_axes[0])\n #ticks = np.logspace(1e-6,1,7)\n #lf = LogFormatter(10, labelOnlyBase=False)\n grid[0].set_ylabel(\"$y/10$\",size=16)\n pos2 = [0.905,0.25,0.01,0.5]\n position = fig.add_axes(pos2)\n ticks=np.logspace(1e-6,1e-1,6)\n fig.colorbar(im, ax=grid[5],cax=position,extend=\"both\")\n \n for cax in grid.cbar_axes:\n cax.toggle_label(True)\n \n # This affects all axes as share_all = True.\n grid.axes_llc.set_xticks([-2,-1, 0,1])\n #grid[0].set_xticks([-20,-10, 0,10, 20])\n grid.axes_llc.set_yticks([-2, -1, 0, 1,2])","def map_plot(self, iter_no):\n \n m = self._m\n n = self._n\n plt.figure()\n label=np.zeros(m*n)\n self._trained = True\n mapped = self.map_vects(datanorm)\n mapped=tuple(map(tuple, mapped))\n c=Counter(mapped)\n \n c= sorted(c.items(), key=itemgetter(1))\n a=[m*n]\n for i in range(0,len(c)):\n x=(((c[i])[0])[0])\n y=(((c[i])[0])[1])\n z=((c[i])[1])\n plt.plot(x, y, 'ro', markersize= z/(2*m*n)) \n plt.savefig('exoplanet{}.png'.format(iter_no))\n p=plt.imread('exoplanet{}.png'.format(iter_no))\n imgs.append(p)\n plt.show()\n plt.close()\n print(c)\n self._trained = False","def data_model_residual(surface, dem, unw, incidence):\n los,fem_los,residual = pu.los2pylith(surface,dem,unw,incidence)\n\n # Using image_grid\n fig = plt.figure()\n grid = ImageGrid(fig, 111, # similar to subplot(111)\n nrows_ncols = (1, 3),\n direction=\"row\",\n axes_pad = 0.05,\n add_all=True,\n label_mode = \"1\",\n share_all = True,\n cbar_location=\"top\",\n cbar_mode=\"each\", #\"single\"\n cbar_size=\"5%\",\n cbar_pad=0.05,\n )\n #grid[0].set_xlabel(\"X\")\n #grid[0].set_ylabel(\"Y\")\n #grid2[0].set_xticks([-2, 0])\n #grid2[0].set_yticks([-2, 0, 2])\n\n #NOTE: could find global min/max from three arrays here\n norm = Normalize(vmin=np.nanmin(los), vmax=np.nanmax(los))\n #for ax,data in zip(grid,[los,fem_los,residual]):\n im = grid[0].imshow(los,origin='upper',norm=norm,cmap=plt.cm.jet)\n grid[0].axhline(100,color='m') #show profile\n cax = grid.cbar_axes[0]\n cax.colorbar(im)\n grid[1].axhline(100,color='k') #show profile\n im1 = grid[1].imshow(fem_los,origin='upper',norm=norm,cmap=plt.cm.jet)\n\n cax = grid.cbar_axes[1]\n cax.colorbar(im1)\n\n im2 = grid[2].imshow(residual,origin='upper',cmap=plt.cm.jet)\n cax = grid.cbar_axes[2]\n cax.colorbar(im2)\n\n # Add letter labels\n for ax, label in zip(grid,['A', 'B', 'C']):\n ax.text(0.05, 0.95, label, transform=ax.transAxes,\n fontsize=16, fontweight='bold', va='top')\n\n # Annotate\n # NOTE: way too high!\n #plt.suptitle('FEM Results')\n\n # Add profile\n # NOTE: for now EW, but would be easy to do arbitrary line, and convert to km\n fig = plt.figure()\n #x = arange(los.shape[0])\n plt.axhline(color='k',ls='--')\n plt.plot(los[100],'m.',label='data')\n plt.plot(fem_los[100],'k-',lw=2,label='model')\n plt.xlabel('Distance [km]')\n plt.ylabel('Distance [km]')\n plt.legend(loc='upper left')\n\n plt.show()","def plot_figure10():\n height_ceiling = 500.\n height_ceiling_id = list(height_range_ceilings).index(height_ceiling)\n\n plot_item00 = {\n 'data': 100.-nc.variables[\"p_ceiling_rank40\"][height_ceiling_id, :, :],\n 'contour_fill_levels': np.linspace(50, 100, 21),\n 'contour_line_levels': [70., 80., 90., 95.],\n 'contour_line_label_fmt': '%.0f',\n 'colorbar_ticks': np.linspace(50, 100, 21)[::4],\n 'colorbar_tick_fmt': '{:.0f}',\n 'colorbar_label': 'Availability [%]',\n 'extend': 'min',\n }\n plot_item01 = {\n 'data': 100.-nc.variables[\"p_ceiling_rank300\"][height_ceiling_id, :, :],\n 'contour_fill_levels': np.linspace(0, 80, 21),\n 'contour_line_levels': np.linspace(0, 80, 21)[::4][2:],\n 'contour_line_label_fmt': '%.0f',\n 'colorbar_ticks': np.linspace(0, 80, 21)[::4],\n 'colorbar_tick_fmt': '{:.0f}',\n 'colorbar_label': 'Availability [%]',\n }\n plot_item02 = {\n 'data': 100.-nc.variables[\"p_ceiling_rank1600\"][height_ceiling_id, :, :],\n 'contour_fill_levels': np.linspace(0, 45, 21),\n 'contour_line_levels': np.linspace(0, 45, 21)[::4][2:],\n 'contour_line_label_fmt': '%.0f',\n 'colorbar_ticks': np.linspace(0, 45, 21)[::4],\n 'colorbar_tick_fmt': '{:.0f}',\n 'colorbar_label': 'Availability [%]',\n }\n\n column_titles = [\"40 $W/m^2$\", \"300 $W/m^2$\", \"1600 $W/m^2$\"]\n plot_items = [plot_item00, plot_item01, plot_item02]\n\n eval_contour_fill_levels(plot_items)\n plot_panel_1x3_seperate_colorbar(plot_items, column_titles)\n\n plot_item10 = {\n 'data': (100.-nc.variables[\"p_ceiling_rank40\"][height_ceiling_id, :, :])-\n (100.-nc.variables[\"p_fixed_rank40\"][0, :, :]),\n 'contour_fill_levels': np.linspace(0., 22., 21),\n 'contour_line_levels': sorted([1.1, 2.2]+list(np.linspace(0., 22., 21)[::4][:-2])),\n 'contour_line_label_fmt': '%.1f',\n 'colorbar_ticks': np.linspace(0., 22., 21)[::4],\n 'colorbar_tick_fmt': '{:.0f}',\n 'colorbar_label': 'Availability increase [%]',\n }\n plot_item11 = {\n 'data': (100.-nc.variables[\"p_ceiling_rank300\"][height_ceiling_id, :, :])-\n (100.-nc.variables[\"p_fixed_rank300\"][0, :, :]),\n 'contour_fill_levels': np.linspace(0., 31., 21),\n 'contour_line_levels': np.linspace(0., 31., 21)[::4][:-2],\n 'contour_line_label_fmt': '%.1f',\n 'colorbar_ticks': np.linspace(0., 31., 21)[::4],\n 'colorbar_tick_fmt': '{:.0f}',\n 'colorbar_label': 'Availability increase [%]',\n }\n plot_item12 = {\n 'data': (100.-nc.variables[\"p_ceiling_rank1600\"][height_ceiling_id, :, :])-\n (100.-nc.variables[\"p_fixed_rank1600\"][0, :, :]),\n 'contour_fill_levels': np.linspace(0., 26., 21),\n 'contour_line_levels': np.linspace(0., 26., 21)[::4][:-2],\n 'contour_line_label_fmt': '%.1f',\n 'colorbar_ticks': np.linspace(0., 26., 21)[::4],\n 'colorbar_tick_fmt': '{:.0f}',\n 'colorbar_label': 'Availability increase [%]',\n }\n\n column_titles = None\n plot_items = [plot_item10, plot_item11, plot_item12]\n\n eval_contour_fill_levels(plot_items)\n plot_panel_1x3_seperate_colorbar(plot_items, column_titles)","def plot_all(self, cmap='Greys', size=(10,10)):\n\n fig, ((ax0, ax1), (ax2, ax3)) = plt.subplots(nrows=2,\n ncols=2,\n sharex=True,\n sharey=True)\n\n ax0.imshow(self.I, cmap=cmap)\n ax0.set_title(f'Original {self.I.shape}',\n fontsize=15)\n ax1.imshow(self.W, cmap=cmap)\n ax1.set_title(f'W Loadings {self.W.shape}',\n fontsize=15)\n ax2.imshow(self.H, cmap=cmap)\n ax2.set_title(f'H Loadings {self.H.shape}',\n fontsize=15)\n ax3.imshow(self.E, cmap=cmap)\n ax3.set_title(f'W * H with n={self._n_components} {self.E.shape}',\n fontsize=15)\n\n fig.set_figheight(size[0])\n fig.set_figwidth(size[1])\n fig.tight_layout()\n plt.show()","def SH_surface_plots(n_max=6,figsize=(15,15),fs=15,saveA=True,show=False,dpi=400,vis_type='real'):\n\n N = 100j\n\n for n in range(n_max+1):\n for m in range(n+1):\n plt.close('all')\n print(\"working on Y_%s^%s\" % (n,m) )\n\n PHI,THETA = np.mgrid[0:2*np.pi:N*2, 0:np.pi:N]\n if vis_type == 'real':\n R = sp.sph_harm(m,n,PHI,THETA).real\n if vis_type == 'modulus':\n r = sp.sph_harm(m,n,PHI,THETA)\n R = r * r.conjugate()\n if vis_type == 'unit':\n R = sp.sph_harm(m,n,PHI,THETA).real + 1\n\n X = np.abs(R) * np.sin(THETA) * np.cos(PHI)\n Y = np.abs(R) * np.sin(THETA) * np.sin(PHI)\n Z = np.abs(R) * np.cos(THETA)\n\n norm = colors.Normalize()\n fig, ax = plt.subplots(subplot_kw=dict(projection='3d'), figsize=(14,10))\n sm = cm.ScalarMappable(cmap=cm.seismic)\n ax.plot_surface(X, Y, Z, rstride=1, cstride=1, facecolors=cm.seismic(norm(R)))\n ax.set_title('real$(Y^%s_%s)$' % (m,n), fontsize=fs)\n ax.set_aspect(1)\n sm.set_array(R)\n fig.colorbar(sm, shrink=0.8)\n\n if saveA:\n fig.savefig('images/%s/%s_%s.png' % (vis_type,n,m), dpi=dpi)\n if show:\n plt.show()\n\n # print(\"\\n only +m values are used.\")\n # for n in range(n_max+1):\n # for m in range(n+1):\n # plt.close('all')\n # print(\"\\n n,m = %s,%s\" % (n,m) )\n #\n # R,X,Y,Z = harmonics(m,n)\n #\n # fig = plt.figure(figsize=figsize)\n # ax = plt.subplot(projection='3d')\n # ax.set_aspect(1)\n # ax.set_title(\"n: %s m: %s\" % (n,m), fontsize=fs+2)\n # ax.plot_surface(X,Y,Z,\\\n # cmap = cm.seismic,\n # norm = colors.Normalize( vmin=np.min(R),vmax=np.max(R) )\\\n # )\n #\n # if saveA:\n # fig.savefig('images/%s_%s.png' % (n,m), dpi=dpi)\n # if show:\n # plt.show()","def three_mass_FUV_maps(gal_indices,**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n fig = plt.figure(figsize=(15,14.5),constrained_layout=False)\n gs1 = fig.add_gridspec(nrows=3, ncols=3, wspace=0.0, hspace=0.0)\n\n rotate = False\n for row_i,gal_index in enumerate(gal_indices):\n\n R_max = p.R_max[row_i]\n\n ax1 = fig.add_subplot(gs1[row_i, 0])\n m = map_sim_property(add=True,ax=ax1,gal_index=gal_index, \\\n prop='m',R_max=R_max,vmin=0,vmax=7,\\\n pix_size_kpc=0.5,sim_type='simgas',cmap='viridis',log=True,colorbar=False,rotate=rotate,text=p.text)\n frame = plt.gca()\n #if row_i != 2: frame.axes.get_xaxis().set_visible(False)\n if row_i != 2: ax1.set_xlabel('')\n if row_i == 0:\n cbaxes = fig.add_axes([0.05, 0.93, 0.25, 0.01]) \n cb = plt.colorbar(m, orientation='horizontal', cax = cbaxes)\n cbaxes.xaxis.set_ticks_position('top')\n cb.ax.set_title(\"log $\\Sigma_{\\mathrm{gas}}$ [M$_{\\odot}$ kpc$^{-2}$]\")\n # Make a size indicator\n #ax1.plot([p.R_max-15,p.R_max-5],[-p.R_max+5,-p.R_max+5],lw=4,color='white')\n #ax1.text(p.R_max-16,-p.R_max+7,'10 kpc',color='white',fontsize=12)\n # Remove axes ticks\n ax1.tick_params(axis='x',which='both',labelbottom=False)\n ax1.tick_params(axis='y',which='both',labelleft=False)\n\n ax1 = fig.add_subplot(gs1[row_i, 1])\n m = star_map(add=True,ax=ax1,R_max=R_max,vmin=6,vmax=9,\\\n gal_index=gal_index,colorbar=False,rotate=rotate)\n frame = plt.gca()\n #if row_i != 2: frame.axes.get_xaxis().set_visible(False)\n if row_i != 2: ax1.set_xlabel('')\n frame.axes.get_yaxis().set_visible(False)\n if row_i == 0:\n cbaxes = fig.add_axes([0.375, 0.93, 0.25, 0.01]) \n cb = plt.colorbar(m, orientation='horizontal', cax = cbaxes) \n cbaxes.xaxis.set_ticks_position('top')\n cb.ax.set_title(\"log stellar age [yr]\")\n # Make a size indicator\n #ax1.plot([p.R_max-15,p.R_max-5],[-p.R_max+5,-p.R_max+5],lw=4,color='k')\n #ax1.text(p.R_max-16,-p.R_max+7,'10 kpc',color='k',fontsize=12)\n # Remove axes ticks\n ax1.tick_params(axis='x',which='both',labelbottom=False)\n ax1.tick_params(axis='y',which='both',labelleft=False)\n\n ax1 = fig.add_subplot(gs1[row_i, 2])\n m = FUV_map(add=True,ax=ax1,gal_index=gal_index,R_max=R_max,vmin=-10,vmax=3,select=p.select,cmap='twilight',colorbar=False,rotate=rotate)\n frame = plt.gca()\n #if row_i != 2: frame.axes.get_xaxis().set_visible(False)\n if row_i != 2: ax1.set_xlabel('')\n frame.axes.get_yaxis().set_visible(False)\n if row_i == 0:\n cbaxes = fig.add_axes([0.69, 0.93, 0.25, 0.01]) \n cb = plt.colorbar(m, orientation='horizontal', cax = cbaxes) \n cbaxes.xaxis.set_ticks_position('top')\n cb.ax.set_title('FUV flux [W/m$^2$/arcsec$^2$]')\n # Make a size indicator\n # if row_i == 2:\n # print('Adding size indicator')\n #ax1.text(p.R_max-16,-p.R_max+7,'10 kpc',color='w',fontsize=12)\n #ax1.plot([p.R_max-15,p.R_max-5],[-p.R_max+5,-p.R_max+5],lw=4,color='w')\n # else:\n ax1.text(R_max-16,-R_max+7,'10 kpc',color='k',fontsize=12)\n ax1.plot([R_max-15,R_max-5],[-R_max+5,-R_max+5],lw=4,color='k')\n # Remove axes ticks\n ax1.tick_params(axis='x',which='both',labelbottom=False)\n ax1.tick_params(axis='y',which='both',labelleft=False)\n\n # s = segs\n gs1.update(top=0.92,bottom=0.02,left=0.02,right=0.98)\n\n if p.savefig:\n if not os.path.isdir(p.d_plot + 'pretty/'): os.mkdir(p.d_plot + 'pretty/')\n plt.savefig('plots/pretty/mass_FUV_maps_%s%s.png' % (p.sim_name,p.sim_run),format='png',dpi=200)","def setup_figure(self):\n # How many data plots are we dealing with in each dimension?\n plots_x = self._dims[0] # Number of columns\n plots_y = self._dims[1] if len(self._dims) > 1 else 1 # Number of rows\n\n # Set up our base row count\n num_rows = plots_y + 1 # Add one more row for the update number\n height_ratios = [1] * plots_y + [0.25]\n num_cols = plots_x + 1 # Add one more column for the colorbar\n width_ratios = [1] * plots_x + [0.10]\n\n if self._is_multi:\n # If we have multiple resources, add another row for the resource legend\n num_rows += 1\n height_ratios.append(0.1)\n\n has_descr = True if len(self._env_str + self._event_str) > 0 else False\n if has_descr:\n # if we need to print some descriptive text, add another at the bottom\n # change this height ratio to make it larger\n num_rows += 1\n height_ratios.append(0.35)\n\n # Create our grid layout\n gs = mpl.gridspec.GridSpec(num_rows, num_cols,\n height_ratios=height_ratios,\n\n width_ratios=width_ratios)\n\n # Plot our category heatmaps\n ndx = 0 # Index into our experiment\n plots = [] # Plots from our experiment\n for col in range(plots_x):\n for row in range(plots_y):\n ax = plt.subplot(gs[row,col])\n base_cmap = self._cmap if not self._is_multi else ColorMaps.gray\n plot = plt.imshow(np.zeros(self._grid_shape), cmap=base_cmap,\n origin='upper', interpolation='nearest',\n vmin=self._vmin, vmax=self._vmax)\n ax.tick_params(axis='both', bottom='off', labelbottom='off',\n left='off', labelleft='off')\n if self._is_left_edge(ndx):\n ax.set_ylabel(self._fact2label(ndx,1))\n if self._is_bottom_edge(ndx):\n ax.set_xlabel(self._fact2label(ndx,0))\n plots.append(plot)\n pa = []\n for pp in self._post_plot:\n pa.append(pp.blit_build(ax, ax_ndx=ndx))\n ndx = ndx+1\n\n # Plot the colorbar\n norm = mpl.colors.Normalize(self._vmin, self._vmax)\n cax = plt.subplot( gs[0:plots_y,-1] ) # Across data rows, last column\n if not self._is_multi:\n cbar = mpl.colorbar.ColorbarBase(cax, cmap=self._cmap, norm=norm, orientation='vertical')\n else:\n cbar = mpl.colorbar.ColorbarBase(cax, cmap=ColorMaps.gray, norm=norm, orientation='vertical')\n cbar.set_label('Abundance')\n\n # Plot the update\n ax = plt.subplot(gs[plots_y,0:plots_x]) # The row after the data plots, across all data plot columns\n ax.tick_params(axis='both', bottom='off', labelbottom='off',\n left='off', labelleft='off')\n ax.set_frame_on(False)\n ax.set_ylim(0,1)\n ax.set_xlim(0,1)\n update = ax.text(0.5,0.25,'Update n/a', ha='center', va='bottom')\n\n # Plot the category legend if needed\n if self._is_multi:\n ax = plt.subplot(gs[plots_y+1,:-1]) # The row after the update axis, acros all data plot columns\n legend_handles = []\n for ndx,cat_name in enumerate(self._categories):\n legend_handles.append(mpl.patches.Patch(color=self._colors[ndx], label=cat_name))\n plt.legend(handles=legend_handles, loc='center', frameon=False, ncol=len(legend_handles))\n ax.tick_params(axis='both', bottom='off', labelbottom='off',\n left='off', labelleft='off')\n ax.set_frame_on(False)\n\n # If we have an environment and event strings, plot them in the final row across all columns\n if has_descr:\n ax = plt.subplot(gs[-1,:])\n desc = self._env_str + '\\n\\n' + self._event_str + '\\n\\n' + f'World: {self._world_size[0]} x {self._world_size[1]}'\n env = ax.text(0.05, 1, desc, ha='left', va='top', fontsize=7)\n ax.tick_params(axis='both', bottom='off', labelbottom='off',\n left='off', labelleft='off')\n ax.set_frame_on(False)\n\n # Title the figure\n plt.suptitle(self._title)\n\n # Store what we need to redraw each frame for blitting.\n # The values in this dictionary may be either a single element\n # or an iterable.\n self._to_draw = {'plots':plots, 'update':update, 'post_plot':pa}","def channel_maps_figure(source):\n # Load data cube\n data_filename = data_rebinned_filepaths[source]\n cube = SpectralCube.read(data_filename)\n # Switch units to km/s (optional)\n cube = cube.with_spectral_unit(u.km/u.s)\n # Get WCS object for 2D spatial image\n wcs_flat = cube[0, :, :].wcs\n # Calculate pixel scale for the spatial image\n pixel_scale = wcs_flat.proj_plane_pixel_scales()[0] # gives RA, Dec scales; pick one. They're almost certainly equal, so doesn't matter\n # Get velocity limits\n # For now, use all the channels in the saved FITS file; can limit them in the future if necessary\n v_lo, v_hi = cube.spectral_axis[0], cube.spectral_axis[-1]\n first_channel_idx = 0 # Using all channels\n last_channel_idx = cube.shape[0] - 1 # Using all channels\n print(\"First and last available channels \", v_lo, v_hi, \" at indices \", first_channel_idx, last_channel_idx)\n\n grid_shape = {\n 'ngc1977': (3, 4), # 12 channels\n 'rcw120': (4, 6), # 21 channels\n 'rcw49': (4, 8), # 31 channels\n }\n figsize = {\n # in inches; fine tune these to remove gaps between the channel maps\n 'ngc1977': (12, 8),\n 'rcw120': (16, 10),\n 'rcw49': (17, 11.5)\n }\n fig = plt.figure(figsize=figsize[source])\n # Matplotlib gridspec setup so that we can have a big colorbar on the side\n # mega_gridspec will contain all the channel maps and the Axes created within it serves as an anchor for the colorbar\n mega_gridspec = fig.add_gridspec(right=0.9, left=0.06, top=0.98, bottom=(0.08 if source=='rcw49' else 0.06))\n # Create a single Axes object from mega_gridspec; this will anchor the colorbar\n mega_axis = mega_gridspec.subplots()\n # Hide the bounding box for this large Axes object\n mega_axis.set_axis_off()\n # Create the channel map gridspec within the large gridspec\n gs = mega_gridspec[0,0].subgridspec(*grid_shape[source], hspace=0, wspace=0)\n # Memoize axes\n axes = {}\n def get_axis(index):\n # Index is 1D index of channel counting from first_channel_idx as 0.\n # In other words, index of the panel in the figure.\n # (if first_channel_idx == 0 then axis index == channel index)\n if index not in axes:\n axes[index] = fig.add_subplot(gs[np.unravel_index(index-first_channel_idx, grid_shape[source])], projection=wcs_flat)\n return axes[index]\n\n # Text defaults\n text_x = 0.05 if source=='rcw49' else 0.5\n text_y = 0.94\n # ha/va are horizontal and vertical alignment\n ha = 'left' if source=='rcw49' else 'center'\n # the color I use there is from Marc's collection of colorblind-friendly colors and works well against \"plasma\"\n default_text_kwargs = dict(fontsize=14, color='#ff7f00', ha=ha, va='center')\n tick_labelsize = 14\n tick_labelrotation = 50 if source=='rcw49' else 25\n tick_labelpad = 26 if source=='rcw49' else 13\n # Colors\n cmap = \"plasma\" # Image colormap\n beam_patch_ec = \"grey\" # edge color\n beam_patch_fc = \"white\" # face color\n # vlims for images (min and max for image colorscales in data units)\n vlims = {\n 'ngc1977': dict(vmin=0, vmax=40),\n 'rcw120': dict(vmin=0, vmax=25),\n 'rcw49': dict(vmin=0, vmax=17)\n }\n\n # Loop through channels and plot\n for channel_idx in range(first_channel_idx, last_channel_idx+1):\n velocity = cube.spectral_axis[channel_idx]\n channel_data = cube[channel_idx].to_value()\n\n print(first_channel_idx, channel_idx, last_channel_idx)\n ### print the [min, mean, median, max] for each panel so that we can find the best vlims (min, max) for all of them\n # print([f(channel_data) for f in (np.nanmin, np.nanmean, np.nanmedian, np.nanmax)])\n\n\n # Setup Axes\n ax = get_axis(channel_idx)\n # Remove x and y labels on individual panels (use the \"super\" titles)\n ax.set_xlabel(\" \")\n ax.set_ylabel(\" \")\n ss = ax.get_subplotspec()\n # Coordinate labels\n if ss.is_last_row() and ss.is_first_col():\n # Coordinates only on bottom left corner panel\n # Mess around with the rotation, position, and size of coordinate labels\n ax.coords[0].set_ticklabel(rotation=tick_labelrotation, rotation_mode='anchor', pad=tick_labelpad, fontsize=tick_labelsize, ha='right', va='top')\n ax.coords[1].set_ticklabel(fontsize=tick_labelsize)\n else:\n # If not the bottom left panel, no coordinates (panels have no space in between)\n # Hide coordinates\n ax.tick_params(axis='x', labelbottom=False)\n ax.tick_params(axis='y', labelleft=False)\n # Plot\n im = ax.imshow(channel_data, origin='lower', cmap=cmap, **vlims[source])\n # Label velocity on each panel\n ax.text(text_x, text_y, f\"{velocity.to_value():.0f} {velocity.unit.to_string('latex_inline')}\", transform=ax.transAxes, **default_text_kwargs)\n # Beam on every panel\n beam_patch = cube.beam.ellipse_to_plot(*(ax.transAxes + ax.transData.inverted()).transform([0.9, 0.1]), pixel_scale)\n beam_patch.set(alpha=0.9, facecolor=beam_patch_fc, edgecolor=beam_patch_ec)\n ax.add_artist(beam_patch)\n\n # Colorbar\n # Create a space to the right of the panels using the height/location of the mega_axis as an anchor\n cbar_ax = mega_axis.inset_axes([1.03, 0, 0.03, 1])\n cbar = fig.colorbar(im, cax=cbar_ax, label='T$_{\\\\rm MB}$ (K)')\n ticks = {\n # 'rcw120'\n }\n # cbar.set_ticks(ticks[source])\n # Titles\n fig.supxlabel(\"Right Ascension\")\n fig.supylabel(\"Declination\")\n\n dpi = 100\n dpi_stub = \"\" if dpi==100 else f\"_dpi{dpi}\"\n\n fig_save_name = f\"channel_maps_{source}{dpi_stub}.png\"\n fig.savefig(\n os.path.join(figure_save_path, fig_save_name),\n dpi=dpi\n )\n print(f\"Figure saved to {os.path.join(figure_save_path, fig_save_name)}\")","def animate(frames):\n plt.grid('on')\n ax = plt.gca()\n ax.set_xticks(np.arange(0.5, 10, 1))\n ax.set_yticks(np.arange(0.5, 10, 1))\n ax.set_xticklabels([])\n ax.set_yticklabels([])\n\n for i in range(len(env_list)):\n ax.imshow(env_list[i],cmap='binary')\n plt.pause(0.05)","def visualizeW1(images, vis_patch_side, hid_patch_side, iter, file_name=\"trained_\"):\n\n figure, axes = matplotlib.pyplot.subplots(nrows=hid_patch_side, ncols=hid_patch_side)\n index = 0\n\n for axis in axes.flat:\n \"\"\" Add row of weights as an image to the plot \"\"\"\n\n image = axis.imshow(images[index, :].reshape(vis_patch_side, vis_patch_side),\n cmap=matplotlib.pyplot.cm.gray, interpolation='nearest')\n axis.set_frame_on(False)\n axis.set_axis_off()\n index += 1\n\n \"\"\" Show the obtained plot \"\"\"\n file=file_name+str(iter)+\".png\"\n matplotlib.pyplot.savefig(file)\n print(\"Written into \"+ file)\n matplotlib.pyplot.close()","def plot_1d_systems(model):\n\n # Construct grid to evaluate the Green's function\n X_G, Y_G = np.meshgrid(model.x_G, model.y_G)\n x_G_star = X_G.flatten()[:, None]\n y_G_star = Y_G.flatten()[:, None]\n\n # Create the figure\n n_plots = max(model.n_input + 1, model.n_output)\n scaling = n_plots / 2\n fig, ax = newfig(1.0 * scaling, 1.5)\n ax.axis('off')\n gs = gridspec.GridSpec(n_plots, n_plots)\n gs.update(top=0.8, bottom=0.2, left=0.1, right=0.9,\n wspace=0.6 * scaling, hspace=0.6 * scaling)\n\n # Plot the Green's functions\n for i in range(model.n_output):\n for j in range(model.n_input):\n input_data = np.concatenate((x_G_star, y_G_star), 1)\n G_pred_identifier = model.sess.run(\n model.G_network[i][j].evaluate(input_data))\n G_pred = G_pred_identifier.reshape(X_G.shape)\n ax = plt.subplot(gs[i, j])\n h = ax.imshow(G_pred, interpolation='lanczos', cmap='jet',\n extent=[np.min(model.x_G), np.max(model.x_G), np.min(\n model.y_G), np.max(model.y_G)],\n origin='lower', aspect='auto')\n divider = make_axes_locatable(ax)\n cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n fig.colorbar(h, cax=cax)\n ax.set_xlabel('$x$')\n ax.set_ylabel('$y$', rotation=0, labelpad=12)\n ax.set_title('$G_{%d,%d}$' % (i + 1, j + 1), fontsize=10)\n\n # Plot the homogeneous solutions\n for i in range(model.n_output):\n N_pred = model.sess.run(model.idn_N_pred[i].evaluate(model.x))\n ax = plt.subplot(gs[i, model.n_input])\n ax.plot(model.x, model.U_hom[:, i], label='Exact')\n ax.plot(model.x, N_pred, dashes=[2, 2], label='Learned')\n divider = make_axes_locatable(ax)\n ymin = min([np.min(N_pred), np.min(model.U_hom[:, i])])\n ymax = max([np.max(N_pred), np.max(model.U_hom[:, i])])\n ax.set_xlim(np.min(model.x), np.max(model.x))\n ax.set_ylim(ymin, ymax)\n if ymax - ymin < 1e-2:\n ax.yaxis.set_major_formatter(MathTextSciFormatter(\"%1.1e\"))\n ax.set_xlabel('$x$')\n ax.set_title('Hom$_{%d}$' % (i + 1), fontsize=10)\n ax.legend()\n\n # Save the figure\n savefig(\"%s/%s_%s\" % (model.path_result, model.example_name,\n model.activation_name), crop=False)","def run_plots(self):\n # load the files\n self.pre_dark_file = os.path.join(self.input_dir, 'step_lastframe.fits')\n self.post_dark_file = os.path.join(self.input_dir, 'step_dark_current.fits')\n self.jump_file = os.path.join(self.input_dir, 'step_jump.fits')\n self.rate_file = os.path.join(self.input_dir, 'step_rate.fits')\n self.ramp_file = glob.glob(os.path.join(self.input_dir, '*.fits'))[0]\n\n # plots\n self.plot_jump_flags_image()\n self.plot_groupdq_flags(pixel=[884, 550])\n self.plot_ramps_pre_post_correction(pixel=[884, 550])","def plot(self):\n h = .02\n i=1\n bags_X = self.bags_X\n bags_y = self.bags_y\n fig1 = plt.figure(figsize=(45, 9))\n\n \n cm = plt.cm.RdBu\n cm_bright = ListedColormap(['#FF0000', '#0000FF'])\n \n for model in self.models:\n ax = plt.subplot(1, len(self.models) , i)\n X = pd.DataFrame(bags_X[i-1])\n y = pd.Series(bags_y[i-1])\n x_min, x_max = X[X.columns[0]].min() - .5, X[X.columns[0]].max() + .5\n y_min, y_max = X[X.columns[1]].min() - .5, X[X.columns[1]].max() + .5\n xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n Z = np.array(model.predict(pd.DataFrame(np.c_[xx.ravel(), yy.ravel()], columns=X.columns)))\n # print(Z[12])\n Z = Z.reshape(xx.shape)\n ax.contourf(xx, yy, Z, cmap=cm, alpha=.8)\n ax.scatter(X[X.columns[0]], X[X.columns[1]], c=y, cmap=cm_bright, edgecolors='k')\n # size=[1000*w for w in self.weights[i-1]]\n ax.set_xlim(xx.min(), xx.max())\n ax.set_ylim(yy.min(), yy.max())\n ax.set_xlabel(str(X.columns[0]))\n ax.set_ylabel(str(X.columns[1]))\n plt.title(\"Estimator \"+str(i))\n i+=1\n \n fig2 = plt.figure(figsize=(9,9))\n X = self.X\n y = self.y\n ax2 = plt.subplot(1,1,1)\n x_min, x_max = X[X.columns[0]].min() - .5, X[X.columns[0]].max() + .5\n y_min, y_max = X[X.columns[1]].min() - .5, X[X.columns[1]].max() + .5\n xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n Z = np.array(self.predict(pd.DataFrame(np.c_[xx.ravel(), yy.ravel()], columns=X.columns)))\n Z = Z.reshape(xx.shape)\n ax2.contourf(xx, yy, Z, cmap=cm, alpha=.8)\n # size=[1000*w for w in self.weights[i-2]]\n ax2.scatter(X[X.columns[0]], X[X.columns[1]], c=y, cmap=cm_bright, edgecolors='k')\n ax2.set_xlim(xx.min(), xx.max())\n ax2.set_ylim(yy.min(), yy.max())\n plt.title(\"Combined Decision Surface\")\n \n plt.tight_layout()\n plt.show()\n\n return [fig1,fig2]","def grid_frame(self, steps, figure_size=(12, 12)):\r\n\r\n x = self.seed\r\n counts = []\r\n for n in np.arange(0, steps):\r\n x, stats = self.update_grid(x)\r\n counts.append(stats)\r\n\r\n counts = np.array(counts)\r\n\r\n fig, ax = plt.subplots(figsize=figure_size)\r\n ax.get_xaxis().set_visible(False)\r\n ax.get_yaxis().set_visible(False)\r\n color_map = matplotlib.colors.ListedColormap(['white', 'black'])\r\n img = plt.imshow(x, interpolation='nearest', cmap=color_map)\r\n img.axes.grid(False)\r\n plt.title(self.title + ' | Step ' + str(steps))\r\n plt.show()\r\n\r\n return x, counts","def plot_maps(self, mode=0, target=1, gfilter=0):\r\n\r\n mpl.figure(1)\r\n\r\n mpl.imshow(self.avgimg, cmap=matplotlib.cm.gray, interpolation=None) # scipy.ndimage.gaussian_filter(ampmap, filter, order=0, mode='reflect'), cmap=matplotlib.cm.gray)\r\n\r\n mpl.colorbar()\r\n\r\n mpl.title('Average image')\r\n\r\n print ('target, mode: ', target, mode)\r\n\r\n max1 = np.amax(self.amplitudeImage1)\r\n\r\n if target > 1:\r\n\r\n max1 = np.amax([max1, np.amax(self.amplitudeImage2)])\r\n\r\n max1 = 10.0*int(max1/10.0)\r\n\r\n mpl.figure(2)\r\n\r\n mpl.subplot(2,2,4)\r\n\r\n ipy0, posl, coll = self.plot_averaged_amplitude()\r\n\r\n\r\n\r\n mpl.subplot(2,2,1)\r\n\r\n self.plot_amplitude_map(self.amplitudeImage1, max1, 'Amplitude Map1', filter=gfilter)\r\n\r\n mpl.subplot(2,2,3)\r\n\r\n self.plot_phase_map(self.phaseImage1, 'Phase Map1', filter=gfilter)\r\n\r\n for i, px in enumerate(posl):\r\n\r\n mpl.plot(px, self.ipy+ipy0, 'o-', markersize=5.0, markerfacecolor = coll[i], markeredgecolor='w')\r\n\r\n if target > 1:\r\n\r\n mpl.subplot(2,2,4)\r\n\r\n self.plot_phase_map(self.phaseImage1, 'Phase Map1', filter=gfilter)\r\n\r\n mpl.subplot(2,2,2)\r\n\r\n self.plot_fft()\r\n\r\n \r\n\r\n mpl.figure(3)\r\n\r\n mpl.title('Phase across center horizontally')\r\n\r\n # extract middle line\r\n\r\n sh = self.phaseImage1.shape\r\n\r\n iy0 = int(sh[1]/2)\r\n\r\n mpl.plot(self.phaseImage1[iy0, :], 'ko-')\r\n\r\n return\r\n\r\n \r\n\r\n if mode == 0:\r\n\r\n mpl.subplot(2,3,3)\r\n\r\n for i in range(0, self.nPhases):\r\n\r\n mpl.plot(ta.n_times, self.DF[:,5,5].view(ndarray))\r\n\r\n #mpl.plot(self.n_times, D[:,i*55+20, 60])\r\n\r\n mpl.hold('on')\r\n\r\n mpl.title('Waveforms')\r\n\r\n\r\n\r\n mpl.subplot(2,3,6)\r\n\r\n for i in range(0, self.nPhases):\r\n\r\n mpl.plot(ta.n_times, self.DF[:,5,5].view(ndarray))\r\n\r\n #mpl.plot(self.DF[:,i*55+20, 60])\r\n\r\n mpl.hold('on')\r\n\r\n mpl.title('FFTs')\r\n\r\n\r\n\r\n if mode == 1 and target > 1:\r\n\r\n \r\n\r\n mpl.subplot(2,3,2)\r\n\r\n mpl.title('Amplitude Map2')\r\n\r\n #scipy.ndimage.gaussian_filter(self.amplitudeImage2, 2, order=0, output=self.amplitudeImage2, mode='reflect')\r\n\r\n imga2 = mpl.imshow(scipy.ndimage.gaussian_filter(self.amplitudeImage2, gfilter, order=0, mode='reflect'))\r\n\r\n imga2.set_clim = (0.0, max1)\r\n\r\n mpl.colorbar()\r\n\r\n mpl.subplot(2,3,5)\r\n\r\n imgp2 = mpl.imshow(scipy.ndimage.gaussian_filter(self.phaseImage2, gfilter, order=0, mode='reflect'), cmap=matplotlib.cm.hsv)\r\n\r\n mpl.colorbar()\r\n\r\n imgp2.set_clim=(-np.pi/2.0, np.pi/2.0)\r\n\r\n mpl.title('Phase Map2')\r\n\r\n # doubled phase map\r\n\r\n mpl.subplot(2,3,6)\r\n\r\n #scipy.ndimage.gaussian_filter(self.phaseImage2, 2, order=0, output=self.phaseImage2, mode='reflect')\r\n\r\n np1 = scipy.ndimage.gaussian_filter(self.phaseImage1, gfilter, order=0, mode='reflect')\r\n\r\n np2 = scipy.ndimage.gaussian_filter(self.phaseImage2, gfilter, order=0, mode='reflect')\r\n\r\n dphase = np1 + np2\r\n\r\n #dphase = self.phaseImage1 - self.phaseImage2\r\n\r\n \r\n\r\n #scipy.ndimage.gaussian_filter(dphase, 2, order=0, output=dphase, mode='reflect')\r\n\r\n imgpdouble = mpl.imshow(dphase, cmap=matplotlib.cm.hsv)\r\n\r\n mpl.title('2x Phi map')\r\n\r\n mpl.colorbar()\r\n\r\n imgpdouble.set_clim=(-np.pi, np.pi)\r\n\r\n\r\n\r\n if mode == 2 or mode == 1:\r\n\r\n if self.phasex == []:\r\n\r\n self.phasex = np.random.randint(0, high=self.DF.shape[1], size=self.DF.shape[1])\r\n\r\n self.phasey = np.random.randint(0, high=self.DF.shape[2], size=self.DF.shape[2])\r\n\r\n\r\n\r\n mpl.subplot(2,3,3)\r\n\r\n sh = self.DF.shape\r\n\r\n spr = sh[2]/self.nPhases\r\n\r\n for i in range(0, self.nPhases):\r\n\r\n Dm = self.avgimg[i*spr,i*spr] # diagonal run\r\n\r\n mpl.plot(self.n_times, 100.0*(self.DF[:,self.phasex[i], self.phasey[i]]/Dm))\r\n\r\n mpl.hold('on')\r\n\r\n mpl.title('Waveforms')\r\n\r\n\r\n\r\n if mode == 2:\r\n\r\n mpl.subplot(2,3,6)\r\n\r\n sh = self.DF.shape\r\n\r\n x0 = int(sh[1]/2)\r\n\r\n y0 = int(sh[2]/2)\r\n\r\n for i in range(0, self.nPhases):\r\n\r\n mpl.plot(self.DF[1:,x0,y0])\r\n\r\n mpl.hold('on')\r\n\r\n mpl.title('FFTs')","def render(self, mode = 'human'):\n if mode == 'human':\n\n if self.is_2d:\n fig = plt.figure()\n for index, value in np.ndenumerate(self.board):\n if value == 1:\n plt.scatter(*index, c='red', s=1000, alpha=0.2)\n elif value == -1:\n plt.scatter(*index, c='blue', s=1000, alpha=0.2)\n plt.xlim(-1, self.dim[0])\n plt.ylim(-1, self.dim[1])\n plt.xticks([])\n plt.yticks([])\n plt.grid(True)\n\n if self.is_3d:\n fig = plt.figure()\n ax = Axes3D(fig)\n for index, value in np.ndenumerate(self.board):\n if value == 1:\n ax.scatter(*index, c='red', s=1000, alpha=0.2)\n elif value == -1:\n ax.scatter(*index, c='blue', s=1000, alpha=0.2)\n ax.set_xlim(0, self.dim[0] - 1)\n ax.set_ylim(0, self.dim[1] - 1)\n ax.set_zlim(0, self.dim[2] - 1)\n\n else:\n fig = plt.figure()\n ax = Axes3D(fig)\n for index, value in np.ndenumerate(self.board):\n if value == 1:\n ax.scatter(*index, c='red', s=1000, alpha=0.2)\n elif value == -1:\n ax.scatter(*index, c='blue', s=1000, alpha=0.2)\n\n ax.set_xlim(0, self.dim[0] - 1)\n ax.set_ylim(0, self.dim[1] - 1)\n ax.set_zlim(0, self.dim[2] - 1)\n ax.set_title('Nr of steps: ' + str(self.steps))\n\n plt.show()\n return fig","def gridPlot16(img_stack):\r\n F = plt.figure(figsize = (30,30))\r\n F.subplots_adjust(left = 0.05, right = 0.95)\r\n grid = ImageGrid(F, 142, nrows_ncols = (4,4), axes_pad = 0.0, share_all = True,\r\n label_mode = \"L\", cbar_location = \"top\", cbar_mode = \"single\")\r\n \r\n i = 0\r\n for img in img_stack[0:16]:\r\n im = grid[i].imshow(img, interpolation = \"nearest\", vmin = 0, vmax = 255)\r\n i += 1 \r\n grid.cbar_axes[0].colorbar(im)\r\n plt.savefig('gplot16.png')\r\n if 'gplot16.png' in os.listdir():\r\n plt.savefig('gplot16_2.png')\r\n# for cax in grid.cbar_axes:\r\n# cax.toggle_label(False)\r\n return","def gridPlot6(img_stack):\r\n F = plt.figure(figsize = (20,20))\r\n F.subplots_adjust(left = 0.05, right = 0.95)\r\n grid = ImageGrid(F, 142, nrows_ncols = (2,3), axes_pad = 0.0, share_all = True,\r\n label_mode = \"L\", cbar_location = \"top\", cbar_mode = \"single\")\r\n \r\n i = 0\r\n for img in img_stack[0:6]:\r\n im = grid[i].imshow(img, interpolation = \"nearest\", vmin = 0, vmax = 255)\r\n i += 1 \r\n grid.cbar_axes[0].colorbar(im)\r\n plt.savefig('gplot16.png')\r\n if 'gplot16.png' in os.listdir():\r\n plt.savefig('gplot16_2.png')\r\n# for cax in grid.cbar_axes:\r\n# cax.toggle_label(False)\r\n return","def plot_tiles(self):\n \n #TODO: adjust plot, border and text_box sizes\n \n ordered_projections = []\n flat_clusters = []\n colors_2D = []\n\n for cluster, nodes in clusters.items():\n for n in nodes:\n ordered_projections.append(projection_2D[n])\n\n for n in nodes:\n flat_clusters.append(n)\n\n for i, n in enumerate(G.nodes):\n if n in nodes:\n colors_2D.append(colors[i])\n\n grid_cols = int(np.ceil(np.sqrt(len(ordered_projections))))\n\n if len(ordered_projections) <= (grid_cols**2 - grid_cols):\n grid_rows = grid_cols - 1\n else:\n grid_rows = grid_cols\n\n #assuming images are same size, get shape\n l, w = ordered_projections[0].shape\n\n #add blank images to pack in grid\n while len(ordered_projections) < grid_rows*grid_cols:\n ordered_projections.append(np.zeros((l, w)))\n colors_2D.append((0., 0., 0.))\n flat_clusters.append('')\n\n f = Figure()\n\n grid = ImageGrid(f, 111, #similar to subplot(111)\n nrows_ncols=(grid_rows, grid_cols), #creates grid of axes\n axes_pad=0.05) #pad between axes in inch\n \n lw = 1.75\n text_box_size = 5 \n props = dict(boxstyle='round', facecolor='white')\n \n for i, (ax, im) in enumerate(zip(grid, ordered_projections)):\n ax.imshow(im, cmap='gray')\n\n for side, spine in ax.spines.items():\n spine.set_color(colors_2D[i])\n spine.set_linewidth(lw)\n\n ax.get_yaxis().set_ticks([])\n ax.get_xaxis().set_ticks([])\n\n text = str(flat_clusters[i])\n ax.text(1, 1, text, va='top', ha='left', bbox=props, size=text_box_size)\n \n newWindow = tk.Toplevel()\n newWindow.grid_rowconfigure(0, weight=1)\n newWindow.grid_columnconfigure(0, weight=1)\n \n #PLOT FRAME\n plotFrame = tk.Frame(newWindow, bg='lightgrey', width=600, height=400)\n plotFrame.grid(row=0, column=0, sticky='nsew')\n \n canvas = FigureCanvasTkAgg(f, plotFrame)\n canvas.draw()\n canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=True)\n canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True)\n canvas.figure.tight_layout()\n \n\n #TOOLBAR FRAME\n toolbarFrame = ttk.Frame(newWindow, width=600, height=100)\n toolbarFrame.grid(row=1, column=0, sticky='nsew')\n toolbarFrame.grid_propagate(0)\n \n toolbar = NavigationToolbar2Tk(canvas, toolbarFrame)\n toolbar.update()","def plot_HDres_histos_vs_z(\n df,\n nameout,\n threshold_var=\"class0\",\n threshold_list=[0.5, 0.7, 0.9],\n threshold_sign=\">\",\n):\n\n P = df[df[\"class0\"] > 0.5]\n Ias = df[df[\"target\"] == 0]\n\n TP = P[P[\"target\"] == 0]\n FP = P[P[\"target\"] != 0]\n\n sel_TP_dic = {}\n sel_FP_dic = {}\n for t in threshold_list:\n if threshold_sign == \">\":\n sel_TP_dic[t] = TP[TP[threshold_var] > t]\n sel_FP_dic[t] = FP[FP[threshold_var] > t]\n else:\n sel_TP_dic[t] = TP[TP[threshold_var] < t]\n sel_FP_dic[t] = FP[FP[threshold_var] < t]\n\n plt.clf()\n cm = CMAP\n fig = plt.figure(figsize=(14, 14))\n # gs = gridspec.GridSpec(4, 2, width_ratios=[3, 1], height_ratios=[2, 2, 1, 1])\n # gs.update(wspace=0.1, hspace=0.3)\n\n # # gridspec init\n # ax00 = plt.subplot(gs[0, 0]) # Hres Ia\n # ax10 = plt.subplot(gs[1, 0], sharex=ax00) # Hres CC\n # ax20 = plt.subplot(gs[2:, 0], sharex=ax00) # efficiency\n # ax01 = plt.subplot(gs[0, 1], sharey=ax00) # histo Ia\n # ax11 = plt.subplot(gs[1, 1], sharey=ax10) # histo CC\n # ax21 = plt.subplot(gs[2, 1]) # histo x1\n # ax31 = plt.subplot(gs[3, 1]) # histo c\n gs = gridspec.GridSpec(3, 3, height_ratios=[2, 2, 1])\n # gs.update(wspace=0.2, hspace=0.1)\n\n # gridspec init\n ax00 = plt.subplot(gs[0, 0:2]) # Hres Ia\n ax10 = plt.subplot(gs[1, 0:2], sharex=ax00) # Hres CC\n ax20 = plt.subplot(gs[2, 0]) # redshift dist\n ax01 = plt.subplot(gs[0, 2], sharey=ax00) # histo Ia\n ax11 = plt.subplot(gs[1, 2], sharey=ax10) # histo CC\n ax21 = plt.subplot(gs[2, 1]) # histo x1\n ax31 = plt.subplot(gs[2, 2]) # histo c\n\n # lines\n ax00.plot([0, 1.2], np.zeros(len([0, 1.2])), \"k:\")\n ax10.plot([0, 1.2], np.zeros(len([0, 1.2])), \"k:\")\n\n mubins = np.arange(-2, 2 + 0.1, 0.1)\n\n # Hres w. histogram\n def HRwhisto(\n df, sel_dic, ax_left, ax_right, threshold_sign, ylabel=\"TP\", visible=False\n ):\n if ylabel == \"TP\":\n sntyp = \"Ia\"\n else:\n sntyp = \"CC\"\n ax_left.scatter(\n df[\"SIM_REDSHIFT_CMB\"],\n df[\"delmu\"],\n c=df[\"class0\"],\n cmap=CMAP,\n vmin=0.5,\n vmax=1,\n s=8,\n )\n ax_left.errorbar(\n df[\"SIM_REDSHIFT_CMB\"],\n df[\"delmu\"],\n yerr=df[\"delmu_err\"],\n color=\"gray\",\n zorder=0,\n fmt=\"none\",\n marker=\"none\",\n )\n\n ax_left.set_ylim(-2, 2)\n ax_left.set_xlim(0, 1.2)\n ax_left.set_ylabel(f\"{ylabel} residual\", fontsize=18)\n ax_left.tick_params(labelsize=14)\n plt.setp(ax_left.get_xticklabels(), visible=visible)\n if visible is True:\n ax_left.set_xlabel(\"simulated redshift\", fontsize=18)\n for t in threshold_list:\n sel = sel_dic[t]\n n_SNe = len(sel)\n ax_right.hist(\n sel[\"delmu\"],\n orientation=\"horizontal\",\n histtype=\"step\",\n color=cm(t),\n bins=mubins,\n density=True,\n label=f\"{n_SNe} {sntyp} {threshold_sign} {t}\",\n lw=2,\n )\n ax_right.legend(loc=\"lower center\", prop={\"size\": 13})\n plt.setp(ax_right.get_yticklabels(), visible=False)\n plt.setp(ax_right.get_xticklabels(), visible=False)\n ax_right.plot(\n [ax_right.get_xlim()[0], ax_right.get_xlim()[1]],\n np.zeros(len([ax_right.get_xlim()[0], ax_right.get_xlim()[1]])),\n \"k:\",\n )\n\n HRwhisto(TP, sel_TP_dic, ax00, ax01, threshold_sign, ylabel=\"TP\", visible=False)\n HRwhisto(FP, sel_FP_dic, ax10, ax11, threshold_sign, ylabel=\"FP\", visible=True)\n\n # z histos\n n, bins_to_use, tmp = ax20.hist(\n Ias[\"SIM_REDSHIFT_CMB\"], histtype=\"step\", color=\"black\", bins=15, lw=3\n )\n\n for t in threshold_list:\n sel_TP = sel_TP_dic[t]\n sel_FP = sel_FP_dic[t]\n ax20.hist(\n sel_TP[\"SIM_REDSHIFT_CMB\"], histtype=\"step\", color=cm(t), bins=bins_to_use\n )\n ax20.hist(\n sel_FP[\"SIM_REDSHIFT_CMB\"],\n histtype=\"step\",\n color=cm(t),\n linestyle=\"--\",\n bins=bins_to_use,\n )\n ax20.set_xlim(0, 1.2)\n ax20.tick_params(labelsize=14)\n ax20.set_xlabel(\"simulated redshift\", fontsize=18)\n\n # hist stretch\n n, bins_to_use, tmp = ax21.hist(Ias[\"x1\"], color=\"black\", histtype=\"step\", lw=3)\n for t in threshold_list:\n sel_TP = sel_TP_dic[t]\n ax21.hist(\n sel_TP[\"x1\"],\n orientation=\"vertical\",\n histtype=\"step\",\n color=cm(t),\n bins=bins_to_use,\n lw=2,\n )\n ax21.set_xlabel(\"x1\", fontsize=18)\n ax21.yaxis.set_label_position(\"right\")\n ax21.set_xlim(-3, 3)\n ax21.tick_params(labelsize=14)\n # color histo\n n, bins_to_use, tmp = ax31.hist(Ias[\"c\"], color=\"black\", histtype=\"step\", lw=3)\n for t in threshold_list:\n sel_TP = sel_TP_dic[t]\n ax31.hist(\n sel_TP[\"c\"],\n orientation=\"vertical\",\n histtype=\"step\",\n color=cm(t),\n bins=bins_to_use,\n lw=2,\n )\n ax31.set_xlabel(\"c\", fontsize=18)\n ax31.set_xlim(-1, 1)\n ax31.tick_params(labelsize=14)\n ax31.yaxis.set_label_position(\"right\")\n\n gs.tight_layout(fig)\n plt.savefig(nameout)\n plt.close()\n del fig","def app_SN_separate_moisture_gradient(self, dfs, phase_dirs, sizer_val, styler_val):\n\n print('Currently plotting plot_SN_separate_moisture_gradient')\n\n for df, direc in zip(dfs, phase_dirs):\n # this iterates one or multiple times\n self.plotter.plot_SN_separate_moisture_gradient(\n df=df,\n phase_directory=direc,\n folder=self.large_test_data.folders['05_gradient_moisture'],\n sizer=self.formatter.sizer[sizer_val]['1x1_partial_width'],\n styler=self.formatter.styler[styler_val],\n xscale=self.xscale_var.get()\n )\n\n print('Done\\n')","def draw_grid(self):\n plt.imshow(py.array(\n map(lambda x: map(lambda y: mplc.colorConverter.to_rgb(colord[y]), x), self.create_grid(self.graph))),\n interpolation='nearest')\n plt.show()","def _step_plot_closure(self, step_number):\n for image_name, image, clean_net_output in zip(self.images_names, self.images, self.clean_nets_outputs):\n plot_image_grid(image_name + \"_watermark_clean_{}\".format(step_number),\n [np.clip(torch_to_np(self.watermark_net_output), 0, 1),\n np.clip(torch_to_np(clean_net_output), 0, 1)])\n plot_image_grid(image_name + \"_learned_image_{}\".format(step_number),\n [np.clip(torch_to_np(self.watermark_net_output) * torch_to_np(self.mask_net_output) +\n (1 - torch_to_np(self.mask_net_output)) * torch_to_np(clean_net_output),\n 0, 1), image])","def print_multipage(path: Path, tick: int, rgb_image: np.ndarray, heatmaps: np.ndarray):\n with PdfPages(path) as pdf:\n height, width, _channels = rgb_image.shape\n figsize = width / float(DPI), height / float(DPI)\n fig = plt.figure(figsize=figsize)\n ax = fig.add_axes([0, 0, 1, 1])\n ax.axis(\"off\")\n ax.imshow(rgb_image)\n pdf.attach_note(\"RGB camera image\")\n pdf.savefig(fig, bbox_inches=\"tight\")\n plt.close()\n\n rescaled_heatmaps = np.power(1.16, np.log(heatmaps))\n heatmaps_shape = rescaled_heatmaps.shape\n\n for command in range(heatmaps_shape[0]):\n for waypoint in range(heatmaps_shape[1]):\n fig = plt.figure()\n ax = fig.add_axes([0, 0, 1, 1])\n ax.axis(\"off\")\n ax.imshow(\n rescaled_heatmaps[command, waypoint, ...],\n cmap=\"inferno\",\n interpolation=\"nearest\",\n )\n pdf.attach_note(f\"command {command} heatmap {waypoint}\")\n pdf.savefig(fig, bbox_inches=\"tight\")\n plt.close()\n\n fig = plt.figure()\n ax = fig.add_axes([0, 0, 1, 1])\n ax.axis(\"off\")\n ax.imshow(\n np.sum(rescaled_heatmaps[command, ...], axis=0),\n cmap=\"inferno\",\n interpolation=\"nearest\",\n )\n pdf.attach_note(f\"command {command} combined heatmap\")\n pdf.savefig(fig, bbox_inches=\"tight\")\n plt.close()\n\n d = pdf.infodict()\n d[\"Title\"] = f\"intervention-learning tick {tick}\"\n d[\"Author\"] = \"intervention-learning\"","def plot_figure4():\n column_titles = [\"5th percentile\", \"32nd percentile\", \"50th percentile\"]\n\n fixed_height_ref = 100.\n fixed_height_id = list(fixed_heights).index(fixed_height_ref)\n\n plot_item0 = {\n 'data': nc.variables[\"p_fixed_perc5\"][fixed_height_id, :, :]*1e-3,\n 'contour_fill_levels': np.linspace(0, .03, 21),\n 'contour_line_levels': sorted([.003]+list(np.linspace(0, .03, 21)[::5])),\n 'contour_line_label_fmt': '%.3f',\n 'colorbar_ticks': np.linspace(0, .03, 21)[::5],\n 'colorbar_tick_fmt': '{:.3f}',\n 'colorbar_label': 'Power density [$kW/m^2$]',\n }\n plot_item1 = {\n 'data': nc.variables[\"p_fixed_perc32\"][fixed_height_id, :, :]*1e-3,\n 'contour_fill_levels': np.linspace(0, .45, 21),\n 'contour_line_levels': sorted([.04]+list(np.linspace(0, .45, 21)[::4])),\n 'contour_line_label_fmt': '%.2f',\n 'colorbar_ticks': np.linspace(0, .45, 21)[::4],\n 'colorbar_tick_fmt': '{:.2f}',\n 'colorbar_label': 'Power density [$kW/m^2$]',\n }\n plot_item2 = {\n 'data': nc.variables[\"p_fixed_perc50\"][fixed_height_id, :, :]*1e-3,\n 'contour_fill_levels': np.linspace(0, 1, 21),\n 'contour_line_levels': sorted([.1]+list(np.linspace(0, 1, 21)[::4])),\n 'contour_line_label_fmt': '%.2f',\n 'colorbar_ticks': np.linspace(0, 1, 21)[::4],\n 'colorbar_tick_fmt': '{:.2f}',\n 'colorbar_label': 'Power density [$kW/m^2$]',\n }\n\n plot_items = [plot_item0, plot_item1, plot_item2]\n\n eval_contour_fill_levels(plot_items)\n plot_panel_1x3_seperate_colorbar(plot_items, column_titles)","def plot_interaction_map(model, name, matrix, output_name, first_variable, second_variable, x_coord, y_coord, output_path): \n import matplotlib\n import matplotlib.cm as cm\n import matplotlib.pyplot as plt\n\n font = {'size' : 14}\n\n matplotlib.rc('font', **font)\n fig = plt.figure(figsize=(5,5))\n ax = plt.subplot()\n\n maxValue = np.max(np.abs(matrix))\n img = ax.imshow((matrix), cmap = cm.bwr, origin='lower', vmin = -min(maxValue, 6), vmax = min(maxValue, 6), interpolation='spline16')\n\n first_variable = '{}'.format(first_variable)\n second_variable = '{}'.format(second_variable)\n ax.set_ylabel(r'$x_i$ = ' + first_variable)\n ax.set_xlabel(r'$y_i$ = ' + second_variable)\n ax.axes.set_xticks([0, 50, 99])\n ax.axes.set_yticks([0, 50, 99])\n xticks = np.linspace(np.array(model.feature_limits[first_variable]).min(), np.array(model.feature_limits[first_variable]).max(), 3)\n yticks = np.linspace(np.array(model.feature_limits[second_variable]).min(), np.array(model.feature_limits[second_variable]).max(), 3)\n ax.scatter([x_coord], [y_coord], marker='o', color='white', s = 250, edgecolors='black', linewidth=3)\n\n ax.set_yticklabels([xticks[tind] for tind in range(3)])\n ax.set_xticklabels([yticks[tind] for tind in range(3)])\n ax.axis([0, (100) - 1, 0, (100) - 1])\n\n # ax.scatter([x_coord_linear], [y_coord_linear], marker='o', color='blue', s = 250, edgecolors='black', linewidth=3)\n t = ax.set_title(r'$\\mathregular{\\frac{\\delta ^2 F(\\bar{x})}{\\delta x_i \\delta x_j}}$')\n # t = ax.set_title('{} and {} - '.format(first_variable, second_variable) + r'$\\mathregular{\\frac{\\delta ^2 F(\\bar{x})}{\\delta x_i \\delta x_j}}$')\n t.set_position([.5, 1.025])\n from mpl_toolkits.axes_grid1 import make_axes_locatable\n divider = make_axes_locatable(ax)\n cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n cb = plt.colorbar(img, cax=cax)\n cb.set_label(\"Nomralized mixed derivative\", rotation=90)\n plt.savefig('{}/{}_{}_{}_{}_nonlinear_map.pdf'.format(output_path, name, output_name, first_variable, second_variable), transparent=True, bbox_inches='tight', format='pdf', dpi=600)\n # plt.close('all')","def _nd_plot_grid(self, **kwargs):\n\n from matplotlib.lines import Line2D\n from pesummary.core.plots.publication import pcolormesh\n\n # only add to corner plot if plotting on an existing figure\n if \"fig\" not in kwargs:\n raise TypeError(\n \"Can only add Grid results to an existing corner plot showing samples\"\n )\n\n colors = kwargs.pop(\"colors\")\n\n fig = kwargs.pop(\"fig\")\n ax = fig.axes\n\n quantiles = kwargs.pop(\"quantiles\", None)\n grid2d = kwargs.pop(\"grid2d\", False)\n\n for i, (label, grid) in enumerate(self._grids.items()):\n plotkwargs = {}\n plotkwargs[\"color\"] = colors[i]\n plotkwargs[\"label\"] = label\n\n axidx = 0\n for j, param in enumerate(self.parameters):\n x = grid[0].sample_points[param]\n pdf = np.exp(\n grid[0].marginalize_ln_posterior(not_parameters=param) - grid[1]\n )\n\n ax[axidx].plot(x, pdf, **plotkwargs)\n\n if quantiles is not None:\n low, high = self._credible_interval_grid(\n grid[0], param, interval=quantiles\n )\n ax[axidx].axvline(low, color=colors[i], ls=\"--\")\n ax[axidx].axvline(high, color=colors[i], ls=\"--\")\n\n # plot 2D posteriors\n if grid2d:\n meshkwargs = {}\n meshkwargs[\"zorder\"] = kwargs.get(\"zorder\", -10)\n meshkwargs[\"shading\"] = kwargs.get(\"shading\", \"gouraud\")\n\n if \"cmap\" not in kwargs:\n if colors[i] in COLOR_MAP:\n meshkwargs[\"cmap\"] = COLOR_MAP[colors[i]]\n else:\n meshkwargs[\"cmap\"] = kwargs[\"cmap\"]\n\n for k in range(j + 1, self._num_parameters):\n y = grid[0].sample_points[self.parameters[k]]\n density = np.exp(\n grid[0].marginalize_ln_posterior(\n not_parameters=[param, self.parameters[k]]\n )\n - grid[1]\n )\n\n # set orientation of the 2D grid\n p1idx = grid[0].parameter_names.index(param)\n p2idx = grid[0].parameter_names.index(self.parameters[k])\n if p1idx < p2idx:\n # transpose density\n density = density.T\n\n axyidx = axidx + (k - j) * self._num_parameters\n pcolormesh(x, y, density, ax=ax[axyidx], **meshkwargs)\n\n axidx += self._num_parameters + 1\n\n # update the legend\n handles = []\n for legtext, leghandle in zip(\n fig.legends[0].texts, fig.legends[0].legendHandles\n ):\n label = legtext.get_text()\n legcolor = leghandle.get_color()\n\n handles.append(Line2D([], [], color=legcolor, label=label))\n\n for i, label in enumerate(self._grids):\n for line in ax[0].get_lines():\n linecolor = line.get_color()\n # test that colours are the same\n if linecolor == colors[i]:\n handles.append(Line2D([], [], color=linecolor, label=label))\n break\n\n # remove original legend\n fig.legends = []\n\n # re-add legend\n fig.legend(handles=handles, frameon=False, loc=\"upper right\")\n\n return fig","def plot_prediction_grid (xx, yy, prediction_grid, filename):\n from matplotlib.colors import ListedColormap\n background_colormap = ListedColormap ([\"hotpink\",\"lightskyblue\", \"yellowgreen\"])\n observation_colormap = ListedColormap ([\"red\",\"blue\",\"green\"])\n plt.figure(figsize =(10,10))\n plt.pcolormesh(xx, yy, prediction_grid, cmap = background_colormap, alpha = 0.5)\n plt.scatter(predictors[:,0], predictors [:,1], c = outcomes, cmap = observation_colormap, s = 50)\n plt.xlabel('Variable 1'); plt.ylabel('Variable 2')\n plt.xticks(()); plt.yticks(())\n plt.xlim (np.min(xx), np.max(xx))\n plt.ylim (np.min(yy), np.max(yy))\n plt.savefig(filename)","def check_plots(tracklist_subset, tracklist):\n\n for trial in tracklist_subset: # Iterates over all available trials\n\n # Scale time for colormap\n scaled_time = (tracklist[trial]['data'].index.values -\n tracklist[trial]['data'].index.values.min()) / \\\n tracklist[trial]['data'].index.values.ptp()\n timemax = max(tracklist[trial]['data'].index.values)\n data = tracklist[trial]['data']\n colors = plt.cm.cubehelix(scaled_time)\n m = cm.ScalarMappable(cmap=cm.cubehelix)\n m.set_array(tracklist[trial]['data'].index.values)\n\n # filename = str(trial) + '.pdf'\n\n fig = plt.figure(figsize=(20, 20))\n fig.suptitle(tracklist[trial]['sequence'] + ' ' +\n tracklist[trial]['behavior'])\n\n ax1 = fig.add_subplot(4, 2, 1, projection='3d')\n ax1.set_title('Pt 1 Position')\n ax1.scatter3D(xs=tracklist[trial]['data']['pt1x_smth'],\n ys=tracklist[trial]['data']['pt1y_smth'],\n zs=tracklist[trial]['data']['pt1z_smth'],\n zdir='z', s=3, c=colors, marker='o',\n edgecolor='none') # 3D Scatter plot\n ax1.autoscale(enable=True, tight=True)\n ax1.set_xlabel('X position')\n ax1.set_ylabel('Y position')\n ax1.set_zlabel('Z position')\n plt.colorbar(m, shrink=0.5, aspect=10)\n\n ax2 = fig.add_subplot(4, 2, 3)\n ax2.plot(data.index.values, data['pt1y_v_smth'], 'bo')\n ax2.set_ylabel('Y velocity (cm/s)', color='b')\n ax2.tick_params('y', colors='b')\n\n ax3 = fig.add_subplot(4, 2, 5)\n ax3.plot(data.index.values, data['pt1_net_v'], 'bo')\n ax3.set_ylabel('Net Velocity (cm/s)', color='b')\n ax3.tick_params('y', colors='b')\n\n ax4 = fig.add_subplot(4, 2, 7)\n ax4.plot(data.index.values, data['pt1_net_a'], 'bo')\n ax4.set_ylabel('Net accel (cm/s2)', color='b')\n ax4.tick_params('y', colors='b')\n\n ax5 = fig.add_subplot(4, 2, 2, projection='3d')\n ax5.set_title('Pt 2 Position')\n ax5.scatter3D(xs=tracklist[trial]['data']['pt2x_smth'],\n ys=tracklist[trial]['data']['pt2y_smth'],\n zs=tracklist[trial]['data']['pt2z_smth'],\n zdir='z', s=3, c=colors, marker='o',\n edgecolor='none') # 3D Scatter plot\n ax5.autoscale(enable=True, tight=True)\n ax5.set_xlabel('X position')\n ax5.set_ylabel('Y position')\n ax5.set_zlabel('Z position')\n plt.colorbar(m, shrink=0.5, aspect=10)\n\n ax6 = fig.add_subplot(4, 2, 4)\n ax6.plot(data.index.values, data['pt2y_v_smth'], 'bo')\n ax6.set_ylabel('Y velocity (cm/s)', color='b')\n ax6.tick_params('y', colors='b')\n\n ax7 = fig.add_subplot(4, 2, 6)\n ax7.plot(data.index.values, data['pt2_net_v'], 'bo')\n ax7.set_ylabel('Net Velocity (cm/s)', color='b')\n ax7.tick_params('y', colors='b')\n\n ax8 = fig.add_subplot(4, 2, 8)\n ax8.plot(data.index.values, data['pt2_net_a'], 'bo')\n ax8.set_ylabel('Net accel (cm/s2)', color='b')\n ax8.tick_params('y', colors='b')\n\n plt.show()","def show_2d_projections(self):\n\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n fig, axs = plt.subplots(1, 3)\n for i in range(3):\n plt.sca(axs[i])\n io.imshow(self.image.max(i), cmap='viridis')","def montage(W):\n import matplotlib.pyplot as plt\n fig, ax = plt.subplots(2, 5)\n for i in range(2):\n for j in range(5):\n im = W[i * 5 + j, :].reshape(32, 32, 3, order='F')\n sim = (im - np.min(im[:])) / (np.max(im[:]) - np.min(im[:]))\n sim = sim.transpose(1, 0, 2)\n ax[i][j].imshow(sim, interpolation='nearest')\n ax[i][j].set_title(\"y=\" + str(5 * i + j))\n ax[i][j].axis('off')\n #plt.savefig(\"plots/ \"+fname +\".png\")\n plt.show()","def plot_steps(self, coord_data, coord_base=\"umap\", plot_size=3, dpi=300):\n if len(self.step_data) == 0:\n print(\"No merge step to plot\")\n return\n if isinstance(coord_data, anndata.AnnData):\n plot_data = _adata_to_coord_data(coord_data, coord_base)\n else:\n plot_data = coord_data.copy()\n self.plot_before_after(coord_data, coord_base=coord_base, plot_size=plot_size, dpi=dpi)\n\n # initial clusters\n for i, step in enumerate(sorted(self.step_data.keys())):\n (\n cur_y,\n cmat,\n r1_cmat,\n r2_cmat,\n cluster_map,\n score,\n step_size,\n ) = self.step_data[step]\n fig, axes = plt.subplots(figsize=(4 * plot_size, plot_size), ncols=4, dpi=dpi)\n ax = axes[0]\n sns.heatmap(ax=ax, data=cmat, cbar=None, cmap=\"Reds\")\n ax.set(title=\"Confusion Matrix\", ylabel=f\"Step {step}\")\n ax = axes[1]\n sns.heatmap(ax=ax, data=r1_cmat, cbar=None, cmap=\"Reds\")\n ax.set(title=\"R1 Norm.\")\n ax = axes[2]\n sns.heatmap(ax=ax, data=r2_cmat, cbar=None, cmap=\"Reds\")\n ax.set(title=\"R2 Norm.\")\n ax = axes[3]\n if len(cluster_map) > 0:\n involved_clusters = set(list(cluster_map.keys()) + list(cluster_map.values()))\n cur_y = pd.Series(cur_y, index=plot_data.index)\n cur_y = cur_y.apply(lambda i: cluster_map[i] if i in cluster_map else i)\n # if not involved, mark as -1\n cur_y = cur_y.apply(lambda i: i if i in involved_clusters else -1)\n plot_data[\"cur_y\"] = cur_y\n n_color = cur_y.unique().size\n colors = list(sns.color_palette(\"tab10\", n_color))\n cmap = {c: colors.pop() if c != -1 else (0.9, 0.9, 0.9) for c in cur_y.unique()}\n categorical_scatter(\n ax=ax,\n data=plot_data,\n coord_base=coord_base,\n hue=\"cur_y\",\n palette=cmap,\n s=3,\n )\n ax.set(title=f\"Step {step} Cells After Merge\")\n else:\n ax.axis(\"off\")\n return","def plot_prediction_grid(xx, yy, prediction_grid, filename):\n from matplotlib.colors import ListedColormap\n background_colormap = ListedColormap ([\"hotpink\",\"lightskyblue\", \"yellowgreen\"])\n observation_colormap = ListedColormap ([\"red\",\"blue\",\"green\"])\n plt.figure(figsize =(10,10))\n plt.pcolormesh(xx, yy, prediction_grid, cmap = background_colormap, alpha = 0.5)\n plt.scatter(predictors[:,0], predictors [:,1], c = outcomes, cmap = observation_colormap, s = 50)\n plt.xlabel('Variable 1'); plt.ylabel('Variable 2')\n plt.xticks(()); plt.yticks(())\n plt.xlim (np.min(xx), np.max(xx))\n plt.ylim (np.min(yy), np.max(yy))\n plt.savefig(filename)","def plot_figure5():\n column_titles = [\"50 - 150m\", \"0 - 10km\", \"Ratio\"]\n\n plot_item0 = {\n 'data': p_integral_mean[0, :, :]*1e-6,\n 'contour_line_levels': np.linspace(0, .31, 21)[::4],\n 'contour_fill_levels': np.linspace(0, .31, 21),\n 'colorbar_ticks': np.linspace(0, .31, 21)[::4],\n 'colorbar_tick_fmt': '{:.2f}',\n 'colorbar_label': '[$MWm/m^2$]',\n }\n plot_item1 = {\n 'data': p_integral_mean[1, :, :]*1e-6,\n 'contour_line_levels': np.linspace(0, 65, 21)[::4],\n 'contour_fill_levels': np.linspace(0, 65, 21),\n 'colorbar_ticks': np.linspace(0, 65, 21)[::4],\n 'colorbar_tick_fmt': '{:.0f}',\n 'colorbar_label': '[$MWm/m^2$]',\n }\n plot_item2 = {\n 'data': plot_item1['data']/plot_item0['data'],\n 'log_scale': True,\n 'contour_line_levels': [300., 600.],\n 'contour_fill_levels': np.logspace(np.log10(100.0), np.log10(6700.0), num=16),\n 'colorbar_ticks': [100., 300., 1000., 3000.],\n 'colorbar_tick_fmt': '{:.0f}',\n 'colorbar_label': 'Increase factor [-]',\n }\n\n plot_items = [plot_item0, plot_item1, plot_item2]\n\n eval_contour_fill_levels(plot_items)\n plot_panel_1x3_seperate_colorbar(plot_items, column_titles)","def plot_ncmc_work(self, filename):\n with PdfPages(filename) as pdf:\n for envname in self.get_environments():\n modname = 'NCMCEngine'\n work = dict()\n for direction in ['delete', 'insert']:\n varname = '/' + envname + '/' + modname + '/' + 'work_' + direction\n try:\n # TODO: For now, we analyze all but the last sample, so that this can be run on active simulations.\n # Later, we should find some way to omit the last sample only if it is nonsensical.\n work[direction] = self._ncfile[varname][:-1,:]\n print('Found %s' % varname)\n except Exception as e:\n pass\n\n def plot_work_trajectories(pdf, work, title=\"\"):\n \"\"\"Generate figures for the specified switching legs.\n \"\"\"\n plt.figure(figsize=(12, 8))\n\n nrows = 2\n ncols = 6\n workcols = 2\n for (row, direction) in enumerate(['delete', 'insert']):\n #\n # Plot work vs step\n #\n\n col = 0\n plt.subplot2grid((nrows,ncols), (row, col), colspan=(ncols-workcols))\n\n # Plot average work distribution in think solid line\n plt.plot(work[direction].mean(0), 'k-', linewidth=1.0, alpha=1.0)\n # Plot bundle of work trajectories in transparent lines\n plt.plot(work[direction].T, 'k-', linewidth=0.5, alpha=0.3)\n # Adjust axes to eliminate large-magnitude outliers (keep 98% of data in-range)\n workvals = np.ravel(np.abs(work[direction]))\n worklim = np.percentile(workvals, 98)\n nsteps = work[direction].shape[1]\n plt.axis([0, nsteps, -worklim, +worklim])\n # Label plot\n if row == 1: plt.xlabel('steps')\n plt.ylabel('work / kT')\n plt.title(\"%s NCMC in environment '%s' : %s\" % (title, envname, direction))\n plt.legend(['average work', 'NCMC attempts'])\n\n #\n # Plot work histogram\n #\n\n col = ncols - workcols\n plt.subplot2grid((nrows,ncols), (row, col), colspan=workcols)\n\n # Plot average work distribution in think solid line\n #nbins = 40\n workvals = work[direction][:-1,-1]\n #plt.hist(workvals, nbins)\n if workvals.std() != 0.0:\n sns.distplot(workvals, rug=True)\n else:\n print('workvals has stddev of zero')\n print(workvals)\n # Adjust axes to eliminate large-magnitude outliers (keep 98% of data in-range)\n #worklim = np.percentile(workvals, 98)\n #oldaxis = plt.axis()\n #plt.axis([-worklim, +worklim, 0, oldaxis[3]])\n # Label plot\n if row == 1: plt.xlabel('work / kT')\n plt.title(\"total %s work\" % direction)\n\n pdf.savefig() # saves the current figure into a pdf page\n plt.close()\n\n if len(work) > 0:\n # Plot work for all chemical transformations.\n plot_work_trajectories(pdf, work, title='(all transformations)')\n\n # Plot work separated out for each chemical transformation\n #[niterations, nsteps] = work.shape\n #transformations = dict()\n #for iteration in range(niterations):\n # plot_work_trajectories(pdf, work, title='(all transformations)')","def generate_image_grid(sess, df, filenames,op, op2):\n #x_points = np.arange(0, 1, 1.5).astype(np.float32)\n #y_points = np.arange(0, 1, 1.5).astype(np.float32)\n\n nx, ny = 12, 1\n #plt.subplot()\n gs = gridspec.GridSpec(nx, ny, hspace=1, wspace=0.05)\n # input_x = sess.run(op2, feed_dict={x_input: df[0:24]})\n #\n # plt.imshow(np.array(df[0].tolist()).reshape(28, 28), cmap='gray')\n # plt.show()\n # x = sess.run(op, feed_dict={decoder_input: input_x[0].reshape(1,2)})\n # img = np.array(x.tolist()).reshape(28, 28)\n #\n # plt.imshow(img, cmap='gray')\n # plt.show()\n\n \"\"\" grid \"\"\"\n input_x = sess.run(op2, feed_dict={x_input: df[0:24]})\n for i, g in enumerate(gs):\n\n x = sess.run(op, feed_dict={decoder_input: input_x[i].reshape(1,2)})\n ax = plt.subplot(g)\n img = np.array(x.tolist()).reshape(28, 28)\n ax.imshow(img, cmap='gray')\n ax.set_xticks([])\n ax.set_yticks([])\n #ax.set_aspect('auto')\n ax.set_title(filenames[i])\n plt.show()\n\n for i, g in enumerate(gs):\n\n ax = plt.subplot(g)\n img = np.array(df[i].tolist()).reshape(28, 28)\n ax.imshow(img, cmap='gray')\n ax.set_xticks([])\n ax.set_yticks([])\n #ax.set_aspect('auto')\n ax.set_title(filenames[i])\n plt.show()","def distribution_horizontale_par_blocs(args):\n number_files = [2,5,10,20]; fact_w = 1; fact_h = 1;\n rep = args[\"path_save\"]+args[\"correction\"]+\\\n \"/data_p_\"+str(args[\"p_value\"])+\"/distribution/\";\n fig = plt.figure(); default_size = fig.get_size_inches(); \n f25, ax_arrs_k25 = plt.subplots(2, 2, figsize=(default_size[0]*fact_w, \\\n default_size[1]*fact_h), \\\n );\n \n cpt1 = 0; cpt2 = 1; tab_bins = [20, 40, 80,100, 100, 100]\n for ind, k in enumerate(number_files[:len(number_files)//2]) :\n df = pd.read_csv(rep+args[\"fichier_prefix\"] +str(k)+args[\"ext\"], \\\n names=[\"cpt\",\"moy_dc\",\"moy_dh\", \"aretes_matE\", \"correl_dh_dl\"], \\\n sep=';')\n N_graphs = df[\"moy_dc\"].count();\n \n# bins = range(0, (ind+1)*args[\"num_bins\"]);\n bins = range(0, tab_bins[ind]);\n max_count_dl, max_count_dh = count_max_df(df)\n \n # plot ax1\n (mu, sigma) = norm.fit(df[\"moy_dc\"]); # best fit of data\n sns.distplot(df[\"moy_dc\"], ax = ax_arrs_k25[cpt1, ind], \\\n bins = bins, kde = False)\n ax_arrs_k25[cpt1, ind].set(xlabel= \"moy_distance_correction\", \\\n ylabel= \"nombre_graphe\", \\\n title = \"distance de correction pour \\n \"+ str(k)+ \\\n \" cases modifiees\")\n ax_arrs_k25[cpt1, ind].plot([k+1,k+1], (0,max_count_dl), 'r--' )\n ax_arrs_k25[cpt1, ind].set_yticklabels(['{:3.2f}%'.format(x*100/N_graphs) \\\n for x in ax_arrs_k25[cpt1, ind].get_yticks()])\n \n #plot ax2\n (mu, sigma) = norm.fit(df[\"moy_dh\"]); # best fit of data\n sns.distplot(df[\"moy_dh\"], ax = ax_arrs_k25[cpt2, ind], \\\n bins = bins, kde = False)\n ax_arrs_k25[cpt2, ind].set(xlabel= \"moy_distance_correction\", \\\n ylabel= \"nombre_graphe\", \\\n title = \"distance Hamming pour \\n \"+ str(k)+\\\n \" cases modifiees\")\n ax_arrs_k25[cpt2, ind].plot([k+1,k+1], (0,max_count_dl), 'r--' )\n ax_arrs_k25[cpt2, ind].set_yticklabels(['{:3.2f}%'.format(x*100/N_graphs) \\\n for x in ax_arrs_k25[cpt2, ind].get_yticks()])\n \n plt.tight_layout(pad=0.4, w_pad=0.5, h_pad=1.0)\n plt.grid(True)\n plt.savefig(args[\"path_save\"]+args[\"correction\"]+\"/courbes/\"+\\\n \"distributionMoyDCDHp05k25.jpeg\",\\\n dpi= 250)\n \n fig = plt.figure(); default_size = fig.get_size_inches(); \n f1020, ax_arrs_k1020 = plt.subplots(2, 2, figsize=(default_size[0]*fact_w, \\\n default_size[1]*fact_h), \\\n ); \n for ind, k in enumerate(number_files[len(number_files)//2:]) :\n df = pd.read_csv(rep+args[\"fichier_prefix\"] +str(k)+args[\"ext\"], \\\n names=[\"cpt\",\"moy_dc\",\"moy_dh\", \"aretes_matE\", \"correl_dh_dl\"], \\\n sep=';')\n N_graphs = df[\"moy_dc\"].count();\n \n bins = range(0, tab_bins[len(number_files)//2:][ind]);\n max_count_dl, max_count_dh = count_max_df(df)\n \n # plot ax1\n (mu, sigma) = norm.fit(df[\"moy_dc\"]); # best fit of data\n sns.distplot(df[\"moy_dc\"], ax = ax_arrs_k1020[cpt1, ind], \\\n bins = bins, kde = False)\n ax_arrs_k1020[cpt1, ind].set(xlabel= \"moy_distance_correction\", \\\n ylabel= \"nombre_graphe\", \\\n title = \"distance de correction pour \\n \"+ str(k)+ \\\n \" cases modifiees\")\n ax_arrs_k1020[cpt1, ind].plot([k+1,k+1], (0,max_count_dl), 'r--' )\n ax_arrs_k1020[cpt1, ind].set_yticklabels(['{:3.2f}%'.format(x*100/N_graphs) \\\n for x in ax_arrs_k1020[cpt1, ind].get_yticks()]) \n \n #plot ax2\n (mu, sigma) = norm.fit(df[\"moy_dh\"]); # best fit of data\n sns.distplot(df[\"moy_dh\"], ax = ax_arrs_k1020[cpt2, ind], \\\n bins = bins, kde = False)\n ax_arrs_k1020[cpt2, ind].set(xlabel= \"moy_distance_correction\", \\\n ylabel= \"nombre_graphe\", \\\n title = \"distance Hamming pour \\n \"+ str(k)+\\\n \" cases modifiees\")\n ax_arrs_k1020[cpt2, ind].plot([k+1,k+1], (0,max_count_dl), 'r--' )\n ax_arrs_k1020[cpt2, ind].set_yticklabels(['{:3.2f}%'.format(x*100/N_graphs) \\\n for x in ax_arrs_k1020[cpt2, ind].get_yticks()])\n# fig = ax_arrs[0,0].figure ;\n# fig.text(0.5,0.04, \"Some very long and even longer xlabel\", ha=\"center\", va=\"center\")\n# fig.text(0.05,0.5, \"Some quite extensive ylabel\", ha=\"center\", va=\"center\", rotation=90)\n\n \n plt.tight_layout(pad=0.4, w_pad=0.5, h_pad=1.0)\n plt.grid(True)\n plt.savefig(args[\"path_save\"]+args[\"correction\"]+\"/courbes/\"+\\\n \"distributionMoyDCDHp05k1020.jpeg\",\\\n dpi= 250) #190 ","def visualize_decomposition(maps_filename, timecourses_filename, out_filename, mask_nib, hgap=20, vgap=20, normalize=False):\n\n\tmaps = np.load(maps_filename)\n\tmaps[np.abs(maps) < 5e-3] = 0\n\t\n\ttimecourses = np.load(timecourses_filename)\n\tncomponents = maps.shape[0]\n\n\t# draw the maps and timecourses into temporary files\n\tmap_image_files = [tempfile.mkstemp(suffix=\".png\")[1] for k in range(ncomponents)]\n\ttimecourse_image_files = [tempfile.mkstemp(suffix=\".png\")[1] for k in range(ncomponents)]\n\n\tfig = pyplot.figure(figsize=(4, 2))\n\n\tfor k in range(ncomponents):\n\t\tmap = maps[k,:]\n\t\tif normalize:\n\t\t\tmap = map / np.linalg.norm(map)\n\t\tplot_map(map, mask_nib, map_image_files[k])\n\n\t\tpyplot.clf()\n\t\tpyplot.plot(timecourses[:,k])\n\t\tpyplot.savefig(timecourse_image_files[k])\n\n\tpyplot.close(fig)\n\n\tmap_images = [Image.open(fname) for fname in map_image_files]\n\ttimecourse_images = [Image.open(fname) for fname in timecourse_image_files]\n\n\tmap_width = map_images[0].size[0]\n\timage_height = map_images[0].size[1]\n\ttimecourse_width = timecourse_images[0].size[0]\n\n\tresult_width = map_width + hgap + timecourse_width\n\tresult_height = ncomponents * (image_height + vgap)\n\n\tresult = Image.new('RGB', (result_width, result_height), (255, 255, 255))\n\ty = 0\n\tfor (map_image, timecourse_image) in zip(map_images, timecourse_images):\n\t\tresult.paste(im=map_image, box=(0, y))\n\t\tresult.paste(im=timecourse_image, box=(map_width+hgap, y))\n\t\ty += image_height + vgap\n\n\tresult.save(out_filename)\n\n\tfor k in range(ncomponents):\n\t\tos.remove(map_image_files[k])\n\t\tos.remove(timecourse_image_files[k])","def visualize_network_samples_grid_1D(net, start=5, stop=100, step=10,\n f_ext=\"pdf\"):\n save_dir = make_memnet_checkpoint_dir(\n Path(\"plots/vis_memnet_samples/grid/\"), net)\n if not save_dir.exists():\n save_dir.makedirs()\n relevant_vals = range(start, stop, step)\n grid_width = len(relevant_vals)\n print(\"Loading plants.\")\n inputs0, stim_vals0 = load_plants(\n net.image_width,\n net.trainingset_dir,\n layer_type=net.layer_type,\n normalize=True)\n inputs0 = inputs0 / 255. # Normalize\n print(\"Finished.\")\n irrelevant_dim = int(net.input_distribution_dim == 0)\n if irrelevant_dim == 0:\n inds = list(product([50], relevant_vals))\n else:\n inds = list(product(relevant_vals, [50]))\n inputs_valid = inputs0[stim_vals0[:, irrelevant_dim] == 50]\n stim_vals = stim_vals0[stim_vals0[:, irrelevant_dim] == 50]\n fig, axes = plt.subplots(\n 1, grid_width, figsize=(50, 50 / len(relevant_vals)))\n preds = []\n inputs = []\n print(\"Making plots...\")\n for i in range(len(stim_vals)):\n if tuple(stim_vals[i]) in inds:\n print(\"Making \", stim_vals[i])\n inputs.append(inputs_valid[i])\n preds = net.predict(inputs, keep_session=True)\n for i in range(len(preds)):\n ax = axes[i]\n ax.imshow(\n preds[i:i + 1].reshape(net.image_width, net.image_width),\n cmap=\"gray_r\")\n ax.set_xticklabels(\"\")\n ax.set_xticks([])\n ax.set_xticklabels(\"\")\n ax.set_yticks([])\n ax.set_yticklabels(\"\")\n plt.savefig(save_dir.joinpath('grid.' + f_ext))\n print(\"Saved to \", save_dir.joinpath('grid.' + f_ext))\n return","def plotOceanParcelsAccumulatedResults(input_data_folder, output_folder, start_year, end_year, dt=1):\n # Only for\n tot_days = (end_year-start_year)*365\n start_date = datetime.strptime(str(start_year),'%Y')\n\n open_files = []\n for c_day in np.arange(0, tot_days, dt):\n print(F\"------- {c_day}---------\")\n # Released months\n c_date = start_date + timedelta(days=int(c_day))\n months = (c_date.year - start_date.year)*12 + c_date.month - start_date.month\n\n # Iterate over all the files that should contribute to the image\n fig = plt.figure(figsize=(20,10))\n ax = plt.subplot(1, 1, 1, projection=ccrs.PlateCarree())\n for c_month in range(0, months + 1):\n c_file_year = (start_date + relativedelta(months=int(c_month))).year\n c_file_month = (start_date + relativedelta(months=int(c_month))).month\n skip_days = c_day - (c_date - datetime.strptime(F\"{c_file_year}-{c_file_month}\",'%Y-%m')).days\n\n if len(open_files) <= c_month:\n file_name = F\"TenYears_YesWinds_YesDiffusion_NoUnbeaching_{c_file_year}_{(c_file_month):02d}.nc\"\n print(F\"Reading new file: {file_name}\")\n open_files.append(Dataset(join(input_data_folder, file_name), \"r\", format=\"NETCDF4\"))\n\n c_time_step = c_day - skip_days\n # lats = open_files[c_month].variables['lat'][:,c_time_step]\n # lons = open_files[c_month].variables['lon'][:,c_time_step]\n ax.scatter(open_files[c_month].variables['lon'][:,c_time_step], open_files[c_month].variables['lat'][:,c_time_step], color='c', s=1)\n\n title = F\"{start_date.strftime('%Y-%m-%d')} - {c_date.strftime('%Y-%m-%d')}\"\n ax.coastlines()\n ax.set_title(title, fontsize=30)\n\n # plt.show()\n plt.savefig(F\"{output_folder}/{start_date.strftime('%Y_%m')}_{c_day:04d}.png\")\n plt.close()","def plot_image_grid(epoch, generated_images):\n\n fig = plt.figure(figsize=(GRID_SIZE, GRID_SIZE))\n fig.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0.001, hspace=0.001)\n\n for ind in range(GRID_IMGS):\n ax = fig.add_subplot(GRID_SIZE, GRID_SIZE, ind + 1, xticks=[], yticks=[])\n ax.imshow(np.uint8(((generated_images[ind] + 1) / 2) * 255), cmap='gray')\n\n plt.savefig('/content/drive/My Drive/WGAN/train_images/image_iteration_{:05d}.png'.format(epoch + 1))\n plt.close()","def grid_image(output):\n grid = []\n for data in output:\n grid += [make_grid(data, nrow=5, normalize=True)]\n return grid","def plot_pipeline(differences_dir, plots_dir_intonation, num_quantiles = 31):\n perf_list = ['54363310_1939750539', '540791114_1793842568']\n difference_path_list = [os.path.join(differences_dir, perf_list[i] + \".npy\") for i in range(len(perf_list))]\n comparisons_list = [np.load(path) for _, path in enumerate(difference_path_list)]\n num_samples = 10000\n # quantile indices\n q_indices = (np.linspace(0, 1, num_quantiles)*(num_samples-1)).astype(np.int32)\n plt.style.use('ggplot')\n labels = ['perf. A', 'perf. B']\n colors = ['blue', 'red']\n linestyles = ['dotted', 'dashed']\n grid = plt.GridSpec(2, 2)\n ax1 = plt.subplot(grid[1, 0])\n ax2 = plt.subplot(grid[1, 1])\n ax4 = plt.subplot(grid[0, :])\n ax4.plot(comparisons_list[0], color=colors[0], label=labels[0], linestyle=linestyles[0])\n ax4.plot(comparisons_list[1], color=colors[1], label=labels[1], linestyle=linestyles[1])\n ax4.set_title(\"Difference between MIDI and pYIN, two performances\")\n ax4.set_ylabel(\"Cents\")\n ax4.set_xlabel(\"Frames\")\n ax4.axhline(y=200, linestyle=\"solid\", linewidth=0.7, c=\"black\", zorder=2, label=\"thresh.\")\n ax4.axhline(y=-200, linestyle=\"solid\", linewidth=0.7, c=\"black\", zorder=2)\n ax4.legend(loc=\"upper right\")\n ax1.set_title(\"10k random sample of distances\")\n ax1.set_ylabel(r\"$|$Cents$|$\")\n ax1.set_xlabel(\"Frames sorted by distance\")\n ax2.set_title(\"Sample quantiles\")\n ax2.set_xlabel(\"Quantile indices\")\n # run analysis song by song\n for i, arr in enumerate(comparisons_list):\n # random sample so all arrays have the same size\n samples = np.random.choice(arr, num_samples, replace=True)\n # sort\n samples = np.sort(np.abs(samples))\n # discard the high values (might be due to misalignment, etc...)\n samples = samples[samples <= 200]\n samples = np.random.choice(samples, num_samples, replace=True)\n samples = np.sort(np.abs(samples))\n ax1.plot(samples, color=colors[i], linestyle=linestyles[i], label=labels[i])\n # get the quantiles\n samples = samples[q_indices]\n ax2.plot(samples, color=colors[i], linestyle=linestyles[i], label=labels[i])\n ax1.legend()\n ax2.legend()\n plt.tight_layout()\n plt.savefig(os.path.join(plots_dir_intonation, \"data processing pipeline.eps\"), format=\"eps\")\n plt.show()","def vis_mechanically_coupled_regions(img_dir,output_dir,data,dbscn_length,dbscn_min_size,display_not_save=False):\n #Read in the image that is segmented/labelled for nuclei\n img=imread(img_dir)\n\n #save plots to show clusters\n fig = plt.figure(figsize=(6, 2))\n ax0 = fig.add_subplot(131)\n ax1 = fig.add_subplot(132)\n ax3 = fig.add_subplot(133)\n #show segmented image labels\n ax0.imshow(img,aspect='auto') \n ax0.axis('off')\n #nuclear centroid color-coded by their orientation\n img1=ax1.scatter(data[\"Y\"], data[\"X\"], c=data[\"angles\"],s=1)\n ax1.set_xlim(0,img.shape[0])\n ax1.set_ylim(img.shape[1],0)\n plt.colorbar(img1)\n ax1.axis('off')\n\n # plot the cluster assignments\n img3=ax3.scatter(data[data[\"clusters\"]> -1][\"Y\"], data[data[\"clusters\"]> -1][\"X\"], \n c=data[data[\"clusters\"]> -1][\"clusters\"],cmap=\"plasma\",s=1)\n ax3.set_xlim(0,img.shape[0])\n ax3.set_ylim(img.shape[1],0)\n ax3.axis('off')\n\n #add titles\n ax0.title.set_text('Segmented Image')\n ax1.title.set_text('Filtered Orientation')\n ax3.title.set_text('Clusters')\n\n if display_not_save:\n plt.show()\n else: \n plt.savefig((output_dir+\"/\"+img_dir.rsplit('/', 1)[-1][:-4]+\"_\"+str(dbscn_length)+\"_\"+ str(dbscn_min_size)+\".png\"),dpi=600, bbox_inches = 'tight',pad_inches = 0)\n fig.clf()\n plt.close(fig)\n plt.close('all')\n \n \n del fig,ax0,ax1,ax3,img1,img3","def visualize_gradient_norms(gradient_norms, parameter_names, plot_filepath):\n\n fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(2 * 10, 2 * 5), sharex=\"all\", sharey=\"all\")\n fig.suptitle(\"Gradient norms vs. batch_norm & skip_con\", fontsize=18)\n for i, (param_combo, grad_norms) in enumerate(gradient_norms.items()):\n grad_norms = pd.DataFrame(grad_norms, columns=parameter_names[param_combo])\n # Clip very small gradient norms for better log scale plotting\n grad_norms[grad_norms < 1e-6] = 1e-6\n ax = axes[i // 2, i % 2]\n ax.set_title(str(param_combo), fontsize=14)\n ax.set_xlabel(\"Mini-batch\", fontsize=12)\n ax.set_ylabel(\"Gradient norm\", fontsize=12)\n ax.tick_params(axis=\"x\", labelsize=10)\n ax.tick_params(axis=\"y\", labelsize=10)\n grad_norms.plot.line(ax=ax, figsize=(10, 5),\n colormap=\"plasma_r\",\n logy=True,\n ylim=(1e-6, 1e6))\n ax.legend(title=\"Depth\", prop={\"size\": 6}, title_fontsize=8)\n plt.tight_layout()\n plt.subplots_adjust(top=0.85)\n plt.savefig(fname=plot_filepath, dpi=\"figure\", format=\"eps\")\n plt.close()","def gridPlot48(img_stack):\r\n F = plt.figure(figsize = (50,50))\r\n F.subplots_adjust(left = 0.05, right = 0.95)\r\n grid = ImageGrid(F, 142, nrows_ncols = (6,8), axes_pad = 0.0, share_all = True,\r\n label_mode = \"L\", cbar_location = \"top\", cbar_mode = \"single\")\r\n \r\n i = 0\r\n for img in img_stack[0:48]:\r\n im = grid[i].imshow(img, interpolation = \"nearest\", vmin = 0, vmax = 255)\r\n i += 1 \r\n grid.cbar_axes[0].colorbar(im)\r\n plt.savefig('gplot48.png')\r\n# for cax in grid.cbar_axes:\r\n# cax.toggle_label(False)\r\n return","def EventDisplay( tubes, quantities, PMTFlatMapPositive, title=\"Charge\", cutrange=[-1,-1] ):\n \n fig, ax= plt.subplots(figsize=[30,30])\n preimage = np.zeros( preimage_dimensions )\n \n imgmin = quantities.min()\n imgmax = quantities.max()\n\n for idx, tube in enumerate( tubes ):\n if cutrange[0] != cutrange[1]:\n if quantities[idx] < cutrange[0] or quantities[idx] > cutrange[1]:\n continue\n for dx in range(-3,4):\n for dy in range(-3,4):\n if abs(dx)==3 and abs(dy)==3:\n continue\n \n #print( \"idx=\", idx, \" len(quantities)=\",len(quantities), \" tube=\", tube, \" len(PMTFlatMap)=\", len(PMTFlatMapPositive))\n preimage[ PMTFlatMapPositive[tube][1]+dx, PMTFlatMapPositive[tube][0]+dy ] = quantities[idx]\n\n if cutrange[0] != cutrange[1]:\n imgmin = cutrange[0]\n imgmax = cutrange[1]\n \n im = ax.imshow( preimage, extent = [-positive_x_offset,positive_x_offset,-lower_endcap_offset,lower_endcap_offset], vmin=imgmin, vmax=imgmax )\n\n fig.suptitle(title, fontsize=80)\n\n plt.rc('xtick', labelsize=24) \n plt.rc('ytick', labelsize=24) \n plt.xlabel('Distance CCW on perimeter from x-axis (cm)', fontsize=48)\n plt.ylabel('Y (cm)', fontsize=48)\n\n plt.set_cmap('gist_heat_r')\n\n # Create colourbar\n divider = make_axes_locatable(ax)\n cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n cbar = plt.colorbar(im, cax=cax)\n cbar.ax.tick_params(labelsize=24)\n\n # Fix title height\n plt.subplots_adjust(top=0.5)\n plt.tight_layout()","def show_filters(self):\n w_mat = np.transpose(self.sess.run(self.W_fc1))\n\n plt.figure(figsize=(10,10), facecolor='w', edgecolor='w')\n plot_positions = [(0,0),(0,1),(1,0),(1,1)]\n for ch in range(self.n_input_channels):\n grid,_ = ia.image_grid_RGB( w_mat,\n n_channels=self.n_input_channels,\n image_size=(self.y_res,self.x_res), n_x=6, n_y=6,\n channel_order=(ch,ch,ch), amplitude_scaling=(1,1,1),\n line_color=1, auto_scale=True, return_borders=False )\n colormax = np.abs(grid).max()\n with sns.axes_style(\"white\"):\n ax = plt.subplot2grid( (2,2), plot_positions[ch] )\n ax.imshow( grid[:,:,0], interpolation='nearest',\n cmap=plt.get_cmap('seismic'),\n clim=(-1*colormax,colormax) )\n ax.set_title(\"Hidden units, channel {}\".format(ch))\n plt.axis('tight')\n plt.axis('off')\n plt.tight_layout()","def heatmap_plot(savefigure=False):\n treenumber,depth = [1, 5, 10, 50, 100, 500, 1000], list(range(1,11))\n iter_list = list(product(treenumber, depth))\n result_list = np.load('npy-data/result_big_run.npy')\n heat_arr = result_list.reshape((len(treenumber), len(depth)))\n\n fig, ax = plt.subplots(figsize=(8,8))\n im = ax.matshow(heat_arr, cmap=plt.cm.coolwarm, vmin=.8, vmax=1)\n divider = make_axes_locatable(ax)\n cax = divider.append_axes(\"right\", size=\"5%\", pad=0.2)\n\n ax.set_xticks(np.arange(heat_arr.shape[1]))\n ax.set_xticklabels(depth)\n ax.set_yticks(np.arange(heat_arr.shape[0]))\n ax.set_yticklabels(treenumber)\n ax.set_xlim(-.5,heat_arr.shape[1]-.5)\n ax.set_ylim(heat_arr.shape[0]-.5,-.5)\n ax.set_xlabel(\"Maximum depth\")\n ax.set_ylabel(\"Number of trees\")\n ax.xaxis.set_ticks_position('bottom')\n plt.colorbar(im, cax=cax)\n for i, z in enumerate(heat_arr):\n for j in range(len(z)):\n ax.text(j, i, '{:.3f}'.format(z[j]), ha='center', va='center')\n if savefigure:\n plt.savefig('img/xgb_heatmap_maxdepth_n_estimators.pdf', bbox_inches='tight')\n plt.show()","def main(config):\n file_paths_info = [('GLOFRIS','WATCH','ARG_inunriver_historical_000000000WATCH_1980_rp01000.tif'),\n \t\t\t\t('GLOFRIS','RCP45','ARG_inunriver_rcp4p5_0000GFDL-ESM2M_2030_rp01000.tif'),\n \t\t\t\t('GLOFRIS','RCP85','ARG_inunriver_rcp8p5_0000GFDL-ESM2M_2030_rp01000.tif'),\n \t\t\t\t('FATHOM','AR_fluvial_undefended_merged','AR-FU-1000.tif'),\n \t\t\t\t('FATHOM','AR_pluvial_undefended_merged','AR-PU-1000.tif')\n \t\t\t\t]\n figure_names = ['GLOFRIS-WATCH-fluvial','GLOFRIS-RCP45-fluvial','GLOFRIS-RCP85-fluvial','FATHOM-fluvial','FATHOM-pluvial']\n figure_titles = ['current fluvial flooding','RCP4.5 fluvial flooding','RCP8.5 fluvial flooding','current fluvial flooding','current pluvial flooding']\n for f_i in range(len(file_paths_info)):\n\t hazard_file = os.path.join(config['paths']['data'],'flood_data', file_paths_info[f_i][0],file_paths_info[f_i][1],file_paths_info[f_i][2])\n\t output_file = os.path.join(config['paths']['figures'], 'flood-map-{}.png'.format(figure_names[f_i]))\n\t ax = get_axes()\n\t plot_basemap(ax, config['paths']['data'])\n\t scale_bar(ax, location=(0.8, 0.05))\n\t plot_basemap_labels(ax, config['paths']['data'], include_regions=True,include_zorder=3)\n\n\t proj_lat_lon = ccrs.PlateCarree()\n\n\n\t # Create color map\n\t colors = plt.get_cmap('Blues')\n\n\t # Read in raster data\n\t data, lat_lon_extent = get_data(hazard_file)\n\t data[(data <= 0) | (data > 5)] = np.nan\n\t max_val = np.nanmax(data)\n\t norm=mpl.colors.Normalize(vmin=0, vmax=max_val)\n\n\t # Plot population data\n\t im = ax.imshow(data, extent=lat_lon_extent,transform=proj_lat_lon, cmap=colors,norm =norm, zorder=2)\n\n\t # Add colorbar\n\t cbar = plt.colorbar(im, ax=ax,fraction=0.1, shrink=0.87,pad=0.01, drawedges=False, orientation='horizontal',\n\t norm=mpl.colors.Normalize(vmin=0, vmax=max_val), ticks=list(np.linspace(0,max_val,3)))\n\t cbar.set_clim(vmin=0,vmax=max_val)\n\n\n\t cbar.outline.set_color(\"none\")\n\t cbar.ax.yaxis.set_tick_params(color='black')\n\t cbar.ax.set_xlabel('Flood depths (m)',fontsize=12,color='black')\n\n\t plt.title('1 in 1000 year {}'.format(figure_titles[f_i]), fontsize = 14)\n\t save_fig(output_file)\n\t plt.close()","def make_plots(fig_title, \n t_csd_x, t_csd_y, t_csd_z, true_csd, \n ele_x, ele_y, ele_z, pots,\n k_csd_x, k_csd_y, k_csd_z, est_csd):\n fig = plt.figure(figsize=(10,16))\n #True CSD\n z_steps = 5\n height_ratios = [1 for i in range(z_steps)]\n height_ratios.append(0.1)\n gs = gridspec.GridSpec(z_steps+1, 3, height_ratios=height_ratios)\n t_max = np.max(np.abs(true_csd))\n levels = np.linspace(-1*t_max, t_max, 16)\n ind_interest = np.mgrid[0:t_csd_z.shape[2]:np.complex(0,z_steps+2)]\n ind_interest = np.array(ind_interest, dtype=np.int)[1:-1]\n for ii, idx in enumerate(ind_interest):\n ax = plt.subplot(gs[ii, 0])\n im = plt.contourf(t_csd_x[:,:,idx], t_csd_y[:,:,idx], true_csd[:,:,idx], \n levels=levels, cmap=cm.bwr_r)\n ax.get_xaxis().set_visible(False)\n ax.get_yaxis().set_visible(False)\n title = str(t_csd_z[:,:,idx][0][0])[:4]\n ax.set_title(label=title, fontdict={'x':0.8, 'y':0.8})\n ax.set_aspect('equal')\n cax = plt.subplot(gs[z_steps,0])\n cbar = plt.colorbar(im, cax=cax, orientation='horizontal')\n cbar.set_ticks(levels[::2])\n cbar.set_ticklabels(np.around(levels[::2], decimals=2))\n #Potentials\n v_max = np.max(np.abs(pots))\n levels_pot = np.linspace(-1*v_max, v_max, 16)\n ele_res = int(np.ceil(len(pots)**(3**-1))) \n ele_x = ele_x.reshape(ele_res, ele_res, ele_res)\n ele_y = ele_y.reshape(ele_res, ele_res, ele_res)\n ele_z = ele_z.reshape(ele_res, ele_res, ele_res)\n pots = pots.reshape(ele_res, ele_res, ele_res)\n for idx in range(min(5,ele_res)):\n X,Y,Z = grid(ele_x[:,:,idx], ele_y[:,:,idx], pots[:,:,idx])\n ax = plt.subplot(gs[idx, 1])\n im = plt.contourf(X, Y, Z, levels=levels_pot, cmap=cm.PRGn)\n ax.hold(True)\n plt.scatter(ele_x[:,:,idx], ele_y[:,:,idx], 5)\n ax.get_xaxis().set_visible(False)\n ax.get_yaxis().set_visible(False)\n title = str(ele_z[:,:,idx][0][0])[:4]\n ax.set_title(label=title, fontdict={'x':0.8, 'y':0.8})\n ax.set_aspect('equal')\n ax.set_xlim([0.,1.])\n ax.set_ylim([0.,1.])\n cax = plt.subplot(gs[z_steps,1])\n cbar2 = plt.colorbar(im, cax=cax, orientation='horizontal')\n cbar2.set_ticks(levels_pot[::2])\n cbar2.set_ticklabels(np.around(levels_pot[::2], decimals=2))\n # #KCSD\n t_max = np.max(np.abs(est_csd[:,:,:,0]))\n levels_kcsd = np.linspace(-1*t_max, t_max, 16)\n ind_interest = np.mgrid[0:k_csd_z.shape[2]:np.complex(0,z_steps+2)]\n ind_interest = np.array(ind_interest, dtype=np.int)[1:-1]\n for ii, idx in enumerate(ind_interest):\n ax = plt.subplot(gs[ii, 2])\n im = plt.contourf(k_csd_x[:,:,idx], k_csd_y[:,:,idx], est_csd[:,:,idx,0], \n levels=levels_kcsd, cmap=cm.bwr_r)\n #im = plt.contourf(k_csd_x[:,:,idx], k_csd_y[:,:,idx], est_csd[:,:,idx,0], \n # levels=levels, cmap=cm.bwr_r)\n ax.get_xaxis().set_visible(False)\n ax.get_yaxis().set_visible(False)\n title = str(k_csd_z[:,:,idx][0][0])[:4]\n ax.set_title(label=title, fontdict={'x':0.8, 'y':0.8})\n ax.set_aspect('equal')\n cax = plt.subplot(gs[z_steps,2])\n cbar3 = plt.colorbar(im, cax=cax, orientation='horizontal')\n cbar3.set_ticks(levels_kcsd[::2])\n #cbar3.set_ticks(levels[::2])\n cbar3.set_ticklabels(np.around(levels_kcsd[::2], decimals=2))\n #cbar3.set_ticklabels(np.around(levels[::2], decimals=2))\n fig.suptitle(\"Lambda,R,CV_Error,RMS_Error,Time = \"+fig_title)\n gs.tight_layout(fig, rect=[0, 0.03, 1, 0.95]) \n # #Showing\n #plt.tight_layout()\n plt.show()\n return","def plot(path, subjects):\n transformToXYZmm = np.array([[-3.125, 0, 0, 81.250], [0, 3.125, 0, -115.625], [0, 0, 6, -54.000], [0, 0, 0, 1.000]])\n data = data_load.load_data(path, subjects)\n dimx = int(data[0][\"meta\"][\"dimx\"][0])\n dimy = int(data[0][\"meta\"][\"dimy\"][0])\n dimz = int(data[0][\"meta\"][\"dimz\"][0])\n coordToCol = data[0][\"meta\"][\"coordToCol\"][0][0]\n images = {}\n max_val = 0\n voxels = np.load(\"data/general_selected_500_1.npy\")\n directory = os.listdir(\"data/input/\")\n bar = pyprind.ProgBar(len(directory), title='Info extraction and Image Building')\n bar2 = pyprind.ProgBar(len(images.keys()), title='Saving Pictures')\n for file in directory:\n file_name = \"data/input/{}\".format(file)\n fh = open(file_name)\n activation_values = np.asarray(list(map(lambda x: float(x), filter(lambda x: x != '', fh.read().split(\",\")))))\n fh.close()\n plot_matrix = np.zeros((dimx, dimy, dimz))\n for x in range(dimx):\n for y in range(dimy):\n for z in range(dimz):\n indice = coordToCol[x][y][z]\n if indice != 0:\n if indice in list(voxels):\n voxel_indice = list(voxels).index(indice)\n value = activation_values[voxel_indice]\n if abs(value) > max_val:\n max_val = abs(value)\n plot_matrix[x][y][z] = value\n image = nib.Nifti1Image(plot_matrix, transformToXYZmm)\n images[file_name] = image\n bar.update(force_flush=True)\n print(bar)\n for image in images:\n plotting.plot_glass_brain(images[image], display_mode='ortho', vmax=max_val, plot_abs=False, threshold=None, colorbar=True, output_file=\"{}-wom1.png\".format(image))\n bar2.update(force_flush=True)\n print(bar2)","def plot_2d_results(model):\n\n # Create the figure\n fig, ax = newfig(1.5, 1.5)\n ax.axis('off')\n gs = gridspec.GridSpec(3, 3)\n gs.update(top=0.8, bottom=0.2, left=0.1, right=0.9, wspace=0.7, hspace=0.7)\n\n # Loop to plot different slices of the Green's function\n for i in range(2):\n for j in range(2):\n # Evaluate the Green's function network\n input_data, shape_Green, axis_limit, axis_labels = input_data_slice(\n model, Green_slice=2 * i + j + 1)\n G_pred_identifier = model.sess.run(\n model.G_network[0][0].evaluate(input_data))\n G_pred = G_pred_identifier.reshape(shape_Green)\n ax = plt.subplot(gs[i, j])\n h = ax.imshow(G_pred, interpolation='lanczos', cmap='jet',\n extent=axis_limit,\n origin='lower', aspect='auto')\n divider = make_axes_locatable(ax)\n cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n fig.colorbar(h, cax=cax)\n ax.set_xlabel(axis_labels[0])\n ax.set_ylabel(axis_labels[1], rotation=0, labelpad=12)\n ax.set_title('$G$%s' % (axis_labels[2]), fontsize=10)\n\n # Get axis limit\n x1min = np.min(model.x_G)\n x1max = np.max(model.x_G)\n x2min = np.min(model.y_G)\n x2max = np.max(model.y_G)\n\n # Exact Homogeneous solution\n ax = plt.subplot(gs[0, 2])\n X_G, Y_G = np.meshgrid(model.x_G, model.y_G)\n x1 = X_G.flatten()[:, None]\n x2 = Y_G.flatten()[:, None]\n U_hom = np.transpose(model.U_hom.reshape(\n (model.y_G.shape[0], model.x_G.shape[0])))\n h = ax.imshow(U_hom, interpolation='lanczos', cmap='jet',\n extent=[x1min, x1max, x2min, x2max],\n origin='lower', aspect='auto')\n divider = make_axes_locatable(ax)\n cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n fig.colorbar(h, cax=cax)\n ax.set_xlabel('$x$')\n ax.set_ylabel('$y$', rotation=0, labelpad=12)\n ax.set_title('Exact Hom', fontsize=10)\n\n # Learned Homogeneous solution\n ax = plt.subplot(gs[1, 2])\n input_data = np.concatenate((x1, x2), 1).astype(dtype=config.real(np))\n N_pred_identifier = model.sess.run(\n model.idn_N_pred[0].evaluate(input_data))\n N_pred = N_pred_identifier.reshape(X_G.shape)\n h = ax.imshow(N_pred, interpolation='lanczos', cmap='jet',\n extent=[x1min, x1max, x2min, x2max],\n origin='lower', aspect='auto')\n divider = make_axes_locatable(ax)\n cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n fig.colorbar(h, cax=cax)\n ax.set_xlabel('$x$')\n ax.set_ylabel('$y$', rotation=0, labelpad=12)\n ax.set_title('Learned Hom', fontsize=10)\n\n # Save the figure\n savefig(\"%s/%s_%s\" % (model.path_result, model.example_name,\n model.activation_name), crop=False)","def plot_spatial_res(data_obj, test_num):\n\n #---------------------------------------------------------------------------------------------#\n # Go through each file [image] and plot the spatial resolution ROI images and MTF data graphs #\n #---------------------------------------------------------------------------------------------#\n for i in range(len(data_obj.files)):\n\n fig = new_pdf_page(data_obj.pdf_obj) #Create a new pdf page\n plt.axis('off')\n\n # Create and plot the (centered) title of the page - that also states the MTF20 values\n str1 = 'Test ' + str(test_num) + ': Spatial Resolution \\n' + \\\n 'MTF20x = ' + \"{0:.2f}\".format(data_obj.MTF_data.MTF20_x) + \\\n '\\n MTF20y = ' + \"{0:.2f}\".format(data_obj.MTF_data.MTF20_y)\n plt.suptitle(str1)\n\n #-----------------------------------------------#\n # Plot the main image in the middle of the page #\n #-----------------------------------------------#\n ax1 = fig.add_subplot(312)\n plt.imshow(data_obj.img_data[i].lead_foil_ROI.img) #Display the ROI image of the lead foil\n\n # Display the title of the ROI image - the orientation\n plt.title('Orientation ' + str(data_obj.img_data[i].orientation))\n plt.xticks([]) # labels\n plt.yticks([])\n ax = plt.gca()\n ax.xaxis.set_ticks_position('none') # tick markers\n ax.yaxis.set_ticks_position('none')\n\n if data_obj.img_data[i].orientation % 2 == 1:\n plt.xlabel('x axis')\n plt.ylabel('y axis')\n else:\n plt.xlabel('y axis')\n plt.ylabel('x axis')\n\n #-----------------------------#\n # Display the Horizontal plot #\n #-----------------------------#\n ax2 = fig.add_subplot(325)\n plt.ylabel('MTFx')\n plt.xlabel('Spatial frequency (cycles/mm)')\n plt.plot(data_obj.img_data[i].MTF_obj.MTF_x_f, data_obj.img_data[i].MTF_obj.MTF_x)\n text = 'MTF20x = ' + \"{0:.2f}\".format(data_obj.img_data[i].MTF_obj.MTF20_x)\n\n ax2.annotate(text,\n xy=(data_obj.img_data[i].MTF_obj.MTF20_x, 0.2),\n xytext=(np.max(data_obj.img_data[i].MTF_obj.MTF_x_f), 0.7),\n arrowprops=dict(facecolor='black', shrink=0.05, width=0.5, headwidth=4),\n horizontalalignment='right')\n\n #---------------#\n # Vertical plot #\n #---------------#\n ax3 = fig.add_subplot(326)\n plt.ylabel('MTFy')\n plt.xlabel('Spatial frequency (cycles/mm)')\n plt.plot(data_obj.img_data[i].MTF_obj.MTF_y_f, data_obj.img_data[i].MTF_obj.MTF_y)\n text = 'MTF20y = ' + \"{0:.2f}\".format(data_obj.img_data[i].MTF_obj.MTF20_y)\n\n ax3.annotate(text,\n xy=(data_obj.img_data[i].MTF_obj.MTF20_y, 0.2),\n xytext=(np.max(data_obj.img_data[i].MTF_obj.MTF_y_f), 0.7),\n arrowprops=dict(facecolor='black', shrink=0.05, width=0.5, headwidth=4),\n horizontalalignment='right')","def show_lanes(self, images, cols = 2, rows = 4, figsize=(15,13)):\n fig, axes = plt.subplots(rows, cols, figsize=figsize)\n indexes = range(cols * rows)\n self.fits = []\n self.fits_curve = []\n for ax, idx in zip(axes.flat, indexes):\n if idx < len(images):\n image = images[idx]\n left_fit, right_fit, left_fit_curve, right_fit_curve = self.plot_lanes(image, ax)\n self.fits.append((left_fit, right_fit))\n self.fits_curve.append((left_fit_curve, right_fit_curve))","def plot_grid(information,\n var_to_plot,\n vmin,\n vmax,\n xmin,\n xmax,\n ymin,\n ymax,\n file_name,\n c_scheme,\n yax_shift,\n subplot):\n\n grain_type = True if \"grain type\" in var_to_plot else False\n\n grid = information['grid']\n dates = information['dates']\n\n # Make the plot\n\n if subplot:\n ax = subplot\n else:\n fig, ax = plt.subplots(1 ,1 ,figsize=(10 ,6))\n\n # Specify the colormap\n\n if grain_type:\n my_cmap = grain_type_colormap()\n grid = transform_grid_for_grain_type(grid)\n else:\n my_cmap = plt.get_cmap(c_scheme)\n\n\n # Set the limits of the plot\n\n x_lims = mdates.date2num([dates[0] ,dates[-1]])\n if xmin and xmax:\n x_lims_specified = mdates.date2num([xmin, xmax])\n # for spec in x_lims_specified:\n # assert (x_lims[0] < spec < x_lims[1])\n x_lims = x_lims_specified\n\n if ymin and ymax:\n information['min_height'] = ymin\n information['max_height'] = ymax\n\n extent = [x_lims[0],\n x_lims[1] ,\n information['min_height'] - yax_shift,\n information['max_height'] - yax_shift]\n\n ax.xaxis_date()\n date_format = mdates.DateFormatter('%m/%d')\n ax.xaxis.set_major_formatter(date_format)\n\n #######################\n\n im = ax.imshow(grid,\n extent= extent,\n aspect='auto',\n vmin=vmin ,vmax=vmax,\n cmap=my_cmap)\n\n\n ax.tick_params(right=True)\n\n ax.set_ylabel('Height (cm)', fontsize='x-large')\n\n if subplot:\n return ax\n else:\n\n cbar = fig.colorbar(im, ax=ax, pad=0.075)\n\n if grain_type: cbar.ax.set_yticklabels(get_grain_tick_labels())\n else: cbar.set_label(var_to_plot, fontsize='x-large')\n\n\n if file_name:\n fig.savefig(file_name ,dpi=500, bbox_inches='tight')\n\n plt.show()\n\n return 0","def plot_results(models,\n data,\n batch_size=128,\n model_name=None):\n\n encoder, decoder = models\n x_test, y_test = data\n # display a 2D plot of the digit classes in the latent space\n z_mean = encoder(x_test)\n plt.figure(figsize=(12, 10))\n plt.scatter(z_mean[:, 0], z_mean[:, 1], c=y_test)\n plt.colorbar()\n plt.xlabel(\"z[0]\")\n plt.ylabel(\"z[1]\")\n \n plt.show()\n if not model_name is None:\n os.makedirs(model_name, exist_ok=True)\n filename = os.path.join(model_name, \"vae_mean.png\")\n plt.savefig(filename)\n filename = os.path.join(model_name, \"digits_over_latent.png\")\n # display a 30x30 2D manifold of digits\n n = 30\n digit_size = 28\n figure = np.zeros((digit_size * n, digit_size * n))\n # linearly spaced coordinates corresponding to the 2D plot\n # of digit classes in the latent space\n grid_x = np.linspace(-4, 4, n)\n grid_y = np.linspace(-4, 4, n)[::-1]\n\n for i, yi in enumerate(grid_y):\n for j, xi in enumerate(grid_x):\n z_sample = np.array([[xi, yi]])\n x_decoded = decoder(z_sample)\n digit = x_decoded[0].reshape(digit_size, digit_size)\n figure[i * digit_size: (i + 1) * digit_size,\n j * digit_size: (j + 1) * digit_size] = digit\n\n plt.figure(figsize=(10, 10))\n start_range = digit_size // 2\n end_range = n * digit_size + start_range + 1\n pixel_range = np.arange(start_range, end_range, digit_size)\n sample_range_x = np.round(grid_x, 1)\n sample_range_y = np.round(grid_y, 1)\n plt.xticks(pixel_range, sample_range_x)\n plt.yticks(pixel_range, sample_range_y)\n plt.xlabel(\"z[0]\")\n plt.ylabel(\"z[1]\")\n plt.imshow(figure, cmap='Greys_r')\n if not model_name is None:\n plt.savefig(filename)\n plt.show()","def run(self):\n # fill the x_values,y_values,z_values dictionaries\n if not self.__fillCoordinatesFromSource():\n self.raiseAWarning('Nothing to Plot Yet. Returning.')\n return\n\n self.counter += 1\n if self.counter > 1:\n self.actcm = None\n clusterDict = deepcopy(self.outStreamTypes)\n\n # start plotting.... loop over the plots that need to be included in this figure\n for pltIndex in range(len(self.outStreamTypes)):\n plotSettings = self.options['plotSettings']['plot'][pltIndex]\n if 'gridLocation' in plotSettings:\n x = None\n y = None\n if 'x' in plotSettings['gridLocation']:\n x = list(map(int, plotSettings['gridLocation']['x'].strip().split(' ')))\n else:\n x = None\n if 'y' in plotSettings['gridLocation'].keys():\n y = list(map(int, plotSettings['gridLocation']['y'].strip().split(' ')))\n else:\n y = None\n if pltIndex == 0:\n self.ax.remove() # remove axis so that there is not an extra axis on plot with subplots\n if (len(x) == 1 and len(y) == 1):\n if self.dim == 2:\n self.ax = self.fig.add_subplot(self.gridSpace[x[0], y[0]])\n else:\n self.ax = self.fig.add_subplot(self.gridSpace[x[0], y[0]], projection='3d')\n elif (len(x) == 1 and len(y) != 1):\n if self.dim == 2:\n self.ax = self.fig.add_subplot(self.gridSpace[x[0], y[0]:y[-1]])\n else:\n self.ax = self.fig.add_subplot(self.gridSpace[x[0], y[0]:y[-1]], projection='3d')\n elif (len(x) != 1 and len(y) == 1):\n if self.dim == 2:\n self.ax = self.fig.add_subplot(self.gridSpace[x[0]:x[-1], y[0]])\n else:\n self.ax = self.fig.add_subplot(self.gridSpace[x[0]:x[-1], y[0]], projection='3d')\n else:\n if self.dim == 2:\n self.ax = self.fig.add_subplot(self.gridSpace[x[0]:x[-1], y[0]:y[-1]])\n else:\n self.ax = self.fig.add_subplot(self.gridSpace[x[0]:x[-1], y[0]:y[-1]], projection='3d')\n\n if 'gridSpace' in self.options['plotSettings']:\n self.ax.locator_params(axis='y', nbins=4)\n self.ax.locator_params(axis='x', nbins=2)\n if 'range' in plotSettings:\n axes_range = plotSettings['range']\n if 'ymin' in axes_range:\n self.ax.set_ylim(bottom=ast.literal_eval(axes_range['ymin']))\n if 'ymax' in axes_range:\n self.ax.set_ylim(top=ast.literal_eval(axes_range['ymax']))\n if 'xmin' in axes_range:\n self.ax.set_xlim(left=ast.literal_eval(axes_range['xmin']))\n if 'xmax' in axes_range:\n self.ax.set_xlim(right=ast.literal_eval(axes_range['xmax']))\n if self.dim == 3:\n if 'zmin' in axes_range.options['plotSettings']['plot'][pltIndex]:\n if 'zmax' not in axes_range.options['plotSettings']:\n self.raiseAWarning('zmin inputted but not zmax. zmin ignored! ')\n else:\n self.ax.set_zlim(bottom=ast.literal_eval(axes_range['zmin']), top=ast.literal_eval(self.options['plotSettings']['zmax']))\n if 'zmax' in axes_range:\n if 'zmin' not in axes_range:\n self.raiseAWarning('zmax inputted but not zmin. zmax ignored! ')\n else:\n self.ax.set_zlim(bottom=ast.literal_eval(axes_range['zmin']), top=ast.literal_eval(axes_range['zmax']))\n if 'xlabel' not in plotSettings:\n self.ax.set_xlabel('x')\n else:\n self.ax.set_xlabel(plotSettings['xlabel'])\n if 'ylabel' not in plotSettings:\n self.ax.set_ylabel('y')\n else:\n self.ax.set_ylabel(plotSettings['ylabel'])\n if 'zlabel' in plotSettings:\n if self.dim == 2:\n self.raiseAWarning('zlabel keyword does not make sense in 2-D Plots!')\n elif self.dim == 3 and self.zCoordinates:\n self.ax.set_zlabel(plotSettings['zlabel'])\n elif self.dim == 3 and self.zCoordinates:\n self.ax.set_zlabel('z')\n else:\n if 'xlabel' not in self.options['plotSettings']:\n self.ax.set_xlabel('x')\n else:\n self.ax.set_xlabel(self.options['plotSettings']['xlabel'])\n if 'ylabel' not in self.options['plotSettings']:\n self.ax.set_ylabel('y')\n else:\n self.ax.set_ylabel(self.options['plotSettings']['ylabel'])\n if 'zlabel' in self.options['plotSettings']:\n if self.dim == 2:\n self.raiseAWarning('zlabel keyword does not make sense in 2-D Plots!')\n elif self.dim == 3 and self.zCoordinates:\n self.ax.set_zlabel(self.options['plotSettings']['zlabel'])\n elif self.dim == 3 and self.zCoordinates:\n self.ax.set_zlabel('z')\n\n if 'legend' in self.options['plotSettings']:\n if 'label' not in plotSettings.get('attributes', {}):\n if 'attributes' not in plotSettings:\n plotSettings['attributes'] = {}\n plotSettings['attributes']['label'] = self.outStreamTypes[pltIndex] + ' ' + str(pltIndex)\n #################\n # SCATTER PLOT #\n #################\n self.raiseADebug(f'creating plot {self.name}')\n if self.outStreamTypes[pltIndex] == 'scatter':\n if 's' not in plotSettings:\n plotSettings['s'] = '20'\n if 'c' not in plotSettings:\n plotSettings['c'] = 'b'\n if 'marker' not in plotSettings:\n plotSettings['marker'] = 'o'\n if 'alpha' not in plotSettings:\n plotSettings['alpha'] = 'None'\n if 'linewidths' not in plotSettings:\n plotSettings['linewidths'] = 'None'\n if self.colorMapCoordinates[pltIndex] is not None:\n # Find the max and min colormap values\n firstKey = utils.first(self.xValues[pltIndex].keys())\n vmin = np.amin(self.colorMapValues[pltIndex][firstKey])\n vmax = np.amax(self.colorMapValues[pltIndex][firstKey])\n for key in self.xValues[pltIndex]:\n vmin = min(vmin,np.amin(self.colorMapValues[pltIndex][key]))\n vmax = max(vmax,np.amax(self.colorMapValues[pltIndex][key]))\n plotSettings['norm'] = matplotlib.colors.Normalize(vmin,vmax)\n for key in self.xValues[pltIndex]:\n for xIndex in range(len(self.xValues[pltIndex][key])):\n for yIndex in range(len(self.yValues[pltIndex][key])):\n scatterPlotOptions = {'s': ast.literal_eval(plotSettings['s']),\n 'marker': (plotSettings['marker']),\n 'alpha': ast.literal_eval(plotSettings['alpha']),\n 'linewidths': ast.literal_eval(plotSettings['linewidths'])}\n if self.colorMapCoordinates[pltIndex] is not None:\n scatterPlotOptions['norm'] = plotSettings['norm']\n scatterPlotOptions.update(plotSettings.get('attributes', {}))\n if self.dim == 2:\n if self.colorMapCoordinates[pltIndex] is not None:\n scatterPlotOptions['c'] = self.colorMapValues[pltIndex][key][xIndex]\n scatterPlotOptions['cmap'] = matplotlib.cm.get_cmap(\"winter\")\n if self.actcm:\n first = False\n else:\n first = True\n if plotSettings['cmap'] == 'None':\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n **scatterPlotOptions)\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n if first:\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_array(self.colorMapValues[pltIndex][key])\n self.actcm = self.fig.colorbar(m)\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n try:\n self.actcm.draw_all()\n # this is not good, what exception will be thrown?\n except:\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_array(self.colorMapValues[pltIndex][key])\n self.actcm = self.fig.colorbar(m)\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n scatterPlotOptions['cmap'] = plotSettings['cmap']\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n **scatterPlotOptions)\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n if first:\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_array(self.colorMapValues[pltIndex][key])\n self.actcm = self.fig.colorbar(m, ax=self.ax)\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_clim(vmin = min(self.colorMapValues[pltIndex][key][-1]), vmax=max(self.colorMapValues[pltIndex][key][-1]))\n self.actcm.draw_all()\n else:\n if 'color' not in scatterPlotOptions:\n scatterPlotOptions['c'] = plotSettings['c']\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n **scatterPlotOptions)\n else:\n for zIndex in range(len(self.zValues[pltIndex][key])):\n if self.colorMapCoordinates[pltIndex] is not None:\n scatterPlotOptions['c'] = self.colorMapValues[pltIndex][key][zIndex]\n if self.actcm:\n first = False\n else:\n first = True\n if plotSettings['cmap'] == 'None':\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], self.zValues[pltIndex][key][zIndex], **scatterPlotOptions)\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n if first:\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_array(self.colorMapValues[pltIndex][key])\n self.actcm = self.fig.colorbar(m)\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n self.actcm.draw_all()\n else:\n scatterPlotOptions['cmap'] = plotSettings['cmap']\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], self.zValues[pltIndex][key][zIndex], **scatterPlotOptions)\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n if first:\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_array(self.colorMapValues[pltIndex][key])\n self.actcm = self.fig.colorbar(m)\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n m = matplotlib.cm.ScalarMappable(cmap = self.actPlot.cmap, norm = self.actPlot.norm)\n m.set_clim(vmin = min(self.colorMapValues[pltIndex][key][-1]), vmax=max(self.colorMapValues[pltIndex][key][-1]))\n self.actcm.draw_all()\n else:\n if 'color' not in scatterPlotOptions:\n scatterPlotOptions['c'] = plotSettings['c']\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], self.zValues[pltIndex][key][zIndex], **scatterPlotOptions)\n #################\n # LINE PLOT #\n #################\n elif self.outStreamTypes[pltIndex] == 'line':\n minV = 0\n maxV = 0\n # If the user does not define an appropriate cmap, then use matplotlib's default.\n if 'cmap' not in plotSettings or plotSettings['cmap'] not in matplotlib.cm.datad:\n plotSettings['cmap'] = None\n if bool(self.colorMapValues):\n for key in self.xValues[pltIndex]:\n minV = min(minV,self.colorMapValues[pltIndex][key][-1][-1])\n maxV = max(maxV,self.colorMapValues[pltIndex][key][-1][-1])\n cmap = matplotlib.cm.ScalarMappable(matplotlib.colors.Normalize(minV, maxV, True), plotSettings['cmap'])\n cmap.set_array([minV,maxV])\n for key in self.xValues[pltIndex]:\n for xIndex in range(len(self.xValues[pltIndex][key])):\n if self.colorMapCoordinates[pltIndex] is not None:\n plotSettings['interpPointsX'] = str(max(200, len(self.xValues[pltIndex][key][xIndex])))\n for yIndex in range(len(self.yValues[pltIndex][key])):\n if self.dim == 2:\n if self.yValues[pltIndex][key][yIndex].size < 2:\n return\n xi, yi = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], plotSettings, returnCoordinate=True)\n if self.colorMapCoordinates[pltIndex] is not None:\n self.ax.plot(xi, yi, c=cmap.cmap(self.colorMapValues[pltIndex][key][-1][-1]/(maxV-minV)))\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n if self.actcm is None:\n self.actcm = self.fig.colorbar(cmap)\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n self.actcm.draw_all()\n else:\n self.actPlot = self.ax.plot(xi, yi, **plotSettings.get('attributes', {}))\n else:\n for zIndex in range(len(self.zValues[pltIndex][key])):\n if self.zValues[pltIndex][key][zIndex].size <= 3:\n return\n if self.colorMapCoordinates[pltIndex] is not None:\n self.ax.plot(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n self.zValues[pltIndex][key][zIndex],\n c=cmap.cmap(self.colorMapValues[pltIndex][key][-1][-1]/(maxV-minV)))\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n if self.actcm is None:\n self.actcm = self.fig.colorbar(cmap)\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n self.actcm.draw_all()\n else:\n self.actPlot = self.ax.plot(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n self.zValues[pltIndex][key][zIndex],\n **plotSettings.get('attributes', {}))\n ##################\n # HISTOGRAM PLOT #\n ##################\n elif self.outStreamTypes[pltIndex] == 'histogram':\n if 'bins' not in plotSettings:\n if self.dim == 2:\n plotSettings['bins'] = '10'\n else:\n plotSettings['bins'] = '4'\n if 'normed' not in plotSettings:\n plotSettings['normed'] = 'False'\n if 'weights' not in plotSettings:\n plotSettings['weights'] = 'None'\n if 'cumulative' not in plotSettings:\n plotSettings['cumulative'] = 'False'\n if 'histtype' not in plotSettings:\n plotSettings['histtype'] = 'bar'\n if 'align' not in plotSettings:\n plotSettings['align'] = 'mid'\n if 'orientation' not in plotSettings:\n plotSettings['orientation'] = 'vertical'\n if 'rwidth' not in plotSettings:\n plotSettings['rwidth'] = 'None'\n if 'log' not in plotSettings:\n plotSettings['log'] = 'None'\n if 'color' not in plotSettings:\n plotSettings['color'] = 'b'\n if 'stacked' not in plotSettings:\n plotSettings['stacked'] = 'None'\n if self.sourceData[0].type.strip() == 'HistorySet':\n #####################################################################################################################################\n # @MANDD: This 'if' condition has been added in order to allow the user the correctly create an histogram out of an historySet #\n # If the histogram is created out of the input variables, then the plot has an identical meaning of the one generated by a pointSet #\n # However, if the histogram is created out of the output variables, then the plot consider only the last value of the array #\n #####################################################################################################################################\n data = {}\n data['x'] = np.empty(0)\n data['y'] = np.empty(0)\n for index in range(len(self.outStreamTypes)):\n for key in self.xValues[index]:\n data['x'] = np.append(data['x'], self.xValues[index][key][0][-1])\n if self.dim == 3:\n data['y'] = np.append(data['y'], self.yValues[index][key][0][-1])\n del self.xValues[index]\n self.xValues = {}\n self.xValues[index] = {}\n self.xValues[index][0] = []\n self.xValues[index][0].append(deepcopy(data['x']))\n if self.dim == 3:\n del self.yValues[index]\n self.yValues = {}\n self.yValues[index] ={ }\n self.yValues[index][0] = []\n self.yValues[index][0].append(deepcopy(data['y']))\n\n for key in self.xValues[pltIndex]:\n for xIndex in range(len(self.xValues[pltIndex][key])):\n try:\n colorss = ast.literal_eval(plotSettings['color'])\n # unknown what specific error is anticipated here, but I don't like a bare except...\n # ast.literal_eval can raise the exceptions listed below (see library docs):\n except (ValueError, TypeError, SyntaxError, MemoryError, RecursionError):\n colorss = plotSettings['color']\n if self.dim == 2:\n self.ax.hist(self.xValues[pltIndex][key][xIndex],\n bins=ast.literal_eval(plotSettings['bins']),\n density=ast.literal_eval(plotSettings['normed']),\n weights=ast.literal_eval(plotSettings['weights']),\n cumulative=ast.literal_eval(plotSettings['cumulative']),\n histtype=plotSettings['histtype'],\n align=plotSettings['align'],\n orientation=plotSettings['orientation'],\n rwidth=ast.literal_eval(plotSettings['rwidth']),\n log=ast.literal_eval(plotSettings['log']),\n color=colorss,\n stacked=ast.literal_eval(plotSettings['stacked']),\n **plotSettings.get('attributes', {}))\n else:\n for yIndex in range(len(self.yValues[pltIndex][key])):\n hist, xedges, yedges = np.histogram2d(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n bins=ast.literal_eval(plotSettings['bins']))\n elements = (len(xedges) - 1) * (len(yedges) - 1)\n if 'x_offset' in plotSettings:\n xoffset = float(plotSettings['x_offset'])\n else:\n xoffset = 0.25\n if 'y_offset' in plotSettings:\n yoffset = float(plotSettings['y_offset'])\n else:\n yoffset = 0.25\n if 'dx' in plotSettings:\n dxs = float(plotSettings['dx'])\n else:\n dxs = (self.xValues[pltIndex][key][xIndex].max() - self.xValues[pltIndex][key][xIndex].min()) / float(plotSettings['bins'])\n if 'dy' in plotSettings:\n dys = float(plotSettings['dy'])\n else:\n dys = (self.yValues[pltIndex][key][yIndex].max() - self.yValues[pltIndex][key][yIndex].min()) / float(plotSettings['bins'])\n xpos, ypos = np.meshgrid(xedges[:-1] + xoffset, yedges[:-1] + yoffset)\n self.actPlot = self.ax.bar3d(xpos.flatten(),\n ypos.flatten(),\n np.zeros(elements),\n dxs*np.ones_like(elements),\n dys*np.ones_like(elements),\n hist.flatten(),\n color=colorss,\n zsort='average',\n **plotSettings.get('attributes', {}))\n ##################\n # STEM PLOT #\n ##################\n elif self.outStreamTypes[pltIndex] == 'stem':\n if 'linefmt' not in plotSettings:\n plotSettings['linefmt'] = 'b-'\n if 'markerfmt' not in plotSettings:\n plotSettings['markerfmt'] = 'bo'\n if 'basefmt' not in plotSettings:\n plotSettings['basefmt'] = 'r-'\n for key in self.xValues[pltIndex]:\n for xIndex in range(len(self.xValues[pltIndex][key])):\n for yIndex in range(len(self.yValues[pltIndex][key])):\n if self.dim == 2:\n self.actPlot = self.ax.stem(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n linefmt=plotSettings['linefmt'],\n markerfmt=plotSettings['markerfmt'],\n basefmt = plotSettings['linefmt'],\n use_line_collection=True,\n **plotSettings.get('attributes', {}))\n else:\n # it is a basic stem plot constructed using a standard line plot. For now we do not use the previous defined keywords...\n for zIndex in range(len(self.zValues[pltIndex][key])):\n for xx, yy, zz in zip(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], self.zValues[pltIndex][key][zIndex]):\n self.ax.plot([xx, xx], [yy, yy], [0, zz], '-')\n ##################\n # STEP PLOT #\n ##################\n elif self.outStreamTypes[pltIndex] == 'step':\n if self.dim == 2:\n if 'where' not in plotSettings:\n plotSettings['where'] = 'mid'\n for key in self.xValues[pltIndex]:\n for xIndex in range(len(self.xValues[pltIndex][key])):\n if self.xValues[pltIndex][key][xIndex].size < 2:\n xi = self.xValues[pltIndex][key][xIndex]\n else:\n xi = np.linspace(self.xValues[pltIndex][key][xIndex].min(), self.xValues[pltIndex][key][xIndex].max(), ast.literal_eval(plotSettings['interpPointsX']))\n for yIndex in range(len(self.yValues[pltIndex][key])):\n if self.yValues[pltIndex][key][yIndex].size <= 3:\n return\n yi = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], plotSettings)\n self.actPlot = self.ax.step(xi, yi, where=plotSettings['where'], **plotSettings.get('attributes', {}))\n else:\n self.raiseAWarning('step Plot not available in 3D')\n return\n ########################\n # PSEUDOCOLOR PLOT #\n ########################\n elif self.outStreamTypes[pltIndex] == 'pseudocolor':\n if self.dim == 2:\n for key in self.xValues[pltIndex]:\n for xIndex in range(len(self.xValues[pltIndex][key])):\n # Hopefully, x,y, and z are all the same length, so checking this\n # here should be good enough.\n # The problem is you cannot interpolate any amount of space if\n # you only have a single data point.\n if self.xValues[pltIndex][key][xIndex].size == 1:\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\n continue\n for yIndex in range(len(self.yValues[pltIndex][key])):\n if not self.colorMapCoordinates:\n self.raiseAMessage('pseudocolor Plot needs coordinates for color map... Returning without plotting')\n return\n for zIndex in range(len(self.colorMapValues[pltIndex][key])):\n if self.colorMapValues[pltIndex][key][zIndex].size <= 3:\n return\n xig, yig, Ci = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n plotSettings,\n z=self.colorMapValues[pltIndex][key][zIndex],\n returnCoordinate=True)\n if plotSettings['cmap'] == 'None':\n self.actPlot = self.ax.pcolormesh(xig,\n yig,\n ma.masked_where(np.isnan(Ci), Ci),\n **plotSettings.get('attributes', {}))\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n else:\n self.actPlot = self.ax.pcolormesh(xig,\n yig,\n ma.masked_where(np.isnan(Ci), Ci),\n cmap=matplotlib.cm.get_cmap(name = plotSettings['cmap']),\n **plotSettings.get('attributes', {}))\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_array(ma.masked_where(np.isnan(Ci), Ci))\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n actcm = self.fig.colorbar(m)\n actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n self.raiseAWarning('pseudocolor Plot is considered a 2D plot, not a 3D!')\n return\n ########################\n # SURFACE PLOT #\n ########################\n elif self.outStreamTypes[pltIndex] == 'surface':\n if self.dim == 2:\n self.raiseAWarning('surface Plot is NOT available for 2D plots, IT IS A 3D!')\n return\n else:\n if 'rstride' not in plotSettings:\n plotSettings['rstride'] = '1'\n if 'cstride' not in plotSettings:\n plotSettings['cstride'] = '1'\n if 'antialiased' not in plotSettings:\n plotSettings['antialiased'] = 'False'\n if 'linewidth' not in plotSettings:\n plotSettings['linewidth'] = '0'\n for key in self.xValues[pltIndex]:\n for xIndex in range(len(self.xValues[pltIndex][key])):\n # Hopefully, x,y, and z are all the same length, so checking this\n # here should be good enough.\n # The problem is you cannot interpolate any amount of space if\n # you only have a single data point.\n if self.xValues[pltIndex][key][xIndex].size == 1:\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\n continue\n for yIndex in range(len(self.yValues[pltIndex][key])):\n for zIndex in range(len(self.zValues[pltIndex][key])):\n if self.zValues[pltIndex][key][zIndex].size <= 3:\n return\n if self.colorMapCoordinates[pltIndex] is not None:\n xig, yig, Ci = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n plotSettings,\n z=self.colorMapValues[pltIndex][key][zIndex],\n returnCoordinate=True)\n xig, yig, zi = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n plotSettings,\n z=self.zValues[pltIndex][key][zIndex],\n returnCoordinate=True)\n if self.colorMapCoordinates[pltIndex] is not None:\n if self.actcm:\n first = False\n else:\n first = True\n if plotSettings['cmap'] == 'None':\n plotSettings['cmap'] = 'jet'\n self.actPlot = self.ax.plot_surface(xig,\n yig,\n ma.masked_where(np.isnan(zi), zi),\n rstride=ast.literal_eval(plotSettings['rstride']),\n cstride=ast.literal_eval(plotSettings['cstride']),\n facecolors=matplotlib.cm.get_cmap(name=plotSettings['cmap'])(ma.masked_where(np.isnan(Ci), Ci)),\n cmap=matplotlib.cm.get_cmap(name = plotSettings['cmap']),\n linewidth=ast.literal_eval(plotSettings['linewidth']),\n antialiased=ast.literal_eval(plotSettings['antialiased']),\n **plotSettings.get('attributes', {}))\n if first:\n self.actPlot.cmap = matplotlib.cm.get_cmap(name=plotSettings['cmap'])\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n if first:\n m = matplotlib.cm.ScalarMappable(cmap = self.actPlot.cmap, norm = self.actPlot.norm)\n m.set_array(self.colorMapValues[pltIndex][key])\n self.actcm = self.fig.colorbar(m)\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_clim(vmin=min(self.colorMapValues[pltIndex][key][-1]), vmax=max(self.colorMapValues[pltIndex][key][-1]))\n self.actcm.draw_all()\n else:\n if plotSettings['cmap'] == 'None':\n self.actPlot = self.ax.plot_surface(xig,\n yig,\n ma.masked_where(np.isnan(zi), zi),\n rstride=ast.literal_eval(plotSettings['rstride']),\n cstride=ast.literal_eval(plotSettings['cstride']),\n linewidth=ast.literal_eval(plotSettings['linewidth']),\n antialiased=ast.literal_eval(plotSettings['antialiased']),\n **plotSettings.get('attributes', {}))\n if 'color' in plotSettings.get('attributes', {}):\n self.actPlot.set_color = plotSettings.get('attributes', {})['color']\n else:\n self.actPlot.set_color = 'blue'\n else:\n self.actPlot = self.ax.plot_surface(xig,\n yig,\n ma.masked_where(np.isnan(zi), zi),\n rstride=ast.literal_eval(plotSettings['rstride']),\n cstride=ast.literal_eval(plotSettings['cstride']),\n cmap=matplotlib.cm.get_cmap(name = plotSettings['cmap']),\n linewidth=ast.literal_eval(plotSettings['linewidth']),\n antialiased=ast.literal_eval(plotSettings['antialiased']),\n **plotSettings.get('attributes', {}))\n ########################\n # TRI-SURFACE PLOT #\n ########################\n elif self.outStreamTypes[pltIndex] == 'tri-surface':\n if self.dim == 2:\n self.raiseAWarning('TRI-surface Plot is NOT available for 2D plots, it is 3D!')\n return\n else:\n if 'color' not in plotSettings:\n plotSettings['color'] = 'b'\n if 'shade' not in plotSettings:\n plotSettings['shade'] = 'False'\n for key in self.xValues[pltIndex]:\n for xIndex in range(len(self.xValues[pltIndex][key])):\n # Hopefully, x,y, and z are all the same length, so checking this\n # here should be good enough.\n # The problem is you cannot interpolate any amount of space if\n # you only have a single data point.\n if self.xValues[pltIndex][key][xIndex].size == 1:\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\n continue\n for yIndex in range(len(self.yValues[pltIndex][key])):\n for zIndex in range(len(self.zValues[pltIndex][key])):\n metric = (self.xValues[pltIndex][key][xIndex] ** 2 + self.yValues[pltIndex][key][yIndex] ** 2) ** 0.5\n metricIndeces = np.argsort(metric)\n xs = np.zeros(self.xValues[pltIndex][key][xIndex].shape)\n ys = np.zeros(self.yValues[pltIndex][key][yIndex].shape)\n zs = np.zeros(self.zValues[pltIndex][key][zIndex].shape)\n for sindex in range(len(metricIndeces)):\n xs[sindex] = self.xValues[pltIndex][key][xIndex][metricIndeces[sindex]]\n ys[sindex] = self.yValues[pltIndex][key][yIndex][metricIndeces[sindex]]\n zs[sindex] = self.zValues[pltIndex][key][zIndex][metricIndeces[sindex]]\n surfacePlotOptions = {'color': plotSettings['color'],\n 'shade': ast.literal_eval(plotSettings['shade'])}\n surfacePlotOptions.update(plotSettings.get('attributes', {}))\n if self.zValues[pltIndex][key][zIndex].size <= 3:\n return\n if self.colorMapCoordinates[pltIndex] is not None:\n if self.actcm:\n first = False\n else:\n first = True\n if plotSettings['cmap'] == 'None':\n plotSettings['cmap'] = 'jet'\n surfacePlotOptions['cmap'] = matplotlib.cm.get_cmap(name = plotSettings['cmap'])\n self.actPlot = self.ax.plot_trisurf(xs, ys, zs, **surfacePlotOptions)\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n if first:\n self.actPlot.cmap = matplotlib.cm.get_cmap(name=plotSettings['cmap'])\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_array(self.colorMapValues[pltIndex][key])\n self.actcm = self.fig.colorbar(m)\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_clim(vmin=min(self.colorMapValues[pltIndex][key][-1]), vmax=max(self.colorMapValues[pltIndex][key][-1]))\n self.actcm.draw_all()\n else:\n if plotSettings['cmap'] != 'None':\n surfacePlotOptions[\"cmap\"] = matplotlib.cm.get_cmap(name=plotSettings['cmap'])\n self.actPlot = self.ax.plot_trisurf(xs, ys, zs, **surfacePlotOptions)\n ########################\n # WIREFRAME PLOT #\n ########################\n elif self.outStreamTypes[pltIndex] == 'wireframe':\n if self.dim == 2:\n self.raiseAWarning('wireframe Plot is NOT available for 2D plots, IT IS A 3D!')\n return\n else:\n if 'rstride' not in plotSettings:\n plotSettings['rstride'] = '1'\n if 'cstride' not in plotSettings:\n plotSettings['cstride'] = '1'\n for key in self.xValues[pltIndex]:\n for xIndex in range(len(self.xValues[pltIndex][key])):\n # Hopefully, x,y, and z are all the same length, so checking this\n # here should be good enough.\n # The problem is you cannot interpolate any amount of space if\n # you only have a single data point.\n if self.xValues[pltIndex][key][xIndex].size == 1:\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\n continue\n for yIndex in range(len(self.yValues[pltIndex][key])):\n for zIndex in range(len(self.zValues[pltIndex][key])):\n if self.zValues[pltIndex][key][zIndex].size <= 3:\n return\n if self.colorMapCoordinates[pltIndex] is not None:\n xig, yig, Ci = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n plotSettings,\n z=self.colorMapValues[pltIndex][key][zIndex],\n returnCoordinate=True)\n xig, yig, zi = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n plotSettings,\n z=self.zValues[pltIndex][key][zIndex],\n returnCoordinate=True)\n if self.colorMapCoordinates[pltIndex] is not None:\n self.raiseAWarning(f'Currently, ax.plot_wireframe() in MatPlotLib version: {matplotlib.__version__} does not support a colormap! Wireframe plotted on a surface plot...')\n if self.actcm:\n first = False\n else:\n first = True\n if plotSettings['cmap'] == 'None':\n plotSettings['cmap'] = 'jet'\n self.actPlot = self.ax.plot_wireframe(xig,\n yig,\n ma.masked_where(np.isnan(zi), zi),\n rstride=ast.literal_eval(plotSettings['rstride']),\n cmap=matplotlib.cm.get_cmap(name = plotSettings['cmap']),\n cstride=ast.literal_eval(plotSettings['cstride']),\n **plotSettings.get('attributes', {}))\n self.actPlot = self.ax.plot_surface(xig,\n yig,\n ma.masked_where(np.isnan(zi), zi),\n alpha=0.4,\n rstride=ast.literal_eval(plotSettings['rstride']),\n cmap=matplotlib.cm.get_cmap(name=plotSettings['cmap']),\n cstride=ast.literal_eval(plotSettings['cstride']),\n **plotSettings.get('attributes', {}))\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n if first:\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_array(self.colorMapValues[pltIndex][key])\n self.actcm = self.fig.colorbar(m)\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\n m.set_clim(vmin=min(self.colorMapValues[pltIndex][key][-1]), vmax=max(self.colorMapValues[pltIndex][key][-1]))\n self.actcm.draw_all()\n else:\n if plotSettings['cmap'] == 'None':\n self.actPlot = self.ax.plot_wireframe(xig,\n yig,\n ma.masked_where(np.isnan(zi), zi),\n rstride=ast.literal_eval(plotSettings['rstride']),\n cstride=ast.literal_eval(plotSettings['cstride']),\n **plotSettings.get('attributes', {}))\n if 'color' in plotSettings.get('attributes', {}):\n self.actPlot.set_color = plotSettings.get('attributes', {})['color']\n else:\n self.actPlot.set_color = 'blue'\n else:\n self.actPlot = self.ax.plot_wireframe(xig,\n yig,\n ma.masked_where(np.isnan(zi), zi),\n rstride=ast.literal_eval(plotSettings['rstride']),\n cstride=ast.literal_eval(plotSettings['cstride']),\n **plotSettings.get('attributes', {}))\n ########################\n # CONTOUR PLOT #\n ########################\n elif self.outStreamTypes[pltIndex] == 'contour' or self.outStreamTypes[pltIndex] == 'filledContour':\n if self.dim == 2:\n if 'numberBins' in plotSettings:\n nbins = int(plotSettings['numberBins'])\n else:\n nbins = 5\n for key in self.xValues[pltIndex]:\n if not self.colorMapCoordinates:\n self.raiseAWarning(self.outStreamTypes[pltIndex] + ' Plot needs coordinates for color map... Returning without plotting')\n return\n for xIndex in range(len(self.xValues[pltIndex][key])):\n # Hopefully, x,y, and z are all the same length, so checking this\n # here should be good enough.\n # The problem is you cannot interpolate any amount of space if\n # you only have a single data point.\n if self.xValues[pltIndex][key][xIndex].size == 1:\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\n continue\n for yIndex in range(len(self.yValues[pltIndex][key])):\n for zIndex in range(len(self.colorMapValues[pltIndex][key])):\n if self.actcm:\n first = False\n else:\n first = True\n xig, yig, Ci = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n plotSettings,\n z=self.colorMapValues[pltIndex][key][zIndex],\n returnCoordinate=True)\n if self.outStreamTypes[pltIndex] == 'contour':\n if plotSettings['cmap'] == 'None':\n if 'color' in plotSettings.get('attributes', {}):\n color = plotSettings.get('attributes', {})['color']\n else:\n color = 'blue'\n self.actPlot = self.ax.contour(xig,\n yig,\n ma.masked_where(np.isnan(Ci), Ci),\n nbins,\n colors=color,\n **plotSettings.get('attributes', {}))\n else:\n self.actPlot = self.ax.contour(xig,\n yig,\n ma.masked_where(np.isnan(Ci), Ci),\n nbins,\n **plotSettings.get('attributes', {}))\n else:\n if plotSettings['cmap'] == 'None':\n plotSettings['cmap'] = 'jet'\n self.actPlot = self.ax.contourf(xig,\n yig,\n ma.masked_where(np.isnan(Ci), Ci),\n nbins,\n **plotSettings.get('attributes', {}))\n self.ax.clabel(self.actPlot, inline=1, fontsize=10)\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n if first:\n self.actcm = self.fig.colorbar(self.actPlot, shrink=0.8, extend='both')\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n m = matplotlib.cm.ScalarMappable(cmap = self.actPlot.cmap, norm = self.actPlot.norm)\n m.set_clim(vmin = min(self.colorMapValues[pltIndex][key][-1]), vmax = max(self.colorMapValues[pltIndex][key][-1]))\n self.actcm.draw_all()\n else:\n self.raiseAWarning('contour/filledContour is a 2-D plot, where x,y are the surface coordinates and colorMap vector is the array to visualize!\\n contour3D/filledContour3D are 3-D! ')\n return\n # These should be combined: ^^^ & vvv\n elif self.outStreamTypes[pltIndex] == 'contour3D' or self.outStreamTypes[pltIndex] == 'filledContour3D':\n if self.dim == 2:\n self.raiseAWarning('contour3D/filledContour3D Plot is NOT available for 2D plots, IT IS A 2D! Check \"contour/filledContour\"!')\n return\n else:\n if 'numberBins' in plotSettings:\n nbins = int(plotSettings['numberBins'])\n else:\n nbins = 5\n if 'extend3D' in plotSettings:\n ext3D = bool(plotSettings['extend3D'])\n else:\n ext3D = False\n for key in self.xValues[pltIndex]:\n for xIndex in range(len(self.xValues[pltIndex][key])):\n # Hopefully, x,y, and z are all the same length, so checking this\n # here should be good enough.\n # The problem is you cannot interpolate any amount of space if\n # you only have a single data point.\n if self.xValues[pltIndex][key][xIndex].size == 1:\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\n continue\n for yIndex in range(len(self.yValues[pltIndex][key])):\n for zIndex in range(len(self.colorMapValues[pltIndex][key])):\n if self.actcm:\n first = False\n else:\n first = True\n xig, yig, Ci = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\n self.yValues[pltIndex][key][yIndex],\n plotSettings,\n z=self.colorMapValues[pltIndex][key][zIndex],\n returnCoordinate=True)\n if self.outStreamTypes[pltIndex] == 'contour3D':\n if plotSettings['cmap'] == 'None':\n if 'color' in plotSettings.get('attributes', {}):\n color = plotSettings.get('attributes', {})['color']\n else:\n color = 'blue'\n self.actPlot = self.ax.contour3D(xig,\n yig,\n ma.masked_where(np.isnan(Ci), Ci),\n nbins,\n colors=color,\n extend3d=ext3D,\n **plotSettings.get('attributes', {}))\n else:\n self.actPlot = self.ax.contour3D(xig,\n yig,\n ma.masked_where(np.isnan(Ci), Ci),\n nbins,\n extend3d=ext3D,\n cmap=matplotlib.cm.get_cmap(name=plotSettings['cmap']),\n **plotSettings.get('attributes', {}))\n else:\n if plotSettings['cmap'] == 'None':\n plotSettings['cmap'] = 'jet'\n self.actPlot = self.ax.contourf3D(xig,\n yig,\n ma.masked_where(np.isnan(Ci), Ci),\n nbins,\n cmap=matplotlib.cm.get_cmap(name=plotSettings['cmap']),\n **plotSettings.get('attributes', {}))\n self.ax.clabel(self.actPlot, inline=1, fontsize=10)\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\n if first:\n self.actcm = self.fig.colorbar(self.actPlot, shrink = 0.8, extend = 'both')\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\n else:\n m = matplotlib.cm.ScalarMappable(cmap = self.actPlot.cmap, norm = self.actPlot.norm)\n m.set_clim(vmin = min(self.colorMapValues[pltIndex][key][-1]), vmax = max(self.colorMapValues[pltIndex][key][-1]))\n self.actcm.draw_all()\n ########################\n # DataMining PLOT #\n ########################\n elif self.outStreamTypes[pltIndex] == 'dataMining':\n colors = cycle(['#88CCEE', '#DDCC77', '#AA4499', '#117733', '#332288', '#999933', '#44AA99', '#882255', '#CC6677', '#CD6677', '#DC6877', '#886677', '#AA6677', '#556677', '#CD7865'])\n if 's' not in plotSettings:\n plotSettings['s'] = '20'\n if 'c' not in plotSettings:\n plotSettings['c'] = 'b'\n if 'marker' not in plotSettings:\n plotSettings['marker'] = 'o'\n if 'alpha' not in plotSettings:\n plotSettings['alpha'] = 'None'\n if 'linewidths' not in plotSettings:\n plotSettings['linewidths'] = 'None'\n clusterDict[pltIndex] = {}\n for key in self.xValues[pltIndex]:\n for xIndex in range(len(self.xValues[pltIndex][key])):\n for yIndex in range(len(self.yValues[pltIndex][key])):\n dataMiningPlotOptions = {'s': ast.literal_eval(plotSettings['s']),\n 'marker': (plotSettings['marker']),\n 'alpha': ast.literal_eval(plotSettings['alpha']),\n 'linewidths': ast.literal_eval(plotSettings['linewidths'])}\n if self.colorMapCoordinates[pltIndex] is not None:\n self.raiseAWarning('ColorMap values supplied, however DataMining plots do not use colorMap from input.')\n if plotSettings['cmap'] == 'None':\n self.raiseAWarning('ColorSet supplied, however DataMining plots do not use color set from input.')\n if 'cluster' == plotSettings['SKLtype']:\n # TODO: include the cluster Centers to the plot\n if 'noClusters' in plotSettings.get('attributes', {}):\n clusterDict[pltIndex]['noClusters'] = int(plotSettings.get('attributes', {})['noClusters'])\n plotSettings.get('attributes', {}).pop('noClusters')\n else:\n clusterDict[pltIndex]['noClusters'] = np.amax(self.clusterValues[pltIndex][1][0]) + 1\n dataMiningPlotOptions.update(plotSettings.get('attributes', {}))\n if self.dim == 2:\n clusterDict[pltIndex]['clusterValues'] = np.zeros(shape=(len(self.xValues[pltIndex][key][xIndex]), 2))\n else:\n clusterDict[pltIndex]['clusterValues'] = np.zeros(shape=(len(self.xValues[pltIndex][key][xIndex]), 3))\n clusterDict[pltIndex]['clusterValues'][:, 0] = self.xValues[pltIndex][key][xIndex]\n clusterDict[pltIndex]['clusterValues'][:, 1] = self.yValues[pltIndex][key][yIndex]\n if self.dim == 2:\n for k, col in zip(range(int(clusterDict[pltIndex]['noClusters'])), colors):\n myMembers = self.clusterValues[pltIndex][1][0] == k\n self.actPlot = self.ax.scatter(clusterDict[pltIndex]['clusterValues'][myMembers, 0],\n clusterDict[pltIndex]['clusterValues'][myMembers, 1],\n color=col,\n **dataMiningPlotOptions)\n\n # Handle all of the outlying data\n myMembers = self.clusterValues[pltIndex][1][0] == -1\n # resize the points\n dataMiningPlotOptions['s'] /= 2\n # and hollow out their markers\n if 'facecolors' in dataMiningPlotOptions:\n faceColors = dataMiningPlotOptions['facecolors']\n else:\n faceColors = None\n dataMiningPlotOptions['facecolors'] = 'none'\n\n self.actPlot = self.ax.scatter(clusterDict[pltIndex]['clusterValues'][myMembers, 0],\n clusterDict[pltIndex]['clusterValues'][myMembers, 1],\n color='#000000',\n **dataMiningPlotOptions)\n\n # Restore the plot options to their original values\n dataMiningPlotOptions['s'] *= 2\n if faceColors is not None:\n dataMiningPlotOptions['facecolors'] = faceColors\n else:\n del dataMiningPlotOptions['facecolors']\n\n else:\n for zIndex in range(len(self.zValues[pltIndex][key])):\n clusterDict[pltIndex]['clusterValues'][:, 2] = self.zValues[pltIndex][key][zIndex]\n for k, col in zip(range(int(clusterDict[pltIndex]['noClusters'])), colors):\n myMembers = self.clusterValues[pltIndex][1][0] == k\n self.actPlot = self.ax.scatter(clusterDict[pltIndex]['clusterValues'][myMembers, 0],\n clusterDict[pltIndex]['clusterValues'][myMembers, 1],\n clusterDict[pltIndex]['clusterValues'][myMembers, 2],\n color=col,\n **dataMiningPlotOptions)\n\n # Handle all of the outlying data\n myMembers = self.clusterValues[pltIndex][1][0] == -1\n # resize the points\n dataMiningPlotOptions['s'] /= 2\n # and hollow out their markers\n if 'facecolors' in dataMiningPlotOptions:\n faceColors = dataMiningPlotOptions['facecolors']\n else:\n faceColors = None\n dataMiningPlotOptions['facecolors'] = 'none'\n\n self.actPlot = self.ax.scatter(clusterDict[pltIndex]['clusterValues'][myMembers, 0],\n clusterDict[pltIndex]['clusterValues'][myMembers, 1],\n clusterDict[pltIndex]['clusterValues'][myMembers, 2],\n color='#000000',\n **dataMiningPlotOptions)\n\n # Restore the plot options to their original values\n dataMiningPlotOptions['s'] *= 2\n if faceColors is not None:\n dataMiningPlotOptions['facecolors'] = faceColors\n else:\n del dataMiningPlotOptions['facecolors']\n\n elif 'bicluster' == plotSettings['SKLtype']:\n self.raiseAnError(IOError, 'SKLType Bi-Cluster Plots are not implemented yet!..')\n elif 'mixture' == plotSettings['SKLtype']:\n if 'noMixtures' in plotSettings.get('attributes', {}):\n clusterDict[pltIndex]['noMixtures'] = int(plotSettings.get('attributes', {})['noMixtures'])\n plotSettings.get('attributes', {}).pop('noMixtures')\n else:\n clusterDict[pltIndex]['noMixtures'] = np.amax(self.mixtureValues[pltIndex][1][0]) + 1\n if self.dim == 3:\n self.raiseAnError(IOError, 'SKLType Mixture Plots are only available in 2-Dimensions')\n else:\n clusterDict[pltIndex]['mixtureValues'] = np.zeros(shape = (len(self.xValues[pltIndex][key][xIndex]), 2))\n clusterDict[pltIndex]['mixtureValues'][:, 0] = self.xValues[pltIndex][key][xIndex]\n clusterDict[pltIndex]['mixtureValues'][:, 1] = self.yValues[pltIndex][key][yIndex]\n if 'mixtureCovars' in plotSettings.get('attributes', {}):\n split = self.__splitVariableNames('mixtureCovars', (pltIndex, 0))\n # mixtureCovars = self.sourceData[pltIndex].getParam(split[1], split[2], nodeId = 'ending')\n plotSettings.get('attributes', {}).pop('mixtureCovars')\n # else:\n # mixtureCovars = None\n if 'mixtureMeans' in plotSettings.get('attributes', {}):\n split = self.__splitVariableNames('mixtureMeans', (pltIndex, 0))\n # mixtureMeans = self.sourceData[pltIndex].getParam(split[1], split[2], nodeId = 'ending')\n plotSettings.get('attributes', {}).pop('mixtureMeans')\n # else:\n # mixtureMeans = None\n # mixtureCovars.reshape(3, 4)\n # mixtureMeans.reshape(3, 4)\n # for i, (mean, covar, col) in enumerate(zip(mixtureMeans, mixtureCovars, colors)):\n for i, col in zip(range(clusterDict[pltIndex]['noMixtures']), colors):\n if not np.any(self.mixtureValues[pltIndex][1][0] == i):\n continue\n myMembers = self.mixtureValues[pltIndex][1][0] == i\n self.actPlot = self.ax.scatter(clusterDict[pltIndex]['mixtureValues'][myMembers, 0],\n clusterDict[pltIndex]['mixtureValues'][myMembers, 1],\n color=col,\n **dataMiningPlotOptions)\n elif 'manifold' == plotSettings['SKLtype']:\n if self.dim == 2:\n manifoldValues = np.zeros(shape=(len(self.xValues[pltIndex][key][xIndex]), 2))\n else:\n manifoldValues = np.zeros(shape=(len(self.xValues[pltIndex][key][xIndex]), 3))\n manifoldValues[:, 0] = self.xValues[pltIndex][key][xIndex]\n manifoldValues[:, 1] = self.yValues[pltIndex][key][yIndex]\n if 'clusterLabels' in plotSettings.get('attributes', {}):\n split = self.__splitVariableNames('clusterLabels', (pltIndex, 0))\n clusterDict[pltIndex]['clusterLabels'] = self.sourceData[pltIndex].getParam(split[1], split[2], nodeId = 'ending')\n plotSettings.get('attributes', {}).pop('clusterLabels')\n else:\n clusterDict[pltIndex]['clusterLabels'] = None\n if 'noClusters' in plotSettings.get('attributes', {}):\n clusterDict[pltIndex]['noClusters'] = int(plotSettings.get('attributes', {})['noClusters'])\n plotSettings.get('attributes', {}).pop('noClusters')\n else:\n clusterDict[pltIndex]['noClusters'] = np.amax(self.clusterValues[pltIndex][1][0]) + 1\n if self.clusterValues[pltIndex][1][0] is not None:\n if self.dim == 2:\n for k, col in zip(range(clusterDict[pltIndex]['noClusters']), colors):\n myMembers = self.clusterValues[pltIndex][1][0] == k\n self.actPlot = self.ax.scatter(manifoldValues[myMembers, 0],\n manifoldValues[myMembers, 1],\n color=col,\n **dataMiningPlotOptions)\n else:\n for zIndex in range(len(self.zValues[pltIndex][key])):\n manifoldValues[:, 2] = self.zValues[pltIndex][key][zIndex]\n for k, col in zip(range(clusterDict[pltIndex]['noClusters']), colors):\n myMembers = self.clusterValues[pltIndex][1][0] == k\n self.actPlot = self.ax.scatter(manifoldValues[myMembers, 0],\n manifoldValues[myMembers, 1],\n manifoldValues[myMembers, 2],\n color=col,\n **dataMiningPlotOptions)\n else:\n if self.dim == 2:\n self.actPlot = self.ax.scatter(manifoldValues[:, 0],\n manifoldValues[:, 1],\n **dataMiningPlotOptions)\n else:\n for zIndex in range(len(self.zValues[pltIndex][key])):\n manifoldValues[:, 2] = self.zValues[pltIndex][key][zIndex]\n self.actPlot = self.ax.scatter(manifoldValues[:, 0],\n manifoldValues[:, 1],\n manifoldValues[:, 2],\n **dataMiningPlotOptions)\n elif 'decomposition' == plotSettings['SKLtype']:\n if self.dim == 2:\n decompositionValues = np.zeros(shape = (len(self.xValues[pltIndex][key][xIndex]), 2))\n else:\n decompositionValues = np.zeros(shape = (len(self.xValues[pltIndex][key][xIndex]), 3))\n decompositionValues[:, 0] = self.xValues[pltIndex][key][xIndex]\n decompositionValues[:, 1] = self.yValues[pltIndex][key][yIndex]\n if 'noClusters' in plotSettings.get('attributes', {}):\n clusterDict[pltIndex]['noClusters'] = int(plotSettings.get('attributes', {})['noClusters'])\n plotSettings.get('attributes', {}).pop('noClusters')\n else:\n clusterDict[pltIndex]['noClusters'] = np.amax(self.clusterValues[pltIndex][1][0]) + 1\n if self.clusterValues[pltIndex][1][0] is not None:\n if self.dim == 2:\n for k, col in zip(range(clusterDict[pltIndex]['noClusters']), colors):\n myMembers = self.clusterValues[pltIndex][1][0] == k\n self.actPlot = self.ax.scatter(decompositionValues[myMembers, 0],\n decompositionValues[myMembers, 1],\n color=col,\n **dataMiningPlotOptions)\n else:\n for zIndex in range(len(self.zValues[pltIndex][key])):\n decompositionValues[:, 2] = self.zValues[pltIndex][key][zIndex]\n for k, col in zip(range(clusterDict[pltIndex]['noClusters']), colors):\n myMembers = self.clusterValues[pltIndex][1][0] == k\n self.actPlot = self.ax.scatter(decompositionValues[myMembers, 0],\n decompositionValues[myMembers, 1],\n decompositionValues[myMembers, 2],\n color=col,\n **dataMiningPlotOptions)\n else:\n # no ClusterLabels\n if self.dim == 2:\n self.actPlot = self.ax.scatter(decompositionValues[:, 0],\n decompositionValues[:, 1],\n **dataMiningPlotOptions)\n else:\n for zIndex in range(len(self.zValues[pltIndex][key])):\n decompositionValues[:, 2] = self.zValues[pltIndex][key][zIndex]\n self.actPlot = self.ax.scatter(decompositionValues[:, 0],\n decompositionValues[:, 1],\n decompositionValues[:, 2],\n **dataMiningPlotOptions)\n else:\n # Let's try to \"write\" the code for the plot on the fly\n self.raiseAWarning('Trying to create a non-predefined plot of type ' + self.outStreamTypes[pltIndex] + '. If this fails, please refer to the and/or the related matplotlib method specification.')\n kwargs = {}\n for kk in plotSettings:\n if kk != 'attributes' and kk != self.outStreamTypes[pltIndex]:\n try:\n kwargs[kk] = ast.literal_eval(plotSettings[kk])\n except ValueError:\n kwargs[kk] = plotSettings[kk]\n try:\n if self.dim == 2:\n customFunctionCall = getattr(self.ax, self.outStreamTypes[pltIndex])\n else:\n customFunctionCall = getattr(self.ax, self.outStreamTypes[pltIndex])\n self.actPlot = customFunctionCall(**kwargs)\n except AttributeError as ae:\n self.raiseAnError(RuntimeError, '<' + str(ae) + '> -> in execution custom plot \"' + self.outStreamTypes[pltIndex] + '\" in Plot ' + self.name + '.\\nSTREAM MANAGER: ERROR -> command has been called in the following way: ' + 'ax.' + self.outStreamTypes[pltIndex])\n\n if 'legend' in self.options['plotSettings']:\n self.fig.legend(**self.options['plotSettings']['legend'])\n\n # SHOW THE PICTURE\n self.__executeActions()\n self.fig.canvas.draw_idle()\n\n if 'screen' in self.destinations and display:\n def handle_close(event):\n \"\"\"\n This method is aimed to handle the closing of figures (overall when in interactive mode)\n @ In, event, instance, the event to close\n @ Out, None\n \"\"\"\n self.fig.canvas.stop_event_loop()\n self.raiseAMessage('Closed Figure')\n self.fig.canvas.mpl_connect('close_event', handle_close)\n # self.plt.pause(1e-6)\n # The following code is extracted from pyplot.pause without actually\n # needing to force the code to sleep, according to MPL's documentation,\n # this feature is experimental, hopefully by not calling the pause\n # function, we can obtain consistent results.\n # We are skipping a few of the sanity checks done in that function,\n # since we are sure we have an interactive backend and access to the\n # correct type of canvas and figure.\n self.fig.canvas.draw()\n # If your graphs are unresponsive to user input, you may want to consider\n # adjusting this timeout, to allow more time for the input to be handled.\n self.fig.canvas.start_event_loop(1e-3)\n\n # self.fig.canvas.flush_events()\n\n for fileType in self.destinations:\n if fileType == 'screen':\n continue\n\n if not self.overwrite:\n prefix = str(self.counter) + '-'\n else:\n prefix = ''\n\n if len(self.filename) > 0:\n name = self.filename\n else:\n name = prefix + self.name + '_' + str(self.outStreamTypes).replace(\"'\", \"\").replace(\"[\", \"\").replace(\"]\", \"\").replace(\",\", \"-\").replace(\" \", \"\")\n\n if self.subDirectory is not None:\n name = os.path.join(self.subDirectory,name)\n\n self.fig.savefig(name + '.' + fileType, format=fileType)\n\n if 'screen' not in self.destinations:\n plt.close(fig=self.fig)\n\n gc.collect()","def plot_grid(filename, title, names, x):\n fig = plt.figure(figsize=(10,6))\n ax = fig.add_subplot(111)\n ax.set_title(title)\n plt.imshow(x, interpolation=\"nearest\", cmap=plt.get_cmap(\"hot\"))\n ax.set_aspect('equal')\n plt.xticks(range(6), names, rotation='vertical')\n plt.yticks(range(6), names)\n plt.subplots_adjust(bottom=0.25)\n # ax.set_xticklabels(('',) + names)\n # ax.set_yticklabels(('',) + names)\n cax = fig.add_axes([0.12, 0.1, 0.78, 0.8])\n cax.get_xaxis().set_visible(False)\n cax.get_yaxis().set_visible(False)\n cax.patch.set_alpha(0)\n cax.set_frame_on(False)\n plt.colorbar(orientation='vertical')\n plt.savefig(filename+\".pdf\")\n fig.clear()","def plot_directory_numex(path, vals, param='density', outname=None, show=True,\n xscale=1e-3,yscale=1e2):\n #vals = arange(2300.0, 2800.0, 50.0)\n outdirs = np.sort(os.listdir(path))\n plt.figure()\n\n # Plot surface profiles for each parameter\n for val,outdir in zip(vals,outdirs):\n pointsFile = os.path.join(path, outdir, 'points.h5')\n print(pointsFile)\n x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile, output=True, adjustRadial=True)\n x_fem = x_fem / xscale\n ur_fem = ur_fem / yscale\n uz_fem = uz_fem / yscale\n l, = plt.plot(x_fem,uz_fem,'.-',label=str(val))\n plt.plot(x_fem,ur_fem,'.-',color=l.get_color())\n\n # Annotate\n plt.axhline(color='k') #zero displacement line\n plt.title(param)\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n plt.legend()\n\n if outname: plt.savefig(outname)\n if show: plt.show()","def do_data_plots(cat, subdir):\n dla_data.noterdaeme_12_data()\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(zmax=5,color=\"blue\")\n np.savetxt(path.join(subdir,\"cddf_all.txt\"), (l_N, cddf, cddf68[:,0], cddf68[:,1], cddf95[:,0],cddf95[:,1]))\n plt.xlim(1e20, 1e23)\n plt.ylim(1e-28, 5e-21)\n plt.legend(loc=0)\n save_figure(path.join(subdir, \"cddf_gp\"))\n plt.clf()\n\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(zmax=5,color=\"blue\", moment=True)\n plt.xlim(1e20, 1e23)\n plt.legend(loc=0)\n save_figure(path.join(subdir, \"cddf_moment_gp\"))\n plt.clf()\n\n #Evolution with redshift\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(4,5, label=\"4-5\", color=\"brown\")\n np.savetxt(path.join(subdir,\"cddf_z45.txt\"), (l_N, cddf, cddf68[:,0], cddf68[:,1], cddf95[:,0],cddf95[:,1]))\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(3,4, label=\"3-4\", color=\"black\")\n np.savetxt(path.join(subdir,\"cddf_z34.txt\"), (l_N, cddf, cddf68[:,0], cddf68[:,1], cddf95[:,0],cddf95[:,1]))\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(2.5,3, label=\"2.5-3\", color=\"green\")\n np.savetxt(path.join(subdir,\"cddf_z253.txt\"), (l_N, cddf, cddf68[:,0], cddf68[:,1], cddf95[:,0],cddf95[:,1]))\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(2,2.5, label=\"2-2.5\", color=\"blue\")\n np.savetxt(path.join(subdir,\"cddf_z225.txt\"), (l_N, cddf, cddf68[:,0], cddf68[:,1], cddf95[:,0],cddf95[:,1]))\n plt.xlim(1e20, 1e23)\n plt.ylim(1e-28, 5e-21)\n plt.legend(loc=0)\n save_figure(path.join(subdir,\"cddf_zz_gp\"))\n plt.clf()\n\n #dNdX\n dla_data.dndx_not()\n dla_data.dndx_pro()\n (z_cent, dNdX, dndx68, dndx95) = cat.plot_line_density(zmax=5)\n np.savetxt(path.join(subdir,\"dndx_all.txt\"), (z_cent, dNdX, dndx68[:,0],dndx68[:,1], dndx95[:,0],dndx95[:,1]) )\n plt.legend(loc=0)\n plt.ylim(0,0.16)\n save_figure(path.join(subdir,\"dndx_gp\"))\n plt.clf()\n\n #Omega_DLA\n dla_data.omegahi_not()\n dla_data.omegahi_pro()\n dla_data.crighton_omega()\n (z_cent, omega_dla, omega_dla_68, omega_dla_95) = cat.plot_omega_dla(zmax=5)\n# cat.tophat_prior = True\n# cat.plot_omega_dla(zmax=5, label=\"Tophat Prior\", twosigma=False)\n# cat.tophat_prior = False\n np.savetxt(path.join(subdir,\"omega_dla_all.txt\"), (z_cent, omega_dla, omega_dla_68[:,0],omega_dla_68[:,1], omega_dla_95[:,0], omega_dla_95[:,1]))\n plt.legend(loc=0)\n plt.xlim(2,5)\n plt.ylim(0,2.5)\n save_figure(path.join(subdir,\"omega_gp\"))\n plt.clf()","def residmapComparison():\n srcmap001 = fits.open('dataFiles/6gev_srcmap_001.fits')\n srcmap03 = fits.open('dataFiles/6gev_srcmap_03.fits')\n\n image_data = fits.getdata('dataFiles/6gev_image.fits')\n filename = get_pkg_data_filename('dataFiles/6gev_image.fits')\n hdu = fits.open(filename)[0]\n wcs = WCS(hdu.header)\n\n #Given the results of the fit, calculate the model\n modelData001 = np.zeros(srcmap001[0].shape)\n modelData03 = np.zeros(srcmap03[0].shape)\n\n file = open('plotsData/fitResults001.pk1','rb')\n fit001 = pickle.load(file)\n file.close()\n\n file = open('plotsData/fitResults03.pk1','rb')\n fit03 = pickle.load(file)\n file.close()\n\n\n for source in fit001:\n the_index = srcmap001.index_of(source)\n\n modelData001 += fit001[source][:, None, None]*srcmap001[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap001[the_index].data, axis=2), axis=1)[:-1, None, None]\n for source in fit03:\n the_index = srcmap03.index_of(source)\n modelData03 += fit03[source][:, None, None]*srcmap03[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap03[the_index].data, axis=2), axis=1)[:-1, None, None]\n\n fig = plt.figure(figsize=[12, 4.5])\n\n vmin = -25.0\n vmax = 25.0\n cbStep = 5.0\n ax = fig.add_subplot(121, projection=wcs)\n ax=plt.gca()\n ax.tick_params(direction='in')\n c = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax.get_transform('galactic'))\n ax.add_patch(c)\n mappable=plt.imshow((image_data-np.sum(modelData001,axis=0)),cmap='seismic',origin='lower',vmin=vmin, vmax=vmax, interpolation='gaussian')#\n plt.xlabel('Galactic Longitude')\n plt.ylabel('Galactic Latitude')\n plt.title('GC Point Source ($>6$ GeV)')\n cb = plt.colorbar(mappable, label='Residual counts per pixel', pad=0.01,ticks=np.arange(vmin, vmax+cbStep, cbStep))\n cb.ax.tick_params(width=0)\n\n\n ax2=fig.add_subplot(122, projection=wcs)\n ax2 = plt.gca()\n c2 = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax2.get_transform('galactic'))\n ax2.add_patch(c2)\n mappable2 = plt.imshow((image_data-np.sum(modelData03,axis=0)), cmap='seismic',origin='lower',vmin=vmin, vmax=vmax, interpolation='gaussian')\n plt.xlabel('Galactic Longitude')\n plt.ylabel('Galactic Latitude')\n plt.title('GC Extended Source ($>6$ GeV)')\n cb2 = plt.colorbar(mappable2, label='Residual counts per pixel', pad=0.01, ticks=np.arange(vmin, vmax+cbStep, cbStep))\n cb2.ax.tick_params(width=0)\n fig.tight_layout()\n plt.subplots_adjust(wspace = 0.13, left=0.04, bottom=0.13, top=0.92)\n #plt.savefig('plots/residComparison.pdf',bbox_inches='tight')\n plt.show()","def generateStationPlot(dir_path, traj_list, color_scheme='light'):\n\n\n # Choose the color scheme\n cs = MapColorScheme()\n \n if color_scheme == 'light':\n cs.light()\n\n else:\n cs.dark()\n\n\n plt.figure(figsize=(19.2, 10.8))\n\n # Init the map\n m = Basemap(projection='cyl', resolution='i')\n\n # Draw the coast boundary and fill the oceans with the given color\n m.drawmapboundary(fill_color=cs.map_background)\n\n # Fill continents, set lake color same as ocean color\n m.fillcontinents(color=cs.continents, lake_color=cs.lakes, zorder=1)\n\n # Draw country borders\n m.drawcountries(color=cs.countries)\n m.drawstates(color=cs.states, linestyle='--')\n\n\n\n ### PLOT WORLD MAP ###\n\n # Group stations into countries\n country_dict = {}\n for traj in traj_list:\n\n for obs in traj.observations:\n\n # Extract country code\n country_code = obs.station_id[:2]\n\n if country_code not in country_dict:\n country_dict[country_code] = {}\n \n\n if obs.station_id not in country_dict[country_code]:\n country_dict[country_code][obs.station_id] = [obs.lat, obs.lon]\n\n\n\n # Plot stations in all countries\n for country_code in country_dict:\n\n station_dict = country_dict[country_code]\n\n # Extract lat/lon\n lat = np.degrees([station_dict[station_id][0] for station_id in station_dict])\n lon = np.degrees([station_dict[station_id][1] for station_id in station_dict])\n\n # Convert lat/lon to x/y\n x, y = m(lon, lat)\n\n plt.scatter(x, y, s=0.75, zorder=5, label=\"{:s}: {:d}\".format(country_code, len(lat)))\n\n\n plt.legend(loc='lower left')\n\n plt.tight_layout()\n\n plt.savefig(os.path.join(dir_path, \"world_map.png\"), dpi=100)\n\n plt.close()\n\n ### ###","def map_sim_property(**kwargs):\n\n GR = glo.global_results()\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n counter = 0\n fignum = 1\n if p.gal_index == 'all':\n\n for gal_index in GR.N_gal - np.arange(GR.N_gal) - 1:\n\n if counter == 0:\n fig, axes = plt.subplots(3, 3, figsize=(20,15))\n axs = [axes[0,0],axes[0,1],axes[0,2],axes[1,0],axes[1,1],axes[1,2],axes[2,0],axes[2,1],axes[2,2]]\n counter = 9\n\n gal_ob = gal.galaxy(GR=GR, gal_index=gal_index)\n simgas = aux.load_temp_file(gal_ob=gal_ob,data_type='simgas')\n map2D,lab,max_scale = make_projection_map(simgas,prop=p.prop)\n if p.prop == 'm': map2D = map2D * simgas.m.sum()/np.sum(map2D) \n\n # Plot\n Rmax = max_scale/2\n ax1 = axs[9 - counter]\n if p.log:\n map2D[map2D < 10.**p.vmin] = 10.**p.vmin/2\n map2D[map2D > 10.**p.vmax] = 10.**p.vmax\n map2D = np.log10(map2D)\n if not p.log:\n map2D[map2D < p.vmin] = p.vmin/2\n map2D[map2D > p.vmax] = p.vmax\n im = ax1.imshow(map2D,\\\n extent=[-Rmax,Rmax,-Rmax,Rmax],vmin=p.vmin,cmap=p.cmap)\n fig.colorbar(im,shrink=0.8,ax=ax1,label=lab)\n if not p.add: ax1.set_xlabel('x [kpc]'); ax1.set_ylabel('y [kpc]')\n # Limit axes limits a bit to avoid area with no particles...\n ax1.set_xlim([-0.99*Rmax,0.99*Rmax])\n ax1.set_ylim([-0.99*Rmax,0.99*Rmax])\n if (p.prop == 'm') & (p.text == True):\n ax1.text(0.05,0.85,'M$_{gas}$=%.2eM$_{\\odot}$' % np.sum(simgas.m),\\\n fontsize=14,transform=ax1.transAxes,color='white')\n ax1.text(0.05,0.75,'SFR=%.2eM$_{\\odot}$/yr' % GR.SFR[gal_index],\\\n fontsize=14,transform=ax1.transAxes,color='white')\n\n counter -= 1\n\n #if counter == 0:\n # ax1 = plt.subplots(1, 1)\n #cbar = fig.colorbar(im, ax=axes.ravel().tolist(), shrink=0.95, label=lab)\n # fig.colorbar(im,shrink=0.8,label=lab)\n\n if counter == 0 or gal_index == GR.N_gal-1:\n print('Saving in ' + p.d_plot + 'sim_data/map_%s_%s_gals_%i.%s' % (p.prop,p.z1,fignum,p.format))\n # plt.tight_layout()\n if not os.path.isdir(p.d_plot + 'sim_data/'): os.mkdir(p.d_plot + 'sim_data/')\n plt.savefig(p.d_plot + 'sim_data/map_%s_%s_gals_%i.%s' % (p.prop,p.z1,fignum,p.format), format=p.format, dpi=250, facecolor='w')\n fignum += 1\n\n else:\n if p.add:\n fig, ax1 = plt.gcf(), p.ax\n if not p.add:\n fig = plt.figure(figsize=(8,6))\n ax1 = fig.add_axes([0.1, 0.01, 0.8, 0.8]) \n ax1.axis('equal')\n\n gal_ob = gal.galaxy(GR=GR, gal_index=p.gal_index)\n simgas = aux.load_temp_file(gal_ob=gal_ob,data_type=p.sim_type)\n if p.R_max:\n # Cut out square\n simgas = simgas[(np.abs(simgas.x) < p.R_max) & (np.abs(simgas.y) < p.R_max)]\n # Add bottom left corner\n extra_row = simgas.iloc[0] # to ensure that map gets the right size\n extra_row['x'],extra_row['y'] = -p.R_max,-p.R_max\n extra_row[p.prop] = 0\n simgas = simgas.append(extra_row).reset_index(drop=True) \n # Add top right corner\n extra_row = simgas.iloc[0] # to ensure that map gets the right size\n extra_row['x'],extra_row['y'] = p.R_max,p.R_max\n extra_row[p.prop] = 0\n simgas = simgas.append(extra_row).reset_index(drop=True) \n else:\n pass\n map2D,lab,max_scale = make_projection_map(simgas,prop=p.prop)\n if p.prop == 'm': map2D = map2D * simgas.m.sum()/np.sum(map2D) \n print('Min and max of map: ',map2D.min(),map2D.max())\n #map2D[map2D < 1e4] = 1e6\n # Plot map\n if not p.R_max:\n p.R_max = max_scale/2\n if p.log: \n if not p.vmax: p.vmax = np.log10(map2D).max()\n if not p.vmin: p.vmin = np.log10(map2D).max() - 4\n map2D[map2D < 10.**p.vmin] = 10.**p.vmin/2\n map2D[map2D > 10.**p.vmax] = 10.**p.vmax\n map2D = np.log10(map2D)\n else:\n if not p.vmax: p.vmax = np.max(map2D)\n if not p.vmin: p.vmin = np.min(map2D) / 1e3\n map2D[map2D < p.vmin] = p.vmin #np.min(map2D[map2D > 0])\n map2D = np.flipud(map2D)\n\n im = ax1.imshow(map2D,\\\n extent=[-max_scale/2,max_scale/2,-max_scale/2,max_scale/2],vmin=p.vmin,vmax=p.vmax,cmap=p.cmap)\n # Limit axes limits a bit to avoid area with no particles...\n zoom = 1#/1.5\n ax1.set_xlim([-1/zoom * p.R_max,1/zoom * p.R_max])\n ax1.set_ylim([-1/zoom * p.R_max,1/zoom * p.R_max])\n if p.colorbar: \n divider = make_axes_locatable(ax1)\n cax1 = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n fig.colorbar(im,cax=cax1,label=lab)\n if not p.add: ax1.set_xlabel('x [kpc]'); ax1.set_ylabel('y [kpc]')\n if (p.prop == 'm') & (p.text == True):\n simstar = aux.load_temp_file(gal_ob=gal_ob,data_type='simstar')\n ax1.text(0.05,0.92,'M$_{star}$=%.1e M$_{\\odot}$' % np.sum(simstar.m),\\\n fontsize=14,transform=ax1.transAxes,color='white')\n ax1.text(0.05,0.86,'M$_{gas}$=%.1e M$_{\\odot}$' % np.sum(simgas.m),\\\n fontsize=14,transform=ax1.transAxes,color='white')\n ax1.text(0.05,0.80,'SFR=%.2f M$_{\\odot}$/yr' % GR.SFR[p.gal_index],\\\n fontsize=14,transform=ax1.transAxes,color='white')\n if p.savefig:\n if not os.path.isdir(p.d_plot + 'sim_data/'): os.mkdir(p.d_plot + 'sim_data/') \n plt.savefig(p.d_plot + 'sim_data/map_%s_G%i.png' % (p.prop,p.gal_index), format=p.format, dpi=250, facecolor='w')\n\n if not p.colorbar: return(im)","def compositePlots(self):\n if not self.master: return\n\n # get the HTML page\n page = [page for page in self.layout.pages if \"MeanState\" in page.name][0]\n \n models = []\n colors = []\n corr = {}\n std = {}\n cycle = {}\n has_cycle = False\n has_std = False\n for fname in glob.glob(os.path.join(self.output_path,\"*.nc\")):\n dataset = Dataset(fname)\n if \"MeanState\" not in dataset.groups: continue\n dset = dataset.groups[\"MeanState\"]\n models.append(dataset.getncattr(\"name\"))\n colors.append(dataset.getncattr(\"color\"))\n for region in self.regions:\n \n if not cycle.has_key(region): cycle[region] = []\n key = [v for v in dset.variables.keys() if (\"cycle_\" in v and region in v)]\n if len(key)>0:\n has_cycle = True\n cycle[region].append(Variable(filename=fname,groupname=\"MeanState\",variable_name=key[0]))\n\n if not std. has_key(region): std [region] = []\n if not corr. has_key(region): corr [region] = []\n\n key = []\n if \"scalars\" in dset.groups:\n key = [v for v in dset.groups[\"scalars\"].variables.keys() if (\"Spatial Distribution Score\" in v and region in v)]\n if len(key) > 0:\n has_std = True\n sds = dset.groups[\"scalars\"].variables[key[0]]\n corr[region].append(sds.getncattr(\"R\" ))\n std [region].append(sds.getncattr(\"std\"))\n\n # composite annual cycle plot\n if has_cycle and len(models) > 2:\n page.addFigure(\"Spatially integrated regional mean\",\n \"compcycle\",\n \"RNAME_compcycle.png\",\n side = \"ANNUAL CYCLE\",\n legend = False)\n\n for region in self.regions:\n if not cycle.has_key(region): continue\n fig,ax = plt.subplots(figsize=(6.8,2.8),tight_layout=True)\n for name,color,var in zip(models,colors,cycle[region]):\n dy = 0.05*(self.limits[\"cycle\"][region][\"max\"]-self.limits[\"cycle\"][region][\"min\"])\n var.plot(ax,lw=2,color=color,label=name,\n ticks = time_opts[\"cycle\"][\"ticks\"],\n ticklabels = time_opts[\"cycle\"][\"ticklabels\"],\n vmin = self.limits[\"cycle\"][region][\"min\"]-dy,\n vmax = self.limits[\"cycle\"][region][\"max\"]+dy)\n ylbl = time_opts[\"cycle\"][\"ylabel\"]\n if ylbl == \"unit\": ylbl = post.UnitStringToMatplotlib(var.unit)\n ax.set_ylabel(ylbl)\n fig.savefig(os.path.join(self.output_path,\"%s_compcycle.png\" % (region)))\n plt.close()\n\n # plot legends with model colors (sorted with Benchmark data on top)\n page.addFigure(\"Spatially integrated regional mean\",\n \"legend_compcycle\",\n \"legend_compcycle.png\",\n side = \"MODEL COLORS\",\n legend = False)\n def _alphabeticalBenchmarkFirst(key):\n key = key[0].upper()\n if key == \"BENCHMARK\": return 0\n return key\n tmp = sorted(zip(models,colors),key=_alphabeticalBenchmarkFirst)\n fig,ax = plt.subplots()\n for model,color in tmp:\n ax.plot(0,0,'o',mew=0,ms=8,color=color,label=model)\n handles,labels = ax.get_legend_handles_labels()\n plt.close()\n \n ncol = np.ceil(float(len(models))/11.).astype(int)\n if ncol > 0:\n fig,ax = plt.subplots(figsize=(3.*ncol,2.8),tight_layout=True)\n ax.legend(handles,labels,loc=\"upper right\",ncol=ncol,fontsize=10,numpoints=1)\n ax.axis('off')\n fig.savefig(os.path.join(self.output_path,\"legend_compcycle.png\"))\n fig.savefig(os.path.join(self.output_path,\"legend_spatial_variance.png\"))\n fig.savefig(os.path.join(self.output_path,\"legend_temporal_variance.png\"))\n plt.close()\n \n # spatial distribution Taylor plot\n if has_std:\n page.addFigure(\"Temporally integrated period mean\",\n \"spatial_variance\",\n \"RNAME_spatial_variance.png\",\n side = \"SPATIAL TAYLOR DIAGRAM\",\n legend = False)\n page.addFigure(\"Temporally integrated period mean\",\n \"legend_spatial_variance\",\n \"legend_spatial_variance.png\",\n side = \"MODEL COLORS\",\n legend = False) \n if \"Benchmark\" in models: colors.pop(models.index(\"Benchmark\"))\n for region in self.regions:\n if not (std.has_key(region) and corr.has_key(region)): continue\n if len(std[region]) != len(corr[region]): continue\n if len(std[region]) == 0: continue\n fig = plt.figure(figsize=(6.0,6.0))\n post.TaylorDiagram(np.asarray(std[region]),np.asarray(corr[region]),1.0,fig,colors)\n fig.savefig(os.path.join(self.output_path,\"%s_spatial_variance.png\" % region))\n plt.close()","def show_image_grid(imgs):\n grd = make_grid(imgs)\n npimg = grd.numpy()\n plt.imshow(np.transpose(npimg, (1,2,0)), interpolation='nearest')\n plt.ion()\n plt.show()","def plot_outputgrid(self, scalefactor=1, **kwargs):\n\n if not (type(scalefactor) == 'int'):\n scalefactor = round(scalefactor)\n\n xx = np.arange(self.xori, self.xend, scalefactor * self.dx)\n yy = np.arange(self.yori, self.yend, scalefactor * self.dy)\n plt.hlines(yy, self.xori, self.xend, linewidth=0.2, **kwargs)\n plt.vlines(xx, self.yori, self.yend, linewidth=0.2, **kwargs)\n\n logger.debug('Adding output grid to plot')","def plot(model, center, extent, outname):\n # define model grid\n xg = np.linspace(-extent, extent, model.shape[0])\n yg = xg.copy()\n interp_func = RectBivariateSpline(xg, yg, model)\n\n x = np.array([-2, -1, 0, 1, 2]) + center[0]\n y = np.array([-2, -1, 0, 1, 2]) + center[1]\n psf = interp_func(x, y)\n\n x, y = np.meshgrid(x, y)\n f = pl.figure(figsize=(10, 5))\n\n pl.gray()\n ax1 = pl.subplot(121)\n ax1.imshow(model, interpolation='nearest', origin='lower',\n extent=(-extent, extent, -extent, extent),\n norm=LogNorm(vmin=model.min(), vmax=model.max()))\n ax1.plot(x, y, 's', mec='r', mfc='none', mew=2)\n\n pl.xlim(-2.5, 2.5)\n pl.ylim(-2.5, 2.5)\n ax2 = pl.subplot(122)\n ax2.imshow(psf, interpolation='nearest', origin='lower',\n extent=(-extent, extent, -extent, extent),\n norm=LogNorm(vmin=model.min(), vmax=model.max()))\n\n ax2.set_xticks([-2, -1, 0, 1, 2])\n ax2.set_yticks([-2, -1, 0, 1, 2])\n ax2.set_xticklabels(['%0.3f' % v for v in x[0]])\n ax2.set_yticklabels(['%0.3f' % v for v in y[:, 0]])\n\n coordsA, coordsB = \"data\", \"data\"\n pixels = np.array([[0.0, 0.0], [2., 2.], [-1., -1.]])\n locs = np.array([[-0.5, 0.5], [-0.5, 0.5], [-0.5, -0.5]])\n rads = [0.15, 0.25, -0.25]\n for i, p in enumerate(pixels):\n xy1 = p + center\n xy2 = p + locs[i]\n con = ConnectionPatch(xyA=xy2, xyB=xy1, coordsA=coordsA,\n coordsB=coordsB, axesA=ax2, axesB=ax1,\n arrowstyle=\"<-, head_length=1.2, head_width=0.8\", \n shrinkB=5,\n connectionstyle='arc3, rad=%s' % rads[i],\n color='r', lw=2)\n ax2.add_artist(con)\n ax2.plot(p[0], p[1], 's', mfc='none', mec='r', mew=2, ms=50)\n\n #pl.xlim(-2.5, 2.5)\n #pl.ylim(-2.5, 2.5)\n f.savefig(outname)","def show_filters(self):\n weight_mat = self.sess.run(self.W_fc_out)\n\n # Loop channels\n plt.figure(figsize=(12,5), facecolor='w', edgecolor='w')\n with sns.axes_style(\"white\"):\n for cl in range(weight_mat.shape[1]):\n # Get filters of this output class\n w_list = ia.vec2image( lin_image=weight_mat[:,cl],\n n_channels=self.n_input_channels,\n image_size=(self.y_res,self.x_res) )\n\n # Show channels\n for ch,w in enumerate(w_list):\n colormax = np.abs(w).max()\n ax = plt.subplot2grid( (self.n_output_classes,\n self.n_input_channels), (cl,ch) )\n ax.imshow( w, interpolation='nearest',\n cmap=plt.get_cmap('seismic'),\n clim=(-1*colormax,colormax) )\n ax.set_title(\"Class {}, Channel {}\".format(cl,ch))\n plt.axis('tight')\n plt.axis('off')\n colormax = np.abs(w).max()\n\n if self.n_output_classes == 2:\n plt.figure(figsize=(12,5), facecolor='w', edgecolor='w')\n with sns.axes_style(\"white\"):\n # Get filters of this output class\n w_list0 = ia.vec2image( lin_image=weight_mat[:,0],\n n_channels=self.n_input_channels,\n image_size=(self.y_res,self.x_res) )\n w_list1 = ia.vec2image( lin_image=weight_mat[:,1],\n n_channels=self.n_input_channels,\n image_size=(self.y_res,self.x_res) )\n for ch in range(len(w_list)):\n w_both = w_list1[ch]-w_list0[ch]\n\n colormax = np.abs(w_both).max()\n ax = plt.subplot2grid( (1,\n self.n_input_channels), (0,ch) )\n ax.imshow( w_both, interpolation='nearest',\n cmap=plt.get_cmap('seismic'),\n clim=(-1*colormax,colormax) )\n ax.set_title(\"Class {}, Channel {}\".format(cl,ch))\n plt.axis('tight')\n plt.axis('off')\n plt.tight_layout()","def plot_map(data, pixlist, nside, runconf, title, unit):\n hpmap = np.repeat(np.nan, hp.pixelfunc.nside2npix(nside))\n hpmap[pixlist] = data\n plot_lon_cen, plot_lat_cen = runconf['ra'], runconf['dec']\n if plot_lon_cen > 180:\n plot_lon_cen -= 360\n plot_bounds = (1.0 + 1.1 * runconf['radius']) * np.array([-1.0, 1.0])\n \n hp.cartview(hpmap, rot=(plot_lon_cen, plot_lat_cen, 0), \n lonra=plot_bounds, latra=plot_bounds,\n notext=True, unit=unit, title=title, \n min=min(data), max=max(data), coord='C', flip='astro')\n\n dec0 = np.round(runconf['dec'])\n dec_spacing = runconf['radius']/2.0\n decs = dec0 + np.arange(-2*runconf['radius'], 2.1*runconf['radius'], dec_spacing)\n decs_min, decs_max = min(decs), max(decs)\n\n ra0 = np.round(runconf['ra'])\n cosdelt =np.cos(np.deg2rad(dec0)) \n ra_spacing = runconf['radius']/cosdelt / 2.0\n ras = ra0 + np.arange(-2.0*runconf['radius']/cosdelt, 2.1*runconf['radius']/cosdelt, ra_spacing)\n ras_min, ras_max = min(ras), max(ras)\n #num_ras = np.ceil(1.0 * runconf['radius'] / grid_spacing / np.cos(np.deg2rad(min(decs))) )\n\n line_dec = np.linspace(decs_min, decs_max, 100)\n line_ra = np.linspace(ras_min, ras_max, 100)\n for ra in ras:\n hp.projplot(np.repeat(ra, 100), line_dec, lonlat=True, ls='dashed', color='black')\n hp.projtext(ra, dec0, r\"{ra:0.1f}$^\\circ$\".format(ra=ra), lonlat=True, clip_on=True)\n for dec in decs:\n hp.projplot(line_ra, np.repeat(dec, 100), lonlat=True, ls='dashed', color='black')\n hp.projtext(ra0, dec, r\"{dec:0.1f}$^\\circ$\".format(dec=dec), lonlat=True, clip_on=True, rotation=90)\n return","def plot_steps(out_dict, units):\n from bokeh.models import BoxAnnotation\n from bokeh.plotting import figure, show, output_notebook\n import bokeh.models as bmd\n\n tooltips = [\n (\"Step (total)\", \"@index\"),\n (\"Step (stage)\", \"@step\"),\n (\"Energy\", \"@energy eV/atom\"),\n (\"Energy (dispersion)\", \"@dispersion_energy_au Ha\"),\n (\"SCF converged\", \"@scf_converged\"),\n (\"Cell A\", \"@cell_a_angs Angs\"),\n (\"Cell Vol\", \"@cell_vol_angs3 Angs^3\"),\n (\"MAX Step\", \"@max_step_au Bohr\"),\n (\"Pressure\", \"@pressure_bar bar\")\n ]\n hover = bmd.HoverTool(tooltips=tooltips)\n TOOLS = [\"pan\", \"wheel_zoom\", \"box_zoom\", \"reset\", \"save\", hover]\n\n natoms = out_dict['natoms']\n values = [ x/natoms*ha2u[units] for x in out_dict['step_info']['energy_au'] ]\n values = [ x-min(values) for x in values ]\n\n data = bmd.ColumnDataSource(data=dict( index=range(len(values)),\n step=out_dict['step_info']['step'],\n energy=values,\n dispersion_energy_au=out_dict['step_info']['dispersion_energy_au'],\n scf_converged=out_dict['step_info']['scf_converged'],\n cell_a_angs=out_dict['step_info']['cell_a_angs'],\n cell_vol_angs3=out_dict['step_info']['cell_vol_angs3'],\n max_step_au=out_dict['step_info']['max_step_au'],\n pressure_bar=out_dict['step_info']['pressure_bar'],\n ))\n\n p = figure(tools=TOOLS, title='Energy profile of the DFT minimization',\n height=350, width=550)\n\n p.xgrid.grid_line_color=None\n p.xaxis.axis_label = 'Steps'\n p.yaxis.axis_label = 'Energy ({}/atom)'.format(units)\n\n # Colored background\n colors = ['red','orange','green','yellow','cyan','pink','palegreen']\n start = 0\n for i,steps in enumerate(out_dict['stage_info']['nsteps']):\n end = start+steps\n p.add_layout(BoxAnnotation(left=start, right=end, fill_alpha=0.2, fill_color=colors[i]))\n start = end\n\n # Trace line and markers\n p.line('index', 'energy', source=data, line_color='blue')\n p.circle('index', 'energy', source=data, line_color='blue', size=3)\n return p","def plot_figure9_lower():\n column_titles = None\n\n height_ceiling = 500.\n height_ceiling_id = list(height_range_ceilings).index(height_ceiling)\n\n fixed_height_ref = 100.\n fixed_height_id = list(fixed_heights).index(fixed_height_ref)\n\n plot_item0 = {\n 'data': nc.variables[\"p_ceiling_perc5\"][height_ceiling_id, :, :]\n / nc.variables[\"p_fixed_perc5\"][fixed_height_id, :, :],\n 'contour_fill_levels': np.linspace(1, 6., 21),\n 'contour_line_levels': np.arange(2., 5., 1.),\n 'contour_line_label_fmt': '%.1f',\n 'colorbar_ticks': np.linspace(1, 6., 21)[::4],\n 'colorbar_tick_fmt': '{:.1f}',\n 'colorbar_label': 'Increase factor [-]',\n 'extend': 'max',\n }\n plot_item1 = {\n 'data': nc.variables[\"p_ceiling_perc32\"][height_ceiling_id, :, :]\n / nc.variables[\"p_fixed_perc32\"][fixed_height_id, :, :],\n 'contour_fill_levels': np.linspace(1, 3.5, 21),\n 'contour_line_levels': np.linspace(1, 3.5, 21)[::4],\n 'contour_line_label_fmt': '%.1f',\n 'colorbar_ticks': np.linspace(1, 3.5, 21)[::4],\n 'colorbar_tick_fmt': '{:.1f}',\n 'colorbar_label': 'Increase factor [-]',\n 'extend': 'max',\n }\n plot_item2 = {\n 'data': nc.variables[\"p_ceiling_perc50\"][height_ceiling_id, :, :]\n / nc.variables[\"p_fixed_perc50\"][fixed_height_id, :, :],\n 'contour_fill_levels': np.linspace(1, 3.5, 21),\n 'contour_line_levels': np.linspace(1, 3.5, 21)[::4],\n 'contour_line_label_fmt': '%.1f',\n 'colorbar_ticks': np.linspace(1, 3.5, 21)[::4],\n 'colorbar_tick_fmt': '{:.1f}',\n 'colorbar_label': 'Increase factor [-]',\n 'extend': 'max',\n }\n\n plot_items = [plot_item0, plot_item1, plot_item2]\n\n eval_contour_fill_levels(plot_items)\n plot_panel_1x3_seperate_colorbar(plot_items, column_titles)","def cartesian_map_array(self, fn, vmin=None, vmax=None, bands=8, title='',cblabel='', \n ecliptic=False, equatorial=False, nocolorbar=False, cmap=plt.get_cmap('coolwarm')):\n if vmin is None:vmin=fn.vmin\n if vmax is None: vmax=fn.vmax\n nrows, ncols = ((bands+1)//4, 4 ) if bands>=4 else (1, bands)\n \n fig, axx = plt.subplots(nrows, ncols, figsize=(3+3*ncols,1+3*nrows), sharex=True, sharey=True)\n plt.subplots_adjust(left=0.1, right=0.92, hspace=0.15, wspace=0.01, bottom=0.15)\n if ecliptic:\n lon, sinlat = self.ecliptic_coords()\n elif equatorial:\n lon, sinlat = self.equatorial_coords()\n else:\n lon = self.df.glon\n sinlat = self.singlat\n for iband,energy in enumerate(self.energy[:bands]):\n ax = axx.flatten()[iband] if bands>1 else axx\n scat=self.basic_skyplot(ax, lon, sinlat, fn(iband).clip(vmin,vmax),\n title='%d MeV'%energy,\n vmin=vmin,vmax=vmax, s=30, edgecolor='none', colorbar=False, labels=False, cmap=cmap)\n\n fig.text(0.5, 0.95, getattr(fn, 'title', title), ha='center', size=14)\n if nocolorbar: return fig\n #put colorbar at right \n cbax = fig.add_axes((0.92, 0.15, 0.02, 0.7) )\n cb=plt.colorbar(scat, cbax, orientation='vertical')\n cb.set_label(getattr(fn, 'cblabel', cblabel))\n fig.text(0.5, 0.025, 'longitude', ha='center', fontsize=14)\n fig.text(0.05, 0.5, 'sin(latitude)', rotation='vertical', va='center', fontsize=14)\n return fig","def plotMSSpectra3D(listOfFilesToPlot, listOfNames=None, listOfColors=None, gridLines=False, yMin=0.5, yMax=2.5, yScale = 1.0,\r\n legend=True, normalizeToN15=False, subtractRef=None, legendLoc=4, lw=1.5, xMin=0, xMax=2000, scaleP=False, scaleI=0, scaleVal=1.0,\r\n figsize=(10,10), tLeft=0, tRight=-1, fixedOffset=False, noTicks=False, xlabel='mass', zlabel='intensity', a14=1.0): \r\n if listOfNames==None:\r\n listOfNames = listOfFilesToPlot\r\n if listOfColors==None:\r\n listOfColors = [pylab.cm.jet(float(i)/float(len(listOfFilesToPlot))) for i in range(len(listOfFilesToPlot))]\r\n \r\n fig = pylab.figure(figsize=figsize)\r\n ax = fig.add_subplot(111, projection='3d')\r\n\r\n yTotal = len(listOfFilesToPlot)\r\n top = 0.0\r\n\r\n if not (subtractRef is None):\r\n [bhah, zsRef, blah] = qMS.readMSSpectraFile(listOfFilesToPlot[subtractRef])\r\n #zsRef = list(numpy.array(zsRef)-fixedOffset\r\n zNorm = max(zsRef[len(zsRef)/2:])\r\n zsRef = numpy.array(zsRef)/zNorm\r\n \r\n for i,f in enumerate(listOfFilesToPlot):\r\n [xs, zs, name] = qMS.readMSSpectraFile(f)\r\n if fixedOffset:\r\n off = zs[len(zs)/2]\r\n print off\r\n #zs = list(numpy.array(zs)-zs[len(zs)/2])\r\n zs = list(numpy.array(zs)-off)\r\n ys = [yTotal-i]*len(xs)\r\n ys = numpy.array(ys)*yScale\r\n if normalizeToN15:\r\n zNorm = max(zs[len(zs)/2:])\r\n zs = numpy.array(zs)/zNorm\r\n if not (subtractRef is None):\r\n zNorm = max(zs[len(zs)/2:])\r\n zs = numpy.array(zs)/zNorm\r\n zs[:len(zsRef)/2] = zs[:len(zs)/2]-zsRef[:len(zsRef)/2]\r\n zs = zs*zNorm\r\n #xs = xs[:len(xs)/2]\r\n #ys = ys[:len(ys)/2]\r\n #zs = zs[:len(zs)/2]\r\n zs[:len(zs)/2] = numpy.array(zs[:len(zs)/2])*a14\r\n if (scaleP is True) and (i==scaleI):\r\n zs = numpy.array(zs)*scaleVal\r\n ax.plot(numpy.array(xs[tLeft:tRight]),numpy.array(ys[tLeft:tRight]),numpy.array(zs[tLeft:tRight]), color=listOfColors[i], lw=lw, label=listOfNames[i])\r\n top = max([top, float(max(zs))])\r\n\r\n\r\n ax.w_xaxis.pane.set_visible(False)\r\n ax.w_yaxis.pane.set_visible(False)\r\n ax.w_zaxis.pane.set_visible(False)\r\n\r\n if gridLines: \r\n ax.w_xaxis.gridlines.set_linewidth(1)\r\n ax.w_yaxis.gridlines.set_linewidth(1)\r\n ax.w_zaxis.gridlines.set_linewidth(1)\r\n \r\n else:\r\n ax.w_xaxis.gridlines.set_visible(False)\r\n ax.w_yaxis.gridlines.set_visible(False)\r\n ax.w_zaxis.gridlines.set_visible(False)\r\n\r\n [i.set_linewidth(1) for i in ax.w_xaxis.get_ticklines()]\r\n [i.set_linewidth(1) for i in ax.w_yaxis.get_ticklines()]\r\n [i.set_linewidth(1) for i in ax.w_zaxis.get_ticklines()]\r\n\r\n ax.w_xaxis.line.set_linewidth(1)\r\n ax.w_yaxis.line.set_linewidth(1)\r\n ax.w_zaxis.line.set_linewidth(1)\r\n \r\n ax.set_zticks([round(i,1) for i in [0, top/3, 2*top/3, top]])\r\n ax.set_zlim3d([0, top])\r\n ax.set_ylim3d(yMin, yMax)\r\n ax.set_yticks(range(1,yTotal+1))\r\n pylab.yticks(range(1,yTotal+1), ['']*yTotal)\r\n ax.set_xlim3d([xMin, xMax])\r\n \r\n if noTicks:\r\n ax.set_zticks([])\r\n ax.set_xticks([])\r\n ax.set_yticks([])\r\n\r\n ax.set_xlabel(xlabel)\r\n ax.set_zlabel(zlabel)\r\n\r\n ax.view_init(15, -60)\r\n if legend:\r\n pylab.legend(loc=legendLoc)\r\n \r\n pylab.tight_layout()\r\n return ax","def plot_examples(cms):\r\n data = amp_axis\r\n\r\n fig, axs = plt.subplots(1, 2, figsize=(30, 8)) #create two plots\r\n for [ax, cmap] in zip(axs, cms):\r\n psm = ax.pcolormesh(time_axis, tof_axis, data, cmap=cmap, rasterized=True, vmin = 250) #specify axis and minimum amplitude value to show on the graph\r\n fig.colorbar(psm, ax=ax, label = 'Amplitude') #define the legend of the amplitude data\r\n \r\n ax.set_ylabel('Time of Flight [\\u03bcs]') #set label for y axis\r\n ax.set_xlabel('Time [min]') #set label for x axis\r\n \r\n ax.hlines(8.744, 0, stop_time, colors = 'white') #create two white lines for the safe operating range for ToF\r\n ax.hlines(9.555, 0, stop_time, colors = 'white') \r\n \r\n plt.show()","def dataModel():\n srcmap001 = fits.open('dataFiles/6gev_srcmap_001.fits')\n srcmap03 = fits.open('dataFiles/6gev_srcmap_03.fits')\n\n image_data = fits.getdata('6gev_image.fits')\n filename = get_pkg_data_filename('6gev_image.fits')\n hdu = fits.open(filename)[0]\n wcs = WCS(hdu.header)\n\n #Given the results of the fit, calculate the model\n modelData001 = np.zeros(srcmap001[0].shape)\n modelData03 = np.zeros(srcmap03[0].shape)\n\n file = open('plotsData/fitResults001.pk1','rb')\n fit001 = pickle.load(file)\n file.close()\n\n file = open('plotsData/fitResults03.pk1','rb')\n fit03 = pickle.load(file)\n file.close()\n\n\n for source in fit001:\n the_index = srcmap001.index_of(source)\n\n modelData001 += fit001[source][:, None, None]*srcmap001[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap001[the_index].data, axis=2), axis=1)[:-1, None, None]\n for source in fit03:\n the_index = srcmap03.index_of(source)\n modelData03 += fit03[source][:, None, None]*srcmap03[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap03[the_index].data, axis=2), axis=1)[:-1, None, None]\n\n fig = plt.figure(figsize=[12, 4.5])\n\n vmin = 0\n vmax = 70.0\n cbStep = 10.0\n ax = fig.add_subplot(121, projection=wcs)\n ax=plt.gca()\n ax.tick_params(direction='in')\n c = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax.get_transform('galactic'))\n ax.add_patch(c)\n mappable=plt.imshow((image_data),cmap='inferno',origin='lower',norm=colors.PowerNorm(gamma=0.6),vmin=vmin, vmax=vmax, interpolation='gaussian')#\n plt.xlabel('Galactic Longitude')\n plt.ylabel('Galactic Latitude')\n plt.title('Data ($>6$ GeV)')\n cb = plt.colorbar(mappable, label='Counts per pixel', pad=0.01,ticks=np.arange(vmin, vmax+cbStep, cbStep))\n cb.ax.tick_params(width=0)\n\n\n ax2=fig.add_subplot(122, projection=wcs)\n ax2 = plt.gca()\n\n sources = []\n sources.append({\n 'Name':'3FGL J1745.3-2903c',\n 'RA':266.3434922,\n 'DEC':-29.06274323,\n 'color':'xkcd:bright light blue'})\n\n sources.append({\n 'Name':'1FIG J1748.2-2816',\n 'RA':267.1000722,\n 'DEC':-28.27707114,\n 'color':'xkcd:fire engine red'\n })\n\n sources.append({\n 'Name':'1FIG J1746.4-2843',\n 'RA':266.5942898,\n 'DEC':-28.86244442,\n 'color':'xkcd:fluorescent green'\n })\n\n sources.append({\n 'Name':'Galactic Center',\n 'RA':266.417,\n 'DEC':-29.0079,\n 'color':'black'\n })\n\n #Add source names:\n for source in sources:\n l, b = ra_dec_to_l_b(source['RA'], source['DEC'])\n ax2.scatter(l, b, color=source['color'],marker='x',s=45.0, transform=ax2.get_transform('galactic'), label=source['Name'])\n\n c2 = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax2.get_transform('galactic'))\n ax2.add_patch(c2)\n mappable2 = plt.imshow((np.sum(modelData03,axis=0)), cmap='inferno',norm=colors.PowerNorm(gamma=0.6),origin='lower',vmin=vmin, vmax=vmax, interpolation='gaussian')\n plt.xlabel('Galactic Longitude')\n plt.ylabel('Galactic Latitude')\n plt.title('Model ($>6$ GeV)')\n cb2 = plt.colorbar(mappable2, label='Counts per pixel', pad=0.01, ticks=np.arange(vmin, vmax+cbStep, cbStep))\n cb2.ax.tick_params(width=0)\n leg = plt.legend(loc=1,frameon=True)\n leg.get_frame().set_alpha(0.5)\n leg.get_frame().set_edgecolor('white')\n text1 = leg.get_texts()\n for text in text1:\n text.set_color('black')\n\n fig.tight_layout()\n plt.subplots_adjust(wspace = 0.13, left=0.04, bottom=0.13, top=0.92)\n plt.show()\n #plt.savefig('plots/dataModelComparison.pdf',bbox_inches='tight')","def P_AI_Rocky(in_dict):\n # START\n fs = 16\n plt.rc('font', size=fs)\n fig = plt.figure(figsize=(14,12))\n ds = nc.Dataset(in_dict['fn'])\n\n # PLOT CODE\n aa = [-122.8, -122.54, 47.92, 48.22]\n import cmocean\n cmap = cmocean.cm.balance\n # cmap = 'RdYlBu_r'\n\n from warnings import filterwarnings\n filterwarnings('ignore') # skip some warning messages\n \n # plot Code\n \n # calculate divergence and vorticity\n uu = ds['u'][0, -1, :, :]\n vv = ds['v'][0, -1, :, :]\n u = zfun.fillit(uu)\n v = zfun.fillit(vv)\n u[np.isnan(u)] = 0\n v[np.isnan(v)] = 0\n \n G = zrfun.get_basic_info(in_dict['fn'], only_G=True)\n \n dive = ((np.diff(u, axis=1)/G['DX'][:, 1:-1])[1:-1, :]\n + (np.diff(v, axis = 0)/G['DY'][1:-1, :])[:, 1:-1])\n #dive[G['mask_rho'][1:-1,1:-1]==False] = np.nan\n \n vort = np.diff(v, axis=1)/G['DX'][1:,1:] - np.diff(u, axis=0)/G['DY'][1:,1:]\n #vort[G['mask_rho'][1:,1:]==False] = np.nan\n \n scl = 2e-3\n \n # panel 1\n ax = fig.add_subplot(121)\n # cs = plt.pcolormesh(G['lon_psi'], G['lat_psi'], dive/scl, cmap=cmap,\n # vmin=-1, vmax=1)\n cs = plt.pcolormesh(G['lon_rho'][1:-1,1:-1], G['lat_rho'][1:-1,1:-1], dive/scl, cmap=cmap,\n vmin=-1, vmax=1, shading='gouraud')\n tstr = (r'Surface Divergence (%0.1e $s^{-1}$)' % (scl))\n #pfun.add_bathy_contours(ax, ds, txt=True)\n pfun.add_coast(ax)\n ax.axis(aa)\n pfun.dar(ax)\n ax.set_xlabel('Longitude')\n ax.set_ylabel('Latitude')\n ax.set_title(tstr)\n pfun.add_info(ax, in_dict['fn'])\n ax.set_xticks([-122.8, -122.7, -122.6])\n ax.set_yticks([48, 48.1, 48.2])\n #\n # panel 2\n ax = fig.add_subplot(122)\n # cs = plt.pcolormesh(G['lon_rho'], G['lat_rho'], vort/scl, cmap=cmap,\n # vmin=-1, vmax=1)\n cs = plt.pcolormesh(G['lon_psi'], G['lat_psi'], vort/scl, cmap=cmap,\n vmin=-1, vmax=1, shading='gouraud')\n tstr = (r'Surface Vorticity (%0.1e $s^{-1}$)' % (scl))\n ax.set_xticks([-122.8, -122.7, -122.6])\n ax.set_yticks([])\n #fig.colorbar(cs)\n \n # Inset colorbar\n from mpl_toolkits.axes_grid1.inset_locator import inset_axes\n cbaxes = inset_axes(ax, width=\"4%\", height=\"40%\", loc='lower left')\n fig.colorbar(cs, cax=cbaxes, orientation='vertical')\n \n #pfun.add_bathy_contours(ax, ds)\n pfun.add_coast(ax)\n ax.axis(aa)\n pfun.dar(ax)\n ax.set_xlabel('Longitude')\n ax.set_title(tstr) \n \n #fig.tight_layout()\n # FINISH\n ds.close()\n if len(in_dict['fn_out']) > 0:\n plt.savefig(in_dict['fn_out'])\n plt.close()\n else:\n plt.show()\n plt.rcdefaults()","def plot_reconstruction_diagnostics(self, figsize=(20, 10)):\n figs = []\n fig_names = []\n\n # upsampled frequency\n fx_us = tools.get_fft_frqs(2 * self.nx, 0.5 * self.dx)\n fy_us = tools.get_fft_frqs(2 * self.ny, 0.5 * self.dx)\n\n # plot different stages of inversion\n extent = tools.get_extent(self.fy, self.fx)\n extent_upsampled = tools.get_extent(fy_us, fx_us)\n\n for ii in range(self.nangles):\n fig = plt.figure(figsize=figsize)\n grid = plt.GridSpec(3, 4)\n\n for jj in range(self.nphases):\n\n # ####################\n # separated components\n # ####################\n ax = plt.subplot(grid[jj, 0])\n\n to_plot = np.abs(self.separated_components_ft[ii, jj])\n to_plot[to_plot <= 0] = np.nan\n plt.imshow(to_plot, norm=LogNorm(), extent=extent)\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 0:\n plt.title('O(f)otf(f)')\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 1:\n plt.title('m*O(f-fo)otf(f)')\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 2:\n plt.title('m*O(f+fo)otf(f)')\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n # ####################\n # deconvolved component\n # ####################\n ax = plt.subplot(grid[jj, 1])\n\n plt.imshow(np.abs(self.components_deconvolved_ft[ii, jj]), norm=LogNorm(), extent=extent)\n\n if jj == 0:\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 1:\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 2:\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 0:\n plt.title('deconvolved component')\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n # ####################\n # shifted component\n # ####################\n ax = plt.subplot(grid[jj, 2])\n\n # avoid any zeros for LogNorm()\n cs_ft_toplot = np.abs(self.components_shifted_ft[ii, jj])\n cs_ft_toplot[cs_ft_toplot <= 0] = np.nan\n plt.imshow(cs_ft_toplot, norm=LogNorm(), extent=extent_upsampled)\n plt.scatter(0, 0, edgecolor='r', facecolor='none')\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 1:\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n elif jj == 2:\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n if jj == 0:\n plt.title('shifted component')\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n # ####################\n # normalized weights\n # ####################\n ax = plt.subplot(grid[jj, 3])\n\n to_plot = self.weights[ii, jj] / self.weight_norm\n to_plot[to_plot <= 0] = np.nan\n im2 = plt.imshow(to_plot, norm=LogNorm(), extent=extent_upsampled)\n im2.set_clim([1e-5, 1])\n fig.colorbar(im2)\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 1:\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n elif jj == 2:\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n if jj == 0:\n plt.title('normalized weight')\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n plt.suptitle('period=%0.3fnm at %0.3fdeg=%0.3frad, f=(%0.3f,%0.3f) 1/um\\n'\n 'mod=%0.3f, min mcnr=%0.3f, wiener param=%0.2f\\n'\n 'phases (deg) =%0.2f, %0.2f, %0.2f, phase diffs (deg) =%0.2f, %0.2f, %0.2f' %\n (self.periods[ii] * 1e3, self.angles[ii] * 180 / np.pi, self.angles[ii],\n self.frqs[ii, 0], self.frqs[ii, 1], self.mod_depths[ii, 1], np.min(self.mcnr[ii]), self.wiener_parameter,\n self.phases[ii, 0] * 180/np.pi, self.phases[ii, 1] * 180/np.pi, self.phases[ii, 2] * 180/np.pi,\n 0, np.mod(self.phases[ii, 1] - self.phases[ii, 0], 2*np.pi) * 180/np.pi,\n np.mod(self.phases[ii, 2] - self.phases[ii, 0], 2*np.pi) * 180/np.pi))\n\n figs.append(fig)\n fig_names.append('sim_combining_angle=%d' % (ii + 1))\n\n # #######################\n # net weight\n # #######################\n figh = plt.figure(figsize=figsize)\n grid = plt.GridSpec(1, 2)\n plt.suptitle('Net weight, Wiener param = %0.2f' % self.wiener_parameter)\n\n ax = plt.subplot(grid[0, 0])\n net_weight = np.sum(self.weights, axis=(0, 1)) / self.weight_norm\n im = ax.imshow(net_weight, extent=extent_upsampled, norm=PowerNorm(gamma=0.1))\n\n figh.colorbar(im, ticks=[1, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 1e-2, 1e-3, 1e-4, 1e-5])\n\n ax.set_title(\"non-linear scale\")\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n circ2 = matplotlib.patches.Circle((0, 0), radius=2*self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ3)\n\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ4)\n\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ5)\n\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ6)\n\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ7)\n\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ8)\n\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\n\n ax = plt.subplot(grid[0, 1])\n ax.set_title(\"linear scale\")\n im = ax.imshow(net_weight, extent=extent_upsampled)\n\n figh.colorbar(im)\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n circ2 = matplotlib.patches.Circle((0, 0), radius=2 * self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ3)\n\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ4)\n\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ5)\n\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ6)\n\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ7)\n\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ8)\n\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\n\n figs.append(figh)\n fig_names.append('net_weight')\n\n return figs, fig_names","def plot(self, n_confs):\n \n import pandas as pd\n import numpy as np\n import matplotlib as mpl\n mpl.use('Agg')\n import matplotlib.pyplot as plt\n import csv\n \n n_iter = len(self.plot_data)\n \n data = np.ndarray((n_iter, n_confs+1))\n data[:,0] = [i[0] for i in self.plot_data]\n data[:,1:] = [i[1].detach().cpu().numpy() for i in self.plot_data]\n\n df=pd.DataFrame(data)\n names = ['iter']\n for i in range(n_confs): names.append(f'c{i+1}')\n df.columns = names\n df.to_csv(f\"{self.plot_name}.tab\", sep=\"\\t\", quoting=csv.QUOTE_NONE) \n\n d = data[:,1:].reshape(-1)\n d = d[~np.isnan(d)]\n mine = d.min() - 0.01\n for i in range(n_confs): \n data[:,i+1] -= mine\n \n df=pd.DataFrame(data)\n names = ['iter']\n for i in range(n_confs): names.append(f'c{i+1}')\n df.columns = names\n \n colors = (0,0,0)\n area = 10\n \n # Plot\n fig = plt.figure(figsize=(15, 15))\n ax = fig.add_subplot(1,1,1)\n for i in range(n_confs):\n ax.plot('iter', f'c{i+1}', data=df)\n ax.set_yscale('log')\n\n plt.xlabel('iter')\n plt.ylabel('loss')\n plt.savefig(f'{self.plot_name}.png')","def ShowOneContourBKG(index,all_images,all_pointing,thex0,they0,all_titles,object_name,all_expo,dir_top_img,all_filt):\n \n figname='contourBKG_{}_{}.pdf'.format(all_filt[index],index)\n \n plt.figure(figsize=(15,6))\n spec_index_min=100 # cut the left border\n spec_index_max=1900 # cut the right border\n star_halfwidth=70\n \n YMIN=-100\n YMAX=100\n \n figfilename=os.path.join(dir_top_img,figname) \n \n #center is approximately the one on the original raw image (may be changed)\n #x0=int(all_pointing[index][0])\n x0=int(thex0[index])\n \n \n # Extract the image \n full_image=np.copy(all_images[index])\n \n # refine center in X,Y\n star_region_X=full_image[:,x0-star_halfwidth:x0+star_halfwidth]\n \n profile_X=np.sum(star_region_X,axis=0)\n profile_Y=np.sum(star_region_X,axis=1)\n\n NX=profile_X.shape[0]\n NY=profile_Y.shape[0]\n \n X_=np.arange(NX)\n Y_=np.arange(NY)\n \n avX,sigX=weighted_avg_and_std(X_,profile_X**4) # take squared on purpose (weigh must be >0)\n avY,sigY=weighted_avg_and_std(Y_,profile_Y**4)\n \n x0=int(avX+x0-star_halfwidth)\n \n \n # find the center in Y on the spectrum\n yprofile=np.sum(full_image[:,spec_index_min:spec_index_max],axis=1)\n y0=np.where(yprofile==yprofile.max())[0][0]\n\n # cut the image in vertical and normalise by exposition time\n reduc_image=full_image[y0+YMIN:y0+YMAX,x0:spec_index_max]/all_expo[index] \n reduc_image[:,0:100]=0 # erase central star\n \n X_Size_Pixels=np.arange(0,reduc_image.shape[1])\n Y_Size_Pixels=np.arange(0,reduc_image.shape[0])\n Transverse_Pixel_Size=Y_Size_Pixels-int(float(Y_Size_Pixels.shape[0])/2.)\n \n # calibration in wavelength\n #grating_name=all_filt[index].replace('dia ','')\n grating_name=get_disperser_filtname(all_filt[index])\n \n lambdas=Pixel_To_Lambdas(grating_name,X_Size_Pixels,all_pointing[index],True)\n \n #if grating_name=='Ron200':\n # holo = Hologram('Ron400',verbose=True)\n #else: \n # holo = Hologram(grating_name,verbose=True)\n #lambdas=holo.grating_pixel_to_lambda(X_Size_Pixels,all_pointing[index])\n #if grating_name=='Ron200':\n # lambdas=lambdas*2.\n \n\n X,Y=np.meshgrid(lambdas,Transverse_Pixel_Size) \n T=np.transpose(reduc_image)\n \n \n cs=plt.contourf(X, Y, reduc_image, 100, alpha=1., cmap='jet',origin='lower')\n #C = plt.contour(X, Y, reduc_image ,10, colors='white', linewidth=.01,origin='lower')\n \n cbar = plt.colorbar(cs) \n \n for line in LINES:\n if line == O2 or line == HALPHA or line == HBETA or line == HGAMMA:\n plt.plot([line['lambda'],line['lambda']],[YMIN,YMAX],'-',color='lime',lw=0.5)\n plt.text(line['lambda'],YMAX*0.8,line['label'],verticalalignment='bottom', horizontalalignment='center',color='lime', fontweight='bold',fontsize=16)\n \n \n \n plt.axis([X.min(), X.max(), Y.min(), Y.max()]); plt.grid(True)\n plt.title(all_titles[index])\n plt.grid(color='white', ls='solid')\n plt.text(200,-5.,all_filt[index],verticalalignment='bottom', horizontalalignment='center',color='yellow', fontweight='bold',fontsize=16)\n plt.xlabel('$\\lambda$ (nm)')\n plt.ylabel('pixels')\n plt.ylim(YMIN,YMAX)\n plt.xlim(0.,1200.)\n plt.savefig(figfilename)","def velocity_map(self, output='test'):\n self.figure = figure(figsize=(10,3))\n self.axes = self.figure.gca() \n xWindowLim = (self.analyst.windowSize[0], self.analyst.windowSize[1])\n yWindowLim = (self.analyst.windowSize[2], self.analyst.windowSize[3])\n \n # Generate contours for velocity magnitude \n xGrid = linspace(\\\n xWindowLim[0]*self.millimetersPerPixel, \n xWindowLim[1]*self.millimetersPerPixel, self.nbins)\n yGrid = linspace(\\\n yWindowLim[0]*self.millimetersPerPixel, \n yWindowLim[1]*self.millimetersPerPixel, self.nbins)\n magVelGrid = griddata(self.xs, self.ys, self.magVel, xGrid, yGrid) \n # csf = self.axes.contourf(xGrid, yGrid, magVelGrid, range(2,26,2), cmap=myColorMap)\n csf = self.axes.contourf(xGrid, yGrid, magVelGrid, cmap=myColorMap)\n cbar = self.figure.colorbar(csf) \n cbar.set_label(\"Velocity magnitude, px/s\")\n \n # Generate arrow plot\n # q = self.axes.quiver(self.xs, self.ys, self.us, self.vs,\n # angles = 'xy', scale_units='xy', scale=2, pivot = 'mid')\n # self.axes.quiverkey(q, 0.9, 1.0, 10, \"10 px/frame\", coordinates='axes') \n \n # Save figure \n self.axes.set_aspect('equal')\n self.axes.set_xlim(*xWindowLim)\n self.axes.set_ylim(*yWindowLim)\n self.figure.savefig(output + '_velocity_map.pdf')","def heatmap(filename, data):\n\n fig, ax = ppl.subplots(1)\n ppl.pcolormesh(fig, ax, data, vmin=-0.0016, vmax=0.0016)\n fig.savefig(filename + \".png\")","def plot_source_residuals_comparison(source_truth, source_model_list, name_list, \n vmin_res=-0.5, vmax_res=-0.5, cmap='cubehelix',\n fontsize=12):\n n_model = len(source_model_list)\n fig, axes = plt.subplots(1+n_model, 2, figsize=(9, (1+n_model)*3.5))\n axes[0, 1].axis('off')\n ax = axes[0, 0]\n #ax.get_xaxis().set_visible(False)\n #ax.get_yaxis().set_visible(False)\n ax.set_title(\"true source\", fontsize=fontsize)\n im = ax.imshow(source_truth, cmap=cmap, vmin=0)\n lims = (len(source_truth)/4, 3*len(source_truth)/4) # zoom a bit on the image\n #ax.set_xlim(*lims)\n #ax.set_ylim(*lims)\n plot_util.nice_colorbar(im, label=\"flux\", fontsize=fontsize)\n \n i = 1\n for source_model, name in zip(source_model_list, name_list):\n print(\"min/max for source model '{}': {}/{}\".format(name, source_model.min(), source_model.max()))\n\n residuals_source = source_model - source_truth\n\n ax = axes[i, 0]\n ax.set_title(\"model '{}'\".format(name), fontsize=fontsize)\n #ax.get_xaxis().set_visible(False)\n #ax.get_yaxis().set_visible(False)\n im = ax.imshow(source_model, cmap=cmap)\n #ax.set_xlim(*lims)\n #ax.set_ylim(*lims)\n plot_util.nice_colorbar(im, label=\"flux\", fontsize=fontsize)\n \n ax = axes[i, 1]\n #ax.get_xaxis().set_visible(False)\n #ax.get_yaxis().set_visible(False)\n ax.set_title(\"difference\", fontsize=fontsize)\n #ax.set_xlim(*lims)\n #ax.set_ylim(*lims)\n im = ax.imshow(residuals_source, cmap='RdBu_r', vmin=vmin_res, vmax=vmax_res)\n plot_util.nice_colorbar_residuals(im, residuals_source, vmin_res, vmax_res,\n label=r\"f${}_{\\rm model}$ - f${}_{\\rm truth}$\", fontsize=fontsize)\n \n print(\"SDR for model '{}' = {:.3f}\".format(name, metrics_util.SDR(source_truth, source_model)))\n i += 1\n\n return fig","def plot_images_grid(x: torch.tensor, export_img, title: str = '', nrow=6, padding=2, normalize=False, pad_value=0, save = True, apply_transforms = False):\n logger = logging.getLogger()\n global global_counter\n #if apply_transforms:\n # #global_counter = 0\n \n # transform = transforms.Compose([\n # #transforms.ToPILImage(),transforms.Lambda(lambda x: transforms.functional.adjust_brightness(x, brightness_factor = 1.1)),\n # #transforms.Lambda(lambda x: normalize_to_zero_one_range(x)),\n # transforms.Lambda(lambda x: tensor_to_img(x)),\n # transforms.Lambda(lambda x: save_img_patch(x, prefix = 'original')),\n # transforms.Lambda(lambda x: generate_NCUT_segmented_image(x)),\n # transforms.Lambda(lambda x: save_img_patch(x, prefix = 'NCUT')),\n # #transforms.Lambda(lambda x: draw_feature_contours(x)),\n # transforms.ToTensor() \n # ])\n \n # for i in range(x.shape[0]): \n # try:\n # x[i] = transform(x[i])\n # except:\n # logger.error(\"Exception occurred while appliying transform {}\".format( sys.exc_info()[0]))\n # logger.error(\"Was processing image number {} with global counter {}\".format(str(i), global_counter))\n\n grid = make_grid(x, nrow=nrow, padding=padding, normalize=normalize, pad_value=pad_value)\n npgrid = grid.detach().cpu().numpy()\n\n plt.imshow(np.transpose(npgrid, (1, 2, 0)), interpolation='nearest')\n\n ax = plt.gca()\n ax.xaxis.set_visible(False)\n ax.yaxis.set_visible(False)\n\n if not (title == ''):\n plt.title(title)\n if (save == True):\n plt.savefig(export_img, bbox_inches='tight', pad_inches=0.1)\n else:\n plt.show()\n plt.clf()","def plot_map(priors):\n sns.set_style(\"white\")\n\n cmap=sns.cubehelix_palette(8, start=.5, rot=-.75,as_cmap=True)\n hdulists=list(map(lambda prior:postmaps.make_fits_image(prior,prior.sim), priors))\n fig = plt.figure(figsize=(10*len(priors),10))\n figs=[]\n for i in range(0,len(priors)):\n figs.append(aplpy.FITSFigure(hdulists[i][1],figure=fig,subplot=(1,len(priors),i+1)))\n\n for i in range(0,len(priors)):\n vmin=np.min(priors[i].sim)\n vmax=np.max(priors[i].sim)\n figs[i].show_colorscale(vmin=vmin,vmax=vmax,cmap=cmap)\n figs[i].show_markers(priors[i].sra, priors[i].sdec, edgecolor='black', facecolor='black',\n marker='o', s=20, alpha=0.5)\n figs[i].tick_labels.set_xformat('dd.dd')\n figs[i].tick_labels.set_yformat('dd.dd')\n figs[i].add_colorbar()\n figs[i].colorbar.set_location('top')\n return figs,fig","def _plot_images(self):\n # Plot sagittal (0), coronal (1) or axial (2) view\n self._images = dict(base=list(), cursor_v=list(), cursor_h=list(),\n bounds=list())\n img_min = np.nanmin(self._base_data)\n img_max = np.nanmax(self._base_data)\n text_kwargs = dict(fontsize='medium', weight='bold', color='#66CCEE',\n family='monospace', ha='center', va='center',\n path_effects=[patheffects.withStroke(\n linewidth=4, foreground=\"k\", alpha=0.75)])\n xyz = apply_trans(self._ras_vox_t, self._ras)\n for axis in range(3):\n plot_x_idx, plot_y_idx = self._xy_idx[axis]\n fig = self._figs[axis]\n ax = fig.axes[0]\n img_data = np.take(self._base_data, self._current_slice[axis],\n axis=axis).T\n self._images['base'].append(ax.imshow(\n img_data, cmap='gray', aspect='auto', zorder=1,\n vmin=img_min, vmax=img_max))\n img_extent = self._img_extents[axis] # x0, x1, y0, y1\n w, h = np.diff(np.array(img_extent).reshape(2, 2), axis=1)[:, 0]\n self._images['bounds'].append(Rectangle(\n img_extent[::2], w, h, edgecolor='w', facecolor='none',\n alpha=0.25, lw=0.5, zorder=1.5))\n ax.add_patch(self._images['bounds'][-1])\n v_x = (xyz[plot_x_idx],) * 2\n v_y = img_extent[2:4]\n self._images['cursor_v'].append(ax.plot(\n v_x, v_y, color='lime', linewidth=0.5, alpha=0.5, zorder=8)[0])\n h_y = (xyz[plot_y_idx],) * 2\n h_x = img_extent[0:2]\n self._images['cursor_h'].append(ax.plot(\n h_x, h_y, color='lime', linewidth=0.5, alpha=0.5, zorder=8)[0])\n # label axes\n self._figs[axis].text(0.5, 0.05, _IMG_LABELS[axis][0],\n **text_kwargs)\n self._figs[axis].text(0.05, 0.5, _IMG_LABELS[axis][1],\n **text_kwargs)\n self._figs[axis].axes[0].axis(img_extent)\n self._figs[axis].canvas.mpl_connect(\n 'scroll_event', self._on_scroll)\n self._figs[axis].canvas.mpl_connect(\n 'button_release_event', partial(self._on_click, axis=axis))\n # add head and brain in mm (convert from m)\n if self._head is None:\n logger.info('Using marching cubes on CT for the '\n '3D visualization panel')\n rr, tris = _marching_cubes(np.where(\n self._base_data < np.quantile(self._base_data, 0.95), 0, 1),\n [1])[0]\n rr = apply_trans(self._vox_ras_t, rr)\n self._renderer.mesh(\n *rr.T, triangles=tris, color='gray', opacity=0.2,\n reset_camera=False, render=False)\n else:\n self._renderer.mesh(\n *self._head['rr'].T * 1000, triangles=self._head['tris'],\n color='gray', opacity=0.2, reset_camera=False, render=False)\n if self._lh is not None and self._rh is not None:\n self._renderer.mesh(\n *self._lh['rr'].T * 1000, triangles=self._lh['tris'],\n color='white', opacity=0.2, reset_camera=False, render=False)\n self._renderer.mesh(\n *self._rh['rr'].T * 1000, triangles=self._rh['tris'],\n color='white', opacity=0.2, reset_camera=False, render=False)\n self._renderer.set_camera(azimuth=90, elevation=90, distance=300,\n focalpoint=tuple(self._ras))\n # update plots\n self._draw()\n self._renderer._update()"],"string":"[\n \"def debugplots(fig,data):\\n grid = AxesGrid(fig, 111, # similar to subplot(142)\\n nrows_ncols=(1, 6),\\n axes_pad=0.0,\\n share_all=True,\\n label_mode=\\\"L\\\",\\n cbar_location=\\\"right\\\",\\n cbar_mode=\\\"none\\\",\\n )\\n\\n Z0=data[0].real\\n Z1=data[1].real\\n Z2=data[2].real\\n Z3=data[3].real\\n Z4=data[4].real\\n Z5=data[5].real\\n \\n Z=[Z0,Z1,Z2,Z3,Z4,Z5]\\n \\n for i in range(6):\\n grid[i].set_title(r\\\"$t=%u\\\\Delta t$\\\"%(Timestep(i)),color='black',horizontalalignment='center',verticalalignment='bottom')\\n im = grid[i].imshow(Z[i], extent=(-2, 2, -2, 2), interpolation=\\\"Nearest\\\",origin=\\\"lower\\\",cmap='seismic',vmin=-1,vmax=1)\\n grid[i].set_aspect(ratio)\\n grid[i].set_xlabel(\\\"$x/10$\\\",size=16)\\n grid[0].set_ylabel(\\\"$y/10$\\\",size=16)\\n pos2 = [0.905,0.25,0.01,0.5]\\n position = fig.add_axes(pos2)\\n fig.colorbar(im, ax=grid[2],cax=position,extend=\\\"both\\\")\\n \\n for cax in grid.cbar_axes:\\n cax.toggle_label(True)\\n \\n # This affects all axes as share_all = True.\\n grid.axes_llc.set_xticks([-2,-1, 0,1])\\n #grid[0].set_xticks([-20,-10, 0,10, 20])\\n grid.axes_llc.set_yticks([-2, -1, 0, 1,2])\",\n \"def show_colormaps():\\n maps = sorted(cmlist)\\n nmaps = len(maps) + 1\\n\\n a = np.linspace(0, 1, 256).reshape(1, -1) # pylint: disable=E1103\\n a = np.vstack((a, a))\\n\\n fig = plt.figure(figsize=(5, 10))\\n fig.subplots_adjust(top=0.99, bottom=0.01, left=0.2, right=0.99)\\n for i, name in enumerate(maps):\\n ax = plt.subplot(nmaps, 1, i + 1)\\n plt.axis(\\\"off\\\")\\n plt.imshow(a, aspect='auto', cmap=get_cmap(name), origin='lower')\\n pos = list(ax.get_position().bounds)\\n fig.text(pos[0] - 0.01, pos[1], name, fontsize=10,\\n horizontalalignment='right')\\n\\n plt.show()\",\n \"def plot_final_grid(generated_images):\\n\\n fig = plt.figure(figsize=(8, 6))\\n fig.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0.001, hspace=0.001)\\n\\n for ind in range(GRID_IMGS):\\n ax = fig.add_subplot(GRID_SIZE, GRID_SIZE, ind + 1, xticks=[], yticks=[])\\n ax.imshow(np.uint8(((generated_images[ind] + 1) / 2) * 255), cmap='gray')\\n\\n plt.savefig('/content/drive/My Drive/WGAN/generated_image_grid.png')\\n plt.savefig('/content/drive/My Drive/WGAN/results/DCGAN.png')\\n plt.show()\",\n \"def ListColorMaps(self):\\n p.rc('text', usetex=False)\\n a=p.outerproduct(numpy.arange(0,1,0.01),numpy.ones(10))\\n p.figure(figsize=(10,5))\\n p.subplots_adjust(top=0.8,bottom=0.05,left=0.01,right=0.99)\\n maps=[m for m in p.cm.datad.keys() if not m.endswith(\\\"_r\\\")]\\n maps.sort()\\n l=len(maps)+1\\n i=1\\n for m in maps:\\n p.subplot(1,l,i)\\n p.axis(\\\"off\\\")\\n p.imshow(a,aspect='auto',cmap=p.get_cmap(m),origin=\\\"lower\\\")\\n p.title(m,rotation=90,fontsize=10)\\n i=i+1\\n #savefig(\\\"colormaps.png\\\",dpi=100,facecolor='gray')\\n p.show()\",\n \"def visualize_M_gridworld(self, state=0):\\n\\n\\t\\tplt.subplot(221); plt.imshow(self.M[12,0,:].reshape(5,5)), plt.colorbar()\\n\\t\\tplt.subplot(222); plt.imshow(self.M[12,1,:].reshape(5,5)), plt.colorbar()\\n\\t\\tplt.subplot(223); plt.imshow(self.M[12,2,:].reshape(5,5)), plt.colorbar()\\n\\t\\tplt.subplot(224); plt.imshow(self.M[12,3,:].reshape(5,5)), plt.colorbar()\\n\\t\\tplt.show()\",\n \"def plot_final_grid(generated_images):\\n\\n fig = plt.figure(figsize=(GRID_SIZE, GRID_SIZE))\\n fig.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0.001, hspace=0.001)\\n\\n for ind in range(GRID_IMGS):\\n ax = fig.add_subplot(GRID_SIZE, GRID_SIZE, ind + 1, xticks=[], yticks=[])\\n ax.imshow(np.uint8(((generated_images[ind] + 1) / 2) * 255), cmap='gray')\\n\\n plt.savefig('/content/drive/My Drive/WGAN/generated_image_grid.png')\\n plt.savefig('/content/drive/My Drive/WGAN/results/WGAN.png')\\n plt.show()\",\n \"def debugmyplots(fig,data):\\n grid = AxesGrid(fig, 111, # similar to subplot(142)\\n nrows_ncols=(1, 6),\\n axes_pad=0.0,\\n share_all=True,\\n label_mode=\\\"L\\\",\\n cbar_location=\\\"right\\\",\\n cbar_mode=\\\"none\\\",\\n )\\n\\n \\n for i in range(6):\\n Z = np.real(data[i])\\n grid[i].set_title(r\\\"$t={:03.1f}$\\\".format(Timestep(i)),color='black',horizontalalignment='center',verticalalignment='bottom')\\n im = grid[i].imshow(Z, extent=(-2, 2, -2, 2), interpolation=\\\"Gaussian\\\",origin=\\\"lower\\\",cmap='seismic',vmin=-1,vmax=1)\\n grid[i].set_aspect(ratio)\\n grid[i].set_xlabel(\\\"$x/10$\\\",size=16)\\n #plt.colorbar(im, cax = grid.cbar_axes[0])\\n #ticks = np.logspace(1e-6,1,7)\\n #lf = LogFormatter(10, labelOnlyBase=False)\\n grid[0].set_ylabel(\\\"$y/10$\\\",size=16)\\n pos2 = [0.905,0.25,0.01,0.5]\\n position = fig.add_axes(pos2)\\n ticks=np.logspace(1e-6,1e-1,6)\\n fig.colorbar(im, ax=grid[5],cax=position,extend=\\\"both\\\")\\n \\n for cax in grid.cbar_axes:\\n cax.toggle_label(True)\\n \\n # This affects all axes as share_all = True.\\n grid.axes_llc.set_xticks([-2,-1, 0,1])\\n #grid[0].set_xticks([-20,-10, 0,10, 20])\\n grid.axes_llc.set_yticks([-2, -1, 0, 1,2])\",\n \"def plot_figure11():\\n height_ceilings = [200., 300., 400.]\\n height_ceiling_ids = [list(height_range_ceilings).index(height_ceiling) for height_ceiling in height_ceilings]\\n\\n baseline_height_ceiling = 500.\\n baseline_height_ceiling_id = list(height_range_ceilings).index(baseline_height_ceiling)\\n\\n plot_item00 = {\\n 'data': 100.-nc.variables[\\\"p_ceiling_rank40\\\"][height_ceiling_ids[0], :, :],\\n 'contour_fill_levels': np.linspace(50, 100, 21),\\n 'contour_line_levels': [70., 80., 90., 95.],\\n 'contour_line_label_fmt': '%.0f',\\n 'colorbar_ticks': np.linspace(50, 100, 21)[::4],\\n 'colorbar_tick_fmt': '{:.0f}',\\n 'colorbar_label': 'Availability [%]',\\n 'extend': 'min',\\n }\\n plot_item01 = {\\n 'data': 100.-nc.variables[\\\"p_ceiling_rank40\\\"][height_ceiling_ids[1], :, :],\\n 'contour_fill_levels': np.linspace(70, 100, 21),\\n 'contour_line_levels': [70., 80., 90., 95.],\\n 'contour_line_label_fmt': '%.0f',\\n 'colorbar_ticks': np.linspace(70, 100, 21)[::4],\\n 'colorbar_tick_fmt': '{:.0f}',\\n 'colorbar_label': 'Availability [%]',\\n 'extend': 'min',\\n }\\n plot_item02 = {\\n 'data': 100.-nc.variables[\\\"p_ceiling_rank40\\\"][height_ceiling_ids[2], :, :],\\n 'contour_fill_levels': np.linspace(80, 100, 21),\\n 'contour_line_levels': [70., 80., 90., 95.],\\n 'contour_line_label_fmt': '%.0f',\\n 'colorbar_ticks': np.linspace(80, 100, 21)[::4],\\n 'colorbar_tick_fmt': '{:.0f}',\\n 'colorbar_label': 'Availability [%]',\\n 'extend': 'min',\\n }\\n\\n column_titles = [\\\"200 m\\\", \\\"300 m\\\", \\\"400 m\\\"]\\n plot_items = [plot_item00, plot_item01, plot_item02]\\n\\n eval_contour_fill_levels(plot_items)\\n plot_panel_1x3_seperate_colorbar(plot_items, column_titles)\\n\\n linspace10 = np.linspace(0., 11., 21)\\n plot_item10 = {\\n 'data': -(100.-nc.variables[\\\"p_ceiling_rank40\\\"][height_ceiling_ids[0], :, :])+\\n (100.-nc.variables[\\\"p_ceiling_rank40\\\"][baseline_height_ceiling_id, :, :]),\\n 'contour_fill_levels': linspace10,\\n 'contour_line_levels': sorted([1.1]+list(linspace10[::4])),\\n 'contour_line_label_fmt': '%.1f',\\n 'colorbar_ticks': linspace10[::4],\\n 'colorbar_tick_fmt': '{:.0f}',\\n 'colorbar_label': 'Availability decrease [%]',\\n }\\n linspace11 = np.linspace(0., 23., 21)\\n plot_item11 = {\\n 'data': (100.-nc.variables[\\\"p_ceiling_rank40\\\"][height_ceiling_ids[1], :, :])-\\n (100.-nc.variables[\\\"p_ceiling_rank40\\\"][baseline_height_ceiling_id, :, :]),\\n 'contour_fill_levels': linspace11,\\n 'contour_line_levels': sorted([2.3]+list(linspace11[::4])),\\n 'contour_line_label_fmt': '%.1f',\\n 'colorbar_ticks': linspace11[::4],\\n 'colorbar_tick_fmt': '{:.0f}',\\n 'colorbar_label': 'Availability increase [%]',\\n }\\n linspace12 = np.linspace(0., 38., 21)\\n plot_item12 = {\\n 'data': (100.-nc.variables[\\\"p_ceiling_rank40\\\"][height_ceiling_ids[2], :, :])-\\n (100.-nc.variables[\\\"p_ceiling_rank40\\\"][baseline_height_ceiling_id, :, :]),\\n 'contour_fill_levels': linspace12,\\n 'contour_line_levels': sorted([3.8]+list(linspace12[::4])),\\n 'contour_line_label_fmt': '%.1f',\\n 'colorbar_ticks': linspace12[::4],\\n 'colorbar_tick_fmt': '{:.0f}',\\n 'colorbar_label': 'Availability increase [%]',\\n }\\n\\n column_titles = None\\n plot_items = [plot_item10, plot_item11, plot_item12]\\n\\n eval_contour_fill_levels(plot_items)\\n plot_panel_1x3_seperate_colorbar(plot_items, column_titles)\",\n \"def plotmap(self):\\n if self.plotfigure is None: return\\n\\n self.plotfigure.clf()\\n collist = [\\\"#%.2x%.2x%.2x\\\" % (i, i, i) for i in self.currentshades]\\n cmap = colors.ListedColormap(collist)\\n if self.gs.isfixed:\\n crange = [self.minvalue] + self.currentvalues\\n elif self.gs.isperc:\\n crange = np.percentile(self.imagearray, [0.0] + self.currentpercents)\\n else:\\n crange = np.array([self.minstdd] + self.currentnsigs) * self.stdvalue + self.meanvalue\\n norm = colors.BoundaryNorm(crange, cmap.N)\\n img = plt.imshow(self.imagearray, cmap=cmap, norm=norm, origin='lower')\\n plt.colorbar(img, norm=norm, cmap=cmap, boundaries=crange, ticks=crange)\\n if self.imagetitle is not None:\\n plt.title(self.imagetitle)\",\n \"def show_channels(chmaps, n_cols=8, normalize=None, ofpath=None):\\n n_rows = (chmaps.shape[0] - 1) // n_cols + 1\\n\\n if n_rows == 1:\\n n_cols = chmaps.shape[0]\\n\\n if normalize is None:\\n vmin, vmax = None, None\\n else:\\n vmin, vmax = normalize\\n\\n fig = plt.figure()\\n\\n grid = AxesGrid(fig, 111,\\n nrows_ncols=(n_rows, n_cols),\\n axes_pad=0.0,\\n share_all=True)\\n\\n for i, chmap in enumerate(chmaps):\\n grid[i].imshow(chmap, vmin=vmin, vmax=vmax)\\n\\n grid.axes_llc.get_xaxis().set_ticks([])\\n grid.axes_llc.get_yaxis().set_ticks([])\\n\\n if ofpath is None:\\n plt.get_current_fig_manager().window.showMaximized()\\n plt.show()\\n else:\\n fig.savefig(ofpath)\\n plt.close(fig)\",\n \"def plot_locations_np(self, c_img, locations, file_name_prefix=''):\\n other_axes = [[1, 2], [2, 0], [1, 0]]\\n shape_str = str(c_img.shape)\\n create_folder(self._output_folder)\\n for id_loc, c_loc in enumerate(locations):\\n plt.subplots(1, 3, squeeze=True, figsize=(8 * 3, 8))\\n for id_plane, plane in enumerate([PlaneTypes.AXIAL, PlaneTypes.SAGITTAL, PlaneTypes.CORONAL]):\\n c_loc = np.array(c_loc)\\n c_dim = get_axis_idx(plane)\\n c_slice = c_loc[c_dim]\\n\\n if c_slice < c_img.shape[c_dim]:\\n pt = c_loc[other_axes[c_dim]]\\n ax = plt.subplot(1, 3, id_plane + 1)\\n ax.imshow(get_proper_plane(c_img, plane, c_slice), cmap='gray')\\n ax.scatter(pt[0],pt[1], color=self._COLORS[id_loc])\\n c_title = F'{c_slice} {pt} -- {plane.value} -- {shape_str} '\\n plt.title(c_title, fontsize=20)\\n else:\\n raise Exception(\\n F'The slice {c_slice} is larger than the shape of the array {c_img.shape[c_dim]}')\\n\\n pylab.savefig(join(self._output_folder, F'{file_name_prefix}_Loc_{id_loc}.jpg'), bbox_inches='tight')\\n self._close_figure()\",\n \"def testing():\\n\\n from matplotlib import pyplot as plt\\n\\n dem_fn = \\\"../../tests/testdata/ca_dem_30s/ca_dem_30s/\\\"\\n dir_fn = \\\"../../tests/testdata/ca_dir_30s/ca_dir_30s/\\\"\\n\\n fv = -32768\\n\\n grid = Grid.from_raster(dir_fn, \\\"dir\\\", nodata=fv)\\n grid.read_raster(dem_fn, \\\"dem\\\", nodata=fv)\\n\\n lon, lat = -99.0619, 20.933\\n\\n fig, (ax1, ax2) = plt.subplots(1, 2)\\n\\n idem = ax1.imshow(\\n grid.view(\\\"dem\\\"), extent=grid.extent, cmap=\\\"cubehelix\\\", zorder=1, vmin=0\\n )\\n plt.colorbar(idem, ax=ax1, label=\\\"Elevation (m)\\\")\\n\\n idir = ax2.imshow(\\n grid.view(\\\"dir\\\"), extent=grid.extent, cmap=\\\"viridis\\\", zorder=2, vmin=0\\n )\\n boundaries = [0] + sorted(list(dirmap))\\n plt.colorbar(idir, ax=ax2, boundaries=boundaries, values=sorted(dirmap))\\n\\n grid.catchment(\\n data=\\\"dir\\\",\\n x=lon,\\n y=lat,\\n dirmap=dirmap,\\n out_name=\\\"catch\\\",\\n xytype=\\\"label\\\",\\n nodata_in=nodata,\\n )\\n catch = grid.polygonize(grid.catch.astype(\\\"int32\\\"), connectivity=8)\\n grid.clip_to(\\\"catch\\\")\\n\\n for (p, v) in catch:\\n poly = geometry.asShape(p)\\n ax1.plot(*poly.exterior.xy, color=\\\"white\\\")\\n plt.show()\",\n \"def gridPlot12(img_stack):\\r\\n F = plt.figure(figsize = (30,30))\\r\\n F.subplots_adjust(left = 0.05, right = 0.95)\\r\\n grid = ImageGrid(F, 142, nrows_ncols = (3,4), axes_pad = 0.0, share_all = True,\\r\\n label_mode = \\\"L\\\", cbar_location = \\\"top\\\", cbar_mode = \\\"single\\\")\\r\\n \\r\\n i = 0\\r\\n for img in img_stack[0:12]:\\r\\n im = grid[i].imshow(img, interpolation = \\\"nearest\\\", vmin = 0, vmax = 255)\\r\\n i += 1 \\r\\n grid.cbar_axes[0].colorbar(im)\\r\\n plt.savefig('gplot12.png')\\r\\n# for cax in grid.cbar_axes:\\r\\n# cax.toggle_label(False)\\r\\n return\",\n \"def myplots(fig,data):\\n grid = AxesGrid(fig, 111, # similar to subplot(142)\\n nrows_ncols=(1, 6),\\n axes_pad=0.0,\\n share_all=True,\\n label_mode=\\\"L\\\",\\n cbar_location=\\\"right\\\",\\n cbar_mode=\\\"none\\\",\\n )\\n\\n \\n for i in range(6):\\n Z = absolute(data[i])**2\\n grid[i].set_title(r\\\"$t={:03.1f}$\\\".format(Timestep(i)),color='black',horizontalalignment='center',verticalalignment='bottom')\\n im = grid[i].imshow(Z, extent=(-2, 2, -2, 2), interpolation=\\\"gaussian\\\",origin=\\\"lower\\\",cmap=cmap,norm=LogNorm(vmin=1e-5,vmax=1))\\n grid[i].set_aspect(ratio)\\n grid[i].set_xlabel(\\\"$x/10$\\\",size=16)\\n #plt.colorbar(im, cax = grid.cbar_axes[0])\\n #ticks = np.logspace(1e-6,1,7)\\n #lf = LogFormatter(10, labelOnlyBase=False)\\n grid[0].set_ylabel(\\\"$y/10$\\\",size=16)\\n pos2 = [0.905,0.25,0.01,0.5]\\n position = fig.add_axes(pos2)\\n ticks=np.logspace(1e-6,1e-1,6)\\n fig.colorbar(im, ax=grid[5],cax=position,extend=\\\"both\\\")\\n \\n for cax in grid.cbar_axes:\\n cax.toggle_label(True)\\n \\n # This affects all axes as share_all = True.\\n grid.axes_llc.set_xticks([-2,-1, 0,1])\\n #grid[0].set_xticks([-20,-10, 0,10, 20])\\n grid.axes_llc.set_yticks([-2, -1, 0, 1,2])\",\n \"def map_plot(self, iter_no):\\n \\n m = self._m\\n n = self._n\\n plt.figure()\\n label=np.zeros(m*n)\\n self._trained = True\\n mapped = self.map_vects(datanorm)\\n mapped=tuple(map(tuple, mapped))\\n c=Counter(mapped)\\n \\n c= sorted(c.items(), key=itemgetter(1))\\n a=[m*n]\\n for i in range(0,len(c)):\\n x=(((c[i])[0])[0])\\n y=(((c[i])[0])[1])\\n z=((c[i])[1])\\n plt.plot(x, y, 'ro', markersize= z/(2*m*n)) \\n plt.savefig('exoplanet{}.png'.format(iter_no))\\n p=plt.imread('exoplanet{}.png'.format(iter_no))\\n imgs.append(p)\\n plt.show()\\n plt.close()\\n print(c)\\n self._trained = False\",\n \"def data_model_residual(surface, dem, unw, incidence):\\n los,fem_los,residual = pu.los2pylith(surface,dem,unw,incidence)\\n\\n # Using image_grid\\n fig = plt.figure()\\n grid = ImageGrid(fig, 111, # similar to subplot(111)\\n nrows_ncols = (1, 3),\\n direction=\\\"row\\\",\\n axes_pad = 0.05,\\n add_all=True,\\n label_mode = \\\"1\\\",\\n share_all = True,\\n cbar_location=\\\"top\\\",\\n cbar_mode=\\\"each\\\", #\\\"single\\\"\\n cbar_size=\\\"5%\\\",\\n cbar_pad=0.05,\\n )\\n #grid[0].set_xlabel(\\\"X\\\")\\n #grid[0].set_ylabel(\\\"Y\\\")\\n #grid2[0].set_xticks([-2, 0])\\n #grid2[0].set_yticks([-2, 0, 2])\\n\\n #NOTE: could find global min/max from three arrays here\\n norm = Normalize(vmin=np.nanmin(los), vmax=np.nanmax(los))\\n #for ax,data in zip(grid,[los,fem_los,residual]):\\n im = grid[0].imshow(los,origin='upper',norm=norm,cmap=plt.cm.jet)\\n grid[0].axhline(100,color='m') #show profile\\n cax = grid.cbar_axes[0]\\n cax.colorbar(im)\\n grid[1].axhline(100,color='k') #show profile\\n im1 = grid[1].imshow(fem_los,origin='upper',norm=norm,cmap=plt.cm.jet)\\n\\n cax = grid.cbar_axes[1]\\n cax.colorbar(im1)\\n\\n im2 = grid[2].imshow(residual,origin='upper',cmap=plt.cm.jet)\\n cax = grid.cbar_axes[2]\\n cax.colorbar(im2)\\n\\n # Add letter labels\\n for ax, label in zip(grid,['A', 'B', 'C']):\\n ax.text(0.05, 0.95, label, transform=ax.transAxes,\\n fontsize=16, fontweight='bold', va='top')\\n\\n # Annotate\\n # NOTE: way too high!\\n #plt.suptitle('FEM Results')\\n\\n # Add profile\\n # NOTE: for now EW, but would be easy to do arbitrary line, and convert to km\\n fig = plt.figure()\\n #x = arange(los.shape[0])\\n plt.axhline(color='k',ls='--')\\n plt.plot(los[100],'m.',label='data')\\n plt.plot(fem_los[100],'k-',lw=2,label='model')\\n plt.xlabel('Distance [km]')\\n plt.ylabel('Distance [km]')\\n plt.legend(loc='upper left')\\n\\n plt.show()\",\n \"def plot_figure10():\\n height_ceiling = 500.\\n height_ceiling_id = list(height_range_ceilings).index(height_ceiling)\\n\\n plot_item00 = {\\n 'data': 100.-nc.variables[\\\"p_ceiling_rank40\\\"][height_ceiling_id, :, :],\\n 'contour_fill_levels': np.linspace(50, 100, 21),\\n 'contour_line_levels': [70., 80., 90., 95.],\\n 'contour_line_label_fmt': '%.0f',\\n 'colorbar_ticks': np.linspace(50, 100, 21)[::4],\\n 'colorbar_tick_fmt': '{:.0f}',\\n 'colorbar_label': 'Availability [%]',\\n 'extend': 'min',\\n }\\n plot_item01 = {\\n 'data': 100.-nc.variables[\\\"p_ceiling_rank300\\\"][height_ceiling_id, :, :],\\n 'contour_fill_levels': np.linspace(0, 80, 21),\\n 'contour_line_levels': np.linspace(0, 80, 21)[::4][2:],\\n 'contour_line_label_fmt': '%.0f',\\n 'colorbar_ticks': np.linspace(0, 80, 21)[::4],\\n 'colorbar_tick_fmt': '{:.0f}',\\n 'colorbar_label': 'Availability [%]',\\n }\\n plot_item02 = {\\n 'data': 100.-nc.variables[\\\"p_ceiling_rank1600\\\"][height_ceiling_id, :, :],\\n 'contour_fill_levels': np.linspace(0, 45, 21),\\n 'contour_line_levels': np.linspace(0, 45, 21)[::4][2:],\\n 'contour_line_label_fmt': '%.0f',\\n 'colorbar_ticks': np.linspace(0, 45, 21)[::4],\\n 'colorbar_tick_fmt': '{:.0f}',\\n 'colorbar_label': 'Availability [%]',\\n }\\n\\n column_titles = [\\\"40 $W/m^2$\\\", \\\"300 $W/m^2$\\\", \\\"1600 $W/m^2$\\\"]\\n plot_items = [plot_item00, plot_item01, plot_item02]\\n\\n eval_contour_fill_levels(plot_items)\\n plot_panel_1x3_seperate_colorbar(plot_items, column_titles)\\n\\n plot_item10 = {\\n 'data': (100.-nc.variables[\\\"p_ceiling_rank40\\\"][height_ceiling_id, :, :])-\\n (100.-nc.variables[\\\"p_fixed_rank40\\\"][0, :, :]),\\n 'contour_fill_levels': np.linspace(0., 22., 21),\\n 'contour_line_levels': sorted([1.1, 2.2]+list(np.linspace(0., 22., 21)[::4][:-2])),\\n 'contour_line_label_fmt': '%.1f',\\n 'colorbar_ticks': np.linspace(0., 22., 21)[::4],\\n 'colorbar_tick_fmt': '{:.0f}',\\n 'colorbar_label': 'Availability increase [%]',\\n }\\n plot_item11 = {\\n 'data': (100.-nc.variables[\\\"p_ceiling_rank300\\\"][height_ceiling_id, :, :])-\\n (100.-nc.variables[\\\"p_fixed_rank300\\\"][0, :, :]),\\n 'contour_fill_levels': np.linspace(0., 31., 21),\\n 'contour_line_levels': np.linspace(0., 31., 21)[::4][:-2],\\n 'contour_line_label_fmt': '%.1f',\\n 'colorbar_ticks': np.linspace(0., 31., 21)[::4],\\n 'colorbar_tick_fmt': '{:.0f}',\\n 'colorbar_label': 'Availability increase [%]',\\n }\\n plot_item12 = {\\n 'data': (100.-nc.variables[\\\"p_ceiling_rank1600\\\"][height_ceiling_id, :, :])-\\n (100.-nc.variables[\\\"p_fixed_rank1600\\\"][0, :, :]),\\n 'contour_fill_levels': np.linspace(0., 26., 21),\\n 'contour_line_levels': np.linspace(0., 26., 21)[::4][:-2],\\n 'contour_line_label_fmt': '%.1f',\\n 'colorbar_ticks': np.linspace(0., 26., 21)[::4],\\n 'colorbar_tick_fmt': '{:.0f}',\\n 'colorbar_label': 'Availability increase [%]',\\n }\\n\\n column_titles = None\\n plot_items = [plot_item10, plot_item11, plot_item12]\\n\\n eval_contour_fill_levels(plot_items)\\n plot_panel_1x3_seperate_colorbar(plot_items, column_titles)\",\n \"def plot_all(self, cmap='Greys', size=(10,10)):\\n\\n fig, ((ax0, ax1), (ax2, ax3)) = plt.subplots(nrows=2,\\n ncols=2,\\n sharex=True,\\n sharey=True)\\n\\n ax0.imshow(self.I, cmap=cmap)\\n ax0.set_title(f'Original {self.I.shape}',\\n fontsize=15)\\n ax1.imshow(self.W, cmap=cmap)\\n ax1.set_title(f'W Loadings {self.W.shape}',\\n fontsize=15)\\n ax2.imshow(self.H, cmap=cmap)\\n ax2.set_title(f'H Loadings {self.H.shape}',\\n fontsize=15)\\n ax3.imshow(self.E, cmap=cmap)\\n ax3.set_title(f'W * H with n={self._n_components} {self.E.shape}',\\n fontsize=15)\\n\\n fig.set_figheight(size[0])\\n fig.set_figwidth(size[1])\\n fig.tight_layout()\\n plt.show()\",\n \"def SH_surface_plots(n_max=6,figsize=(15,15),fs=15,saveA=True,show=False,dpi=400,vis_type='real'):\\n\\n N = 100j\\n\\n for n in range(n_max+1):\\n for m in range(n+1):\\n plt.close('all')\\n print(\\\"working on Y_%s^%s\\\" % (n,m) )\\n\\n PHI,THETA = np.mgrid[0:2*np.pi:N*2, 0:np.pi:N]\\n if vis_type == 'real':\\n R = sp.sph_harm(m,n,PHI,THETA).real\\n if vis_type == 'modulus':\\n r = sp.sph_harm(m,n,PHI,THETA)\\n R = r * r.conjugate()\\n if vis_type == 'unit':\\n R = sp.sph_harm(m,n,PHI,THETA).real + 1\\n\\n X = np.abs(R) * np.sin(THETA) * np.cos(PHI)\\n Y = np.abs(R) * np.sin(THETA) * np.sin(PHI)\\n Z = np.abs(R) * np.cos(THETA)\\n\\n norm = colors.Normalize()\\n fig, ax = plt.subplots(subplot_kw=dict(projection='3d'), figsize=(14,10))\\n sm = cm.ScalarMappable(cmap=cm.seismic)\\n ax.plot_surface(X, Y, Z, rstride=1, cstride=1, facecolors=cm.seismic(norm(R)))\\n ax.set_title('real$(Y^%s_%s)$' % (m,n), fontsize=fs)\\n ax.set_aspect(1)\\n sm.set_array(R)\\n fig.colorbar(sm, shrink=0.8)\\n\\n if saveA:\\n fig.savefig('images/%s/%s_%s.png' % (vis_type,n,m), dpi=dpi)\\n if show:\\n plt.show()\\n\\n # print(\\\"\\\\n only +m values are used.\\\")\\n # for n in range(n_max+1):\\n # for m in range(n+1):\\n # plt.close('all')\\n # print(\\\"\\\\n n,m = %s,%s\\\" % (n,m) )\\n #\\n # R,X,Y,Z = harmonics(m,n)\\n #\\n # fig = plt.figure(figsize=figsize)\\n # ax = plt.subplot(projection='3d')\\n # ax.set_aspect(1)\\n # ax.set_title(\\\"n: %s m: %s\\\" % (n,m), fontsize=fs+2)\\n # ax.plot_surface(X,Y,Z,\\\\\\n # cmap = cm.seismic,\\n # norm = colors.Normalize( vmin=np.min(R),vmax=np.max(R) )\\\\\\n # )\\n #\\n # if saveA:\\n # fig.savefig('images/%s_%s.png' % (n,m), dpi=dpi)\\n # if show:\\n # plt.show()\",\n \"def three_mass_FUV_maps(gal_indices,**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n fig = plt.figure(figsize=(15,14.5),constrained_layout=False)\\n gs1 = fig.add_gridspec(nrows=3, ncols=3, wspace=0.0, hspace=0.0)\\n\\n rotate = False\\n for row_i,gal_index in enumerate(gal_indices):\\n\\n R_max = p.R_max[row_i]\\n\\n ax1 = fig.add_subplot(gs1[row_i, 0])\\n m = map_sim_property(add=True,ax=ax1,gal_index=gal_index, \\\\\\n prop='m',R_max=R_max,vmin=0,vmax=7,\\\\\\n pix_size_kpc=0.5,sim_type='simgas',cmap='viridis',log=True,colorbar=False,rotate=rotate,text=p.text)\\n frame = plt.gca()\\n #if row_i != 2: frame.axes.get_xaxis().set_visible(False)\\n if row_i != 2: ax1.set_xlabel('')\\n if row_i == 0:\\n cbaxes = fig.add_axes([0.05, 0.93, 0.25, 0.01]) \\n cb = plt.colorbar(m, orientation='horizontal', cax = cbaxes)\\n cbaxes.xaxis.set_ticks_position('top')\\n cb.ax.set_title(\\\"log $\\\\Sigma_{\\\\mathrm{gas}}$ [M$_{\\\\odot}$ kpc$^{-2}$]\\\")\\n # Make a size indicator\\n #ax1.plot([p.R_max-15,p.R_max-5],[-p.R_max+5,-p.R_max+5],lw=4,color='white')\\n #ax1.text(p.R_max-16,-p.R_max+7,'10 kpc',color='white',fontsize=12)\\n # Remove axes ticks\\n ax1.tick_params(axis='x',which='both',labelbottom=False)\\n ax1.tick_params(axis='y',which='both',labelleft=False)\\n\\n ax1 = fig.add_subplot(gs1[row_i, 1])\\n m = star_map(add=True,ax=ax1,R_max=R_max,vmin=6,vmax=9,\\\\\\n gal_index=gal_index,colorbar=False,rotate=rotate)\\n frame = plt.gca()\\n #if row_i != 2: frame.axes.get_xaxis().set_visible(False)\\n if row_i != 2: ax1.set_xlabel('')\\n frame.axes.get_yaxis().set_visible(False)\\n if row_i == 0:\\n cbaxes = fig.add_axes([0.375, 0.93, 0.25, 0.01]) \\n cb = plt.colorbar(m, orientation='horizontal', cax = cbaxes) \\n cbaxes.xaxis.set_ticks_position('top')\\n cb.ax.set_title(\\\"log stellar age [yr]\\\")\\n # Make a size indicator\\n #ax1.plot([p.R_max-15,p.R_max-5],[-p.R_max+5,-p.R_max+5],lw=4,color='k')\\n #ax1.text(p.R_max-16,-p.R_max+7,'10 kpc',color='k',fontsize=12)\\n # Remove axes ticks\\n ax1.tick_params(axis='x',which='both',labelbottom=False)\\n ax1.tick_params(axis='y',which='both',labelleft=False)\\n\\n ax1 = fig.add_subplot(gs1[row_i, 2])\\n m = FUV_map(add=True,ax=ax1,gal_index=gal_index,R_max=R_max,vmin=-10,vmax=3,select=p.select,cmap='twilight',colorbar=False,rotate=rotate)\\n frame = plt.gca()\\n #if row_i != 2: frame.axes.get_xaxis().set_visible(False)\\n if row_i != 2: ax1.set_xlabel('')\\n frame.axes.get_yaxis().set_visible(False)\\n if row_i == 0:\\n cbaxes = fig.add_axes([0.69, 0.93, 0.25, 0.01]) \\n cb = plt.colorbar(m, orientation='horizontal', cax = cbaxes) \\n cbaxes.xaxis.set_ticks_position('top')\\n cb.ax.set_title('FUV flux [W/m$^2$/arcsec$^2$]')\\n # Make a size indicator\\n # if row_i == 2:\\n # print('Adding size indicator')\\n #ax1.text(p.R_max-16,-p.R_max+7,'10 kpc',color='w',fontsize=12)\\n #ax1.plot([p.R_max-15,p.R_max-5],[-p.R_max+5,-p.R_max+5],lw=4,color='w')\\n # else:\\n ax1.text(R_max-16,-R_max+7,'10 kpc',color='k',fontsize=12)\\n ax1.plot([R_max-15,R_max-5],[-R_max+5,-R_max+5],lw=4,color='k')\\n # Remove axes ticks\\n ax1.tick_params(axis='x',which='both',labelbottom=False)\\n ax1.tick_params(axis='y',which='both',labelleft=False)\\n\\n # s = segs\\n gs1.update(top=0.92,bottom=0.02,left=0.02,right=0.98)\\n\\n if p.savefig:\\n if not os.path.isdir(p.d_plot + 'pretty/'): os.mkdir(p.d_plot + 'pretty/')\\n plt.savefig('plots/pretty/mass_FUV_maps_%s%s.png' % (p.sim_name,p.sim_run),format='png',dpi=200)\",\n \"def setup_figure(self):\\n # How many data plots are we dealing with in each dimension?\\n plots_x = self._dims[0] # Number of columns\\n plots_y = self._dims[1] if len(self._dims) > 1 else 1 # Number of rows\\n\\n # Set up our base row count\\n num_rows = plots_y + 1 # Add one more row for the update number\\n height_ratios = [1] * plots_y + [0.25]\\n num_cols = plots_x + 1 # Add one more column for the colorbar\\n width_ratios = [1] * plots_x + [0.10]\\n\\n if self._is_multi:\\n # If we have multiple resources, add another row for the resource legend\\n num_rows += 1\\n height_ratios.append(0.1)\\n\\n has_descr = True if len(self._env_str + self._event_str) > 0 else False\\n if has_descr:\\n # if we need to print some descriptive text, add another at the bottom\\n # change this height ratio to make it larger\\n num_rows += 1\\n height_ratios.append(0.35)\\n\\n # Create our grid layout\\n gs = mpl.gridspec.GridSpec(num_rows, num_cols,\\n height_ratios=height_ratios,\\n\\n width_ratios=width_ratios)\\n\\n # Plot our category heatmaps\\n ndx = 0 # Index into our experiment\\n plots = [] # Plots from our experiment\\n for col in range(plots_x):\\n for row in range(plots_y):\\n ax = plt.subplot(gs[row,col])\\n base_cmap = self._cmap if not self._is_multi else ColorMaps.gray\\n plot = plt.imshow(np.zeros(self._grid_shape), cmap=base_cmap,\\n origin='upper', interpolation='nearest',\\n vmin=self._vmin, vmax=self._vmax)\\n ax.tick_params(axis='both', bottom='off', labelbottom='off',\\n left='off', labelleft='off')\\n if self._is_left_edge(ndx):\\n ax.set_ylabel(self._fact2label(ndx,1))\\n if self._is_bottom_edge(ndx):\\n ax.set_xlabel(self._fact2label(ndx,0))\\n plots.append(plot)\\n pa = []\\n for pp in self._post_plot:\\n pa.append(pp.blit_build(ax, ax_ndx=ndx))\\n ndx = ndx+1\\n\\n # Plot the colorbar\\n norm = mpl.colors.Normalize(self._vmin, self._vmax)\\n cax = plt.subplot( gs[0:plots_y,-1] ) # Across data rows, last column\\n if not self._is_multi:\\n cbar = mpl.colorbar.ColorbarBase(cax, cmap=self._cmap, norm=norm, orientation='vertical')\\n else:\\n cbar = mpl.colorbar.ColorbarBase(cax, cmap=ColorMaps.gray, norm=norm, orientation='vertical')\\n cbar.set_label('Abundance')\\n\\n # Plot the update\\n ax = plt.subplot(gs[plots_y,0:plots_x]) # The row after the data plots, across all data plot columns\\n ax.tick_params(axis='both', bottom='off', labelbottom='off',\\n left='off', labelleft='off')\\n ax.set_frame_on(False)\\n ax.set_ylim(0,1)\\n ax.set_xlim(0,1)\\n update = ax.text(0.5,0.25,'Update n/a', ha='center', va='bottom')\\n\\n # Plot the category legend if needed\\n if self._is_multi:\\n ax = plt.subplot(gs[plots_y+1,:-1]) # The row after the update axis, acros all data plot columns\\n legend_handles = []\\n for ndx,cat_name in enumerate(self._categories):\\n legend_handles.append(mpl.patches.Patch(color=self._colors[ndx], label=cat_name))\\n plt.legend(handles=legend_handles, loc='center', frameon=False, ncol=len(legend_handles))\\n ax.tick_params(axis='both', bottom='off', labelbottom='off',\\n left='off', labelleft='off')\\n ax.set_frame_on(False)\\n\\n # If we have an environment and event strings, plot them in the final row across all columns\\n if has_descr:\\n ax = plt.subplot(gs[-1,:])\\n desc = self._env_str + '\\\\n\\\\n' + self._event_str + '\\\\n\\\\n' + f'World: {self._world_size[0]} x {self._world_size[1]}'\\n env = ax.text(0.05, 1, desc, ha='left', va='top', fontsize=7)\\n ax.tick_params(axis='both', bottom='off', labelbottom='off',\\n left='off', labelleft='off')\\n ax.set_frame_on(False)\\n\\n # Title the figure\\n plt.suptitle(self._title)\\n\\n # Store what we need to redraw each frame for blitting.\\n # The values in this dictionary may be either a single element\\n # or an iterable.\\n self._to_draw = {'plots':plots, 'update':update, 'post_plot':pa}\",\n \"def channel_maps_figure(source):\\n # Load data cube\\n data_filename = data_rebinned_filepaths[source]\\n cube = SpectralCube.read(data_filename)\\n # Switch units to km/s (optional)\\n cube = cube.with_spectral_unit(u.km/u.s)\\n # Get WCS object for 2D spatial image\\n wcs_flat = cube[0, :, :].wcs\\n # Calculate pixel scale for the spatial image\\n pixel_scale = wcs_flat.proj_plane_pixel_scales()[0] # gives RA, Dec scales; pick one. They're almost certainly equal, so doesn't matter\\n # Get velocity limits\\n # For now, use all the channels in the saved FITS file; can limit them in the future if necessary\\n v_lo, v_hi = cube.spectral_axis[0], cube.spectral_axis[-1]\\n first_channel_idx = 0 # Using all channels\\n last_channel_idx = cube.shape[0] - 1 # Using all channels\\n print(\\\"First and last available channels \\\", v_lo, v_hi, \\\" at indices \\\", first_channel_idx, last_channel_idx)\\n\\n grid_shape = {\\n 'ngc1977': (3, 4), # 12 channels\\n 'rcw120': (4, 6), # 21 channels\\n 'rcw49': (4, 8), # 31 channels\\n }\\n figsize = {\\n # in inches; fine tune these to remove gaps between the channel maps\\n 'ngc1977': (12, 8),\\n 'rcw120': (16, 10),\\n 'rcw49': (17, 11.5)\\n }\\n fig = plt.figure(figsize=figsize[source])\\n # Matplotlib gridspec setup so that we can have a big colorbar on the side\\n # mega_gridspec will contain all the channel maps and the Axes created within it serves as an anchor for the colorbar\\n mega_gridspec = fig.add_gridspec(right=0.9, left=0.06, top=0.98, bottom=(0.08 if source=='rcw49' else 0.06))\\n # Create a single Axes object from mega_gridspec; this will anchor the colorbar\\n mega_axis = mega_gridspec.subplots()\\n # Hide the bounding box for this large Axes object\\n mega_axis.set_axis_off()\\n # Create the channel map gridspec within the large gridspec\\n gs = mega_gridspec[0,0].subgridspec(*grid_shape[source], hspace=0, wspace=0)\\n # Memoize axes\\n axes = {}\\n def get_axis(index):\\n # Index is 1D index of channel counting from first_channel_idx as 0.\\n # In other words, index of the panel in the figure.\\n # (if first_channel_idx == 0 then axis index == channel index)\\n if index not in axes:\\n axes[index] = fig.add_subplot(gs[np.unravel_index(index-first_channel_idx, grid_shape[source])], projection=wcs_flat)\\n return axes[index]\\n\\n # Text defaults\\n text_x = 0.05 if source=='rcw49' else 0.5\\n text_y = 0.94\\n # ha/va are horizontal and vertical alignment\\n ha = 'left' if source=='rcw49' else 'center'\\n # the color I use there is from Marc's collection of colorblind-friendly colors and works well against \\\"plasma\\\"\\n default_text_kwargs = dict(fontsize=14, color='#ff7f00', ha=ha, va='center')\\n tick_labelsize = 14\\n tick_labelrotation = 50 if source=='rcw49' else 25\\n tick_labelpad = 26 if source=='rcw49' else 13\\n # Colors\\n cmap = \\\"plasma\\\" # Image colormap\\n beam_patch_ec = \\\"grey\\\" # edge color\\n beam_patch_fc = \\\"white\\\" # face color\\n # vlims for images (min and max for image colorscales in data units)\\n vlims = {\\n 'ngc1977': dict(vmin=0, vmax=40),\\n 'rcw120': dict(vmin=0, vmax=25),\\n 'rcw49': dict(vmin=0, vmax=17)\\n }\\n\\n # Loop through channels and plot\\n for channel_idx in range(first_channel_idx, last_channel_idx+1):\\n velocity = cube.spectral_axis[channel_idx]\\n channel_data = cube[channel_idx].to_value()\\n\\n print(first_channel_idx, channel_idx, last_channel_idx)\\n ### print the [min, mean, median, max] for each panel so that we can find the best vlims (min, max) for all of them\\n # print([f(channel_data) for f in (np.nanmin, np.nanmean, np.nanmedian, np.nanmax)])\\n\\n\\n # Setup Axes\\n ax = get_axis(channel_idx)\\n # Remove x and y labels on individual panels (use the \\\"super\\\" titles)\\n ax.set_xlabel(\\\" \\\")\\n ax.set_ylabel(\\\" \\\")\\n ss = ax.get_subplotspec()\\n # Coordinate labels\\n if ss.is_last_row() and ss.is_first_col():\\n # Coordinates only on bottom left corner panel\\n # Mess around with the rotation, position, and size of coordinate labels\\n ax.coords[0].set_ticklabel(rotation=tick_labelrotation, rotation_mode='anchor', pad=tick_labelpad, fontsize=tick_labelsize, ha='right', va='top')\\n ax.coords[1].set_ticklabel(fontsize=tick_labelsize)\\n else:\\n # If not the bottom left panel, no coordinates (panels have no space in between)\\n # Hide coordinates\\n ax.tick_params(axis='x', labelbottom=False)\\n ax.tick_params(axis='y', labelleft=False)\\n # Plot\\n im = ax.imshow(channel_data, origin='lower', cmap=cmap, **vlims[source])\\n # Label velocity on each panel\\n ax.text(text_x, text_y, f\\\"{velocity.to_value():.0f} {velocity.unit.to_string('latex_inline')}\\\", transform=ax.transAxes, **default_text_kwargs)\\n # Beam on every panel\\n beam_patch = cube.beam.ellipse_to_plot(*(ax.transAxes + ax.transData.inverted()).transform([0.9, 0.1]), pixel_scale)\\n beam_patch.set(alpha=0.9, facecolor=beam_patch_fc, edgecolor=beam_patch_ec)\\n ax.add_artist(beam_patch)\\n\\n # Colorbar\\n # Create a space to the right of the panels using the height/location of the mega_axis as an anchor\\n cbar_ax = mega_axis.inset_axes([1.03, 0, 0.03, 1])\\n cbar = fig.colorbar(im, cax=cbar_ax, label='T$_{\\\\\\\\rm MB}$ (K)')\\n ticks = {\\n # 'rcw120'\\n }\\n # cbar.set_ticks(ticks[source])\\n # Titles\\n fig.supxlabel(\\\"Right Ascension\\\")\\n fig.supylabel(\\\"Declination\\\")\\n\\n dpi = 100\\n dpi_stub = \\\"\\\" if dpi==100 else f\\\"_dpi{dpi}\\\"\\n\\n fig_save_name = f\\\"channel_maps_{source}{dpi_stub}.png\\\"\\n fig.savefig(\\n os.path.join(figure_save_path, fig_save_name),\\n dpi=dpi\\n )\\n print(f\\\"Figure saved to {os.path.join(figure_save_path, fig_save_name)}\\\")\",\n \"def animate(frames):\\n plt.grid('on')\\n ax = plt.gca()\\n ax.set_xticks(np.arange(0.5, 10, 1))\\n ax.set_yticks(np.arange(0.5, 10, 1))\\n ax.set_xticklabels([])\\n ax.set_yticklabels([])\\n\\n for i in range(len(env_list)):\\n ax.imshow(env_list[i],cmap='binary')\\n plt.pause(0.05)\",\n \"def visualizeW1(images, vis_patch_side, hid_patch_side, iter, file_name=\\\"trained_\\\"):\\n\\n figure, axes = matplotlib.pyplot.subplots(nrows=hid_patch_side, ncols=hid_patch_side)\\n index = 0\\n\\n for axis in axes.flat:\\n \\\"\\\"\\\" Add row of weights as an image to the plot \\\"\\\"\\\"\\n\\n image = axis.imshow(images[index, :].reshape(vis_patch_side, vis_patch_side),\\n cmap=matplotlib.pyplot.cm.gray, interpolation='nearest')\\n axis.set_frame_on(False)\\n axis.set_axis_off()\\n index += 1\\n\\n \\\"\\\"\\\" Show the obtained plot \\\"\\\"\\\"\\n file=file_name+str(iter)+\\\".png\\\"\\n matplotlib.pyplot.savefig(file)\\n print(\\\"Written into \\\"+ file)\\n matplotlib.pyplot.close()\",\n \"def plot_1d_systems(model):\\n\\n # Construct grid to evaluate the Green's function\\n X_G, Y_G = np.meshgrid(model.x_G, model.y_G)\\n x_G_star = X_G.flatten()[:, None]\\n y_G_star = Y_G.flatten()[:, None]\\n\\n # Create the figure\\n n_plots = max(model.n_input + 1, model.n_output)\\n scaling = n_plots / 2\\n fig, ax = newfig(1.0 * scaling, 1.5)\\n ax.axis('off')\\n gs = gridspec.GridSpec(n_plots, n_plots)\\n gs.update(top=0.8, bottom=0.2, left=0.1, right=0.9,\\n wspace=0.6 * scaling, hspace=0.6 * scaling)\\n\\n # Plot the Green's functions\\n for i in range(model.n_output):\\n for j in range(model.n_input):\\n input_data = np.concatenate((x_G_star, y_G_star), 1)\\n G_pred_identifier = model.sess.run(\\n model.G_network[i][j].evaluate(input_data))\\n G_pred = G_pred_identifier.reshape(X_G.shape)\\n ax = plt.subplot(gs[i, j])\\n h = ax.imshow(G_pred, interpolation='lanczos', cmap='jet',\\n extent=[np.min(model.x_G), np.max(model.x_G), np.min(\\n model.y_G), np.max(model.y_G)],\\n origin='lower', aspect='auto')\\n divider = make_axes_locatable(ax)\\n cax = divider.append_axes(\\\"right\\\", size=\\\"5%\\\", pad=0.05)\\n fig.colorbar(h, cax=cax)\\n ax.set_xlabel('$x$')\\n ax.set_ylabel('$y$', rotation=0, labelpad=12)\\n ax.set_title('$G_{%d,%d}$' % (i + 1, j + 1), fontsize=10)\\n\\n # Plot the homogeneous solutions\\n for i in range(model.n_output):\\n N_pred = model.sess.run(model.idn_N_pred[i].evaluate(model.x))\\n ax = plt.subplot(gs[i, model.n_input])\\n ax.plot(model.x, model.U_hom[:, i], label='Exact')\\n ax.plot(model.x, N_pred, dashes=[2, 2], label='Learned')\\n divider = make_axes_locatable(ax)\\n ymin = min([np.min(N_pred), np.min(model.U_hom[:, i])])\\n ymax = max([np.max(N_pred), np.max(model.U_hom[:, i])])\\n ax.set_xlim(np.min(model.x), np.max(model.x))\\n ax.set_ylim(ymin, ymax)\\n if ymax - ymin < 1e-2:\\n ax.yaxis.set_major_formatter(MathTextSciFormatter(\\\"%1.1e\\\"))\\n ax.set_xlabel('$x$')\\n ax.set_title('Hom$_{%d}$' % (i + 1), fontsize=10)\\n ax.legend()\\n\\n # Save the figure\\n savefig(\\\"%s/%s_%s\\\" % (model.path_result, model.example_name,\\n model.activation_name), crop=False)\",\n \"def run_plots(self):\\n # load the files\\n self.pre_dark_file = os.path.join(self.input_dir, 'step_lastframe.fits')\\n self.post_dark_file = os.path.join(self.input_dir, 'step_dark_current.fits')\\n self.jump_file = os.path.join(self.input_dir, 'step_jump.fits')\\n self.rate_file = os.path.join(self.input_dir, 'step_rate.fits')\\n self.ramp_file = glob.glob(os.path.join(self.input_dir, '*.fits'))[0]\\n\\n # plots\\n self.plot_jump_flags_image()\\n self.plot_groupdq_flags(pixel=[884, 550])\\n self.plot_ramps_pre_post_correction(pixel=[884, 550])\",\n \"def plot(self):\\n h = .02\\n i=1\\n bags_X = self.bags_X\\n bags_y = self.bags_y\\n fig1 = plt.figure(figsize=(45, 9))\\n\\n \\n cm = plt.cm.RdBu\\n cm_bright = ListedColormap(['#FF0000', '#0000FF'])\\n \\n for model in self.models:\\n ax = plt.subplot(1, len(self.models) , i)\\n X = pd.DataFrame(bags_X[i-1])\\n y = pd.Series(bags_y[i-1])\\n x_min, x_max = X[X.columns[0]].min() - .5, X[X.columns[0]].max() + .5\\n y_min, y_max = X[X.columns[1]].min() - .5, X[X.columns[1]].max() + .5\\n xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\\n Z = np.array(model.predict(pd.DataFrame(np.c_[xx.ravel(), yy.ravel()], columns=X.columns)))\\n # print(Z[12])\\n Z = Z.reshape(xx.shape)\\n ax.contourf(xx, yy, Z, cmap=cm, alpha=.8)\\n ax.scatter(X[X.columns[0]], X[X.columns[1]], c=y, cmap=cm_bright, edgecolors='k')\\n # size=[1000*w for w in self.weights[i-1]]\\n ax.set_xlim(xx.min(), xx.max())\\n ax.set_ylim(yy.min(), yy.max())\\n ax.set_xlabel(str(X.columns[0]))\\n ax.set_ylabel(str(X.columns[1]))\\n plt.title(\\\"Estimator \\\"+str(i))\\n i+=1\\n \\n fig2 = plt.figure(figsize=(9,9))\\n X = self.X\\n y = self.y\\n ax2 = plt.subplot(1,1,1)\\n x_min, x_max = X[X.columns[0]].min() - .5, X[X.columns[0]].max() + .5\\n y_min, y_max = X[X.columns[1]].min() - .5, X[X.columns[1]].max() + .5\\n xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\\n Z = np.array(self.predict(pd.DataFrame(np.c_[xx.ravel(), yy.ravel()], columns=X.columns)))\\n Z = Z.reshape(xx.shape)\\n ax2.contourf(xx, yy, Z, cmap=cm, alpha=.8)\\n # size=[1000*w for w in self.weights[i-2]]\\n ax2.scatter(X[X.columns[0]], X[X.columns[1]], c=y, cmap=cm_bright, edgecolors='k')\\n ax2.set_xlim(xx.min(), xx.max())\\n ax2.set_ylim(yy.min(), yy.max())\\n plt.title(\\\"Combined Decision Surface\\\")\\n \\n plt.tight_layout()\\n plt.show()\\n\\n return [fig1,fig2]\",\n \"def grid_frame(self, steps, figure_size=(12, 12)):\\r\\n\\r\\n x = self.seed\\r\\n counts = []\\r\\n for n in np.arange(0, steps):\\r\\n x, stats = self.update_grid(x)\\r\\n counts.append(stats)\\r\\n\\r\\n counts = np.array(counts)\\r\\n\\r\\n fig, ax = plt.subplots(figsize=figure_size)\\r\\n ax.get_xaxis().set_visible(False)\\r\\n ax.get_yaxis().set_visible(False)\\r\\n color_map = matplotlib.colors.ListedColormap(['white', 'black'])\\r\\n img = plt.imshow(x, interpolation='nearest', cmap=color_map)\\r\\n img.axes.grid(False)\\r\\n plt.title(self.title + ' | Step ' + str(steps))\\r\\n plt.show()\\r\\n\\r\\n return x, counts\",\n \"def plot_maps(self, mode=0, target=1, gfilter=0):\\r\\n\\r\\n mpl.figure(1)\\r\\n\\r\\n mpl.imshow(self.avgimg, cmap=matplotlib.cm.gray, interpolation=None) # scipy.ndimage.gaussian_filter(ampmap, filter, order=0, mode='reflect'), cmap=matplotlib.cm.gray)\\r\\n\\r\\n mpl.colorbar()\\r\\n\\r\\n mpl.title('Average image')\\r\\n\\r\\n print ('target, mode: ', target, mode)\\r\\n\\r\\n max1 = np.amax(self.amplitudeImage1)\\r\\n\\r\\n if target > 1:\\r\\n\\r\\n max1 = np.amax([max1, np.amax(self.amplitudeImage2)])\\r\\n\\r\\n max1 = 10.0*int(max1/10.0)\\r\\n\\r\\n mpl.figure(2)\\r\\n\\r\\n mpl.subplot(2,2,4)\\r\\n\\r\\n ipy0, posl, coll = self.plot_averaged_amplitude()\\r\\n\\r\\n\\r\\n\\r\\n mpl.subplot(2,2,1)\\r\\n\\r\\n self.plot_amplitude_map(self.amplitudeImage1, max1, 'Amplitude Map1', filter=gfilter)\\r\\n\\r\\n mpl.subplot(2,2,3)\\r\\n\\r\\n self.plot_phase_map(self.phaseImage1, 'Phase Map1', filter=gfilter)\\r\\n\\r\\n for i, px in enumerate(posl):\\r\\n\\r\\n mpl.plot(px, self.ipy+ipy0, 'o-', markersize=5.0, markerfacecolor = coll[i], markeredgecolor='w')\\r\\n\\r\\n if target > 1:\\r\\n\\r\\n mpl.subplot(2,2,4)\\r\\n\\r\\n self.plot_phase_map(self.phaseImage1, 'Phase Map1', filter=gfilter)\\r\\n\\r\\n mpl.subplot(2,2,2)\\r\\n\\r\\n self.plot_fft()\\r\\n\\r\\n \\r\\n\\r\\n mpl.figure(3)\\r\\n\\r\\n mpl.title('Phase across center horizontally')\\r\\n\\r\\n # extract middle line\\r\\n\\r\\n sh = self.phaseImage1.shape\\r\\n\\r\\n iy0 = int(sh[1]/2)\\r\\n\\r\\n mpl.plot(self.phaseImage1[iy0, :], 'ko-')\\r\\n\\r\\n return\\r\\n\\r\\n \\r\\n\\r\\n if mode == 0:\\r\\n\\r\\n mpl.subplot(2,3,3)\\r\\n\\r\\n for i in range(0, self.nPhases):\\r\\n\\r\\n mpl.plot(ta.n_times, self.DF[:,5,5].view(ndarray))\\r\\n\\r\\n #mpl.plot(self.n_times, D[:,i*55+20, 60])\\r\\n\\r\\n mpl.hold('on')\\r\\n\\r\\n mpl.title('Waveforms')\\r\\n\\r\\n\\r\\n\\r\\n mpl.subplot(2,3,6)\\r\\n\\r\\n for i in range(0, self.nPhases):\\r\\n\\r\\n mpl.plot(ta.n_times, self.DF[:,5,5].view(ndarray))\\r\\n\\r\\n #mpl.plot(self.DF[:,i*55+20, 60])\\r\\n\\r\\n mpl.hold('on')\\r\\n\\r\\n mpl.title('FFTs')\\r\\n\\r\\n\\r\\n\\r\\n if mode == 1 and target > 1:\\r\\n\\r\\n \\r\\n\\r\\n mpl.subplot(2,3,2)\\r\\n\\r\\n mpl.title('Amplitude Map2')\\r\\n\\r\\n #scipy.ndimage.gaussian_filter(self.amplitudeImage2, 2, order=0, output=self.amplitudeImage2, mode='reflect')\\r\\n\\r\\n imga2 = mpl.imshow(scipy.ndimage.gaussian_filter(self.amplitudeImage2, gfilter, order=0, mode='reflect'))\\r\\n\\r\\n imga2.set_clim = (0.0, max1)\\r\\n\\r\\n mpl.colorbar()\\r\\n\\r\\n mpl.subplot(2,3,5)\\r\\n\\r\\n imgp2 = mpl.imshow(scipy.ndimage.gaussian_filter(self.phaseImage2, gfilter, order=0, mode='reflect'), cmap=matplotlib.cm.hsv)\\r\\n\\r\\n mpl.colorbar()\\r\\n\\r\\n imgp2.set_clim=(-np.pi/2.0, np.pi/2.0)\\r\\n\\r\\n mpl.title('Phase Map2')\\r\\n\\r\\n # doubled phase map\\r\\n\\r\\n mpl.subplot(2,3,6)\\r\\n\\r\\n #scipy.ndimage.gaussian_filter(self.phaseImage2, 2, order=0, output=self.phaseImage2, mode='reflect')\\r\\n\\r\\n np1 = scipy.ndimage.gaussian_filter(self.phaseImage1, gfilter, order=0, mode='reflect')\\r\\n\\r\\n np2 = scipy.ndimage.gaussian_filter(self.phaseImage2, gfilter, order=0, mode='reflect')\\r\\n\\r\\n dphase = np1 + np2\\r\\n\\r\\n #dphase = self.phaseImage1 - self.phaseImage2\\r\\n\\r\\n \\r\\n\\r\\n #scipy.ndimage.gaussian_filter(dphase, 2, order=0, output=dphase, mode='reflect')\\r\\n\\r\\n imgpdouble = mpl.imshow(dphase, cmap=matplotlib.cm.hsv)\\r\\n\\r\\n mpl.title('2x Phi map')\\r\\n\\r\\n mpl.colorbar()\\r\\n\\r\\n imgpdouble.set_clim=(-np.pi, np.pi)\\r\\n\\r\\n\\r\\n\\r\\n if mode == 2 or mode == 1:\\r\\n\\r\\n if self.phasex == []:\\r\\n\\r\\n self.phasex = np.random.randint(0, high=self.DF.shape[1], size=self.DF.shape[1])\\r\\n\\r\\n self.phasey = np.random.randint(0, high=self.DF.shape[2], size=self.DF.shape[2])\\r\\n\\r\\n\\r\\n\\r\\n mpl.subplot(2,3,3)\\r\\n\\r\\n sh = self.DF.shape\\r\\n\\r\\n spr = sh[2]/self.nPhases\\r\\n\\r\\n for i in range(0, self.nPhases):\\r\\n\\r\\n Dm = self.avgimg[i*spr,i*spr] # diagonal run\\r\\n\\r\\n mpl.plot(self.n_times, 100.0*(self.DF[:,self.phasex[i], self.phasey[i]]/Dm))\\r\\n\\r\\n mpl.hold('on')\\r\\n\\r\\n mpl.title('Waveforms')\\r\\n\\r\\n\\r\\n\\r\\n if mode == 2:\\r\\n\\r\\n mpl.subplot(2,3,6)\\r\\n\\r\\n sh = self.DF.shape\\r\\n\\r\\n x0 = int(sh[1]/2)\\r\\n\\r\\n y0 = int(sh[2]/2)\\r\\n\\r\\n for i in range(0, self.nPhases):\\r\\n\\r\\n mpl.plot(self.DF[1:,x0,y0])\\r\\n\\r\\n mpl.hold('on')\\r\\n\\r\\n mpl.title('FFTs')\",\n \"def render(self, mode = 'human'):\\n if mode == 'human':\\n\\n if self.is_2d:\\n fig = plt.figure()\\n for index, value in np.ndenumerate(self.board):\\n if value == 1:\\n plt.scatter(*index, c='red', s=1000, alpha=0.2)\\n elif value == -1:\\n plt.scatter(*index, c='blue', s=1000, alpha=0.2)\\n plt.xlim(-1, self.dim[0])\\n plt.ylim(-1, self.dim[1])\\n plt.xticks([])\\n plt.yticks([])\\n plt.grid(True)\\n\\n if self.is_3d:\\n fig = plt.figure()\\n ax = Axes3D(fig)\\n for index, value in np.ndenumerate(self.board):\\n if value == 1:\\n ax.scatter(*index, c='red', s=1000, alpha=0.2)\\n elif value == -1:\\n ax.scatter(*index, c='blue', s=1000, alpha=0.2)\\n ax.set_xlim(0, self.dim[0] - 1)\\n ax.set_ylim(0, self.dim[1] - 1)\\n ax.set_zlim(0, self.dim[2] - 1)\\n\\n else:\\n fig = plt.figure()\\n ax = Axes3D(fig)\\n for index, value in np.ndenumerate(self.board):\\n if value == 1:\\n ax.scatter(*index, c='red', s=1000, alpha=0.2)\\n elif value == -1:\\n ax.scatter(*index, c='blue', s=1000, alpha=0.2)\\n\\n ax.set_xlim(0, self.dim[0] - 1)\\n ax.set_ylim(0, self.dim[1] - 1)\\n ax.set_zlim(0, self.dim[2] - 1)\\n ax.set_title('Nr of steps: ' + str(self.steps))\\n\\n plt.show()\\n return fig\",\n \"def gridPlot16(img_stack):\\r\\n F = plt.figure(figsize = (30,30))\\r\\n F.subplots_adjust(left = 0.05, right = 0.95)\\r\\n grid = ImageGrid(F, 142, nrows_ncols = (4,4), axes_pad = 0.0, share_all = True,\\r\\n label_mode = \\\"L\\\", cbar_location = \\\"top\\\", cbar_mode = \\\"single\\\")\\r\\n \\r\\n i = 0\\r\\n for img in img_stack[0:16]:\\r\\n im = grid[i].imshow(img, interpolation = \\\"nearest\\\", vmin = 0, vmax = 255)\\r\\n i += 1 \\r\\n grid.cbar_axes[0].colorbar(im)\\r\\n plt.savefig('gplot16.png')\\r\\n if 'gplot16.png' in os.listdir():\\r\\n plt.savefig('gplot16_2.png')\\r\\n# for cax in grid.cbar_axes:\\r\\n# cax.toggle_label(False)\\r\\n return\",\n \"def gridPlot6(img_stack):\\r\\n F = plt.figure(figsize = (20,20))\\r\\n F.subplots_adjust(left = 0.05, right = 0.95)\\r\\n grid = ImageGrid(F, 142, nrows_ncols = (2,3), axes_pad = 0.0, share_all = True,\\r\\n label_mode = \\\"L\\\", cbar_location = \\\"top\\\", cbar_mode = \\\"single\\\")\\r\\n \\r\\n i = 0\\r\\n for img in img_stack[0:6]:\\r\\n im = grid[i].imshow(img, interpolation = \\\"nearest\\\", vmin = 0, vmax = 255)\\r\\n i += 1 \\r\\n grid.cbar_axes[0].colorbar(im)\\r\\n plt.savefig('gplot16.png')\\r\\n if 'gplot16.png' in os.listdir():\\r\\n plt.savefig('gplot16_2.png')\\r\\n# for cax in grid.cbar_axes:\\r\\n# cax.toggle_label(False)\\r\\n return\",\n \"def plot_tiles(self):\\n \\n #TODO: adjust plot, border and text_box sizes\\n \\n ordered_projections = []\\n flat_clusters = []\\n colors_2D = []\\n\\n for cluster, nodes in clusters.items():\\n for n in nodes:\\n ordered_projections.append(projection_2D[n])\\n\\n for n in nodes:\\n flat_clusters.append(n)\\n\\n for i, n in enumerate(G.nodes):\\n if n in nodes:\\n colors_2D.append(colors[i])\\n\\n grid_cols = int(np.ceil(np.sqrt(len(ordered_projections))))\\n\\n if len(ordered_projections) <= (grid_cols**2 - grid_cols):\\n grid_rows = grid_cols - 1\\n else:\\n grid_rows = grid_cols\\n\\n #assuming images are same size, get shape\\n l, w = ordered_projections[0].shape\\n\\n #add blank images to pack in grid\\n while len(ordered_projections) < grid_rows*grid_cols:\\n ordered_projections.append(np.zeros((l, w)))\\n colors_2D.append((0., 0., 0.))\\n flat_clusters.append('')\\n\\n f = Figure()\\n\\n grid = ImageGrid(f, 111, #similar to subplot(111)\\n nrows_ncols=(grid_rows, grid_cols), #creates grid of axes\\n axes_pad=0.05) #pad between axes in inch\\n \\n lw = 1.75\\n text_box_size = 5 \\n props = dict(boxstyle='round', facecolor='white')\\n \\n for i, (ax, im) in enumerate(zip(grid, ordered_projections)):\\n ax.imshow(im, cmap='gray')\\n\\n for side, spine in ax.spines.items():\\n spine.set_color(colors_2D[i])\\n spine.set_linewidth(lw)\\n\\n ax.get_yaxis().set_ticks([])\\n ax.get_xaxis().set_ticks([])\\n\\n text = str(flat_clusters[i])\\n ax.text(1, 1, text, va='top', ha='left', bbox=props, size=text_box_size)\\n \\n newWindow = tk.Toplevel()\\n newWindow.grid_rowconfigure(0, weight=1)\\n newWindow.grid_columnconfigure(0, weight=1)\\n \\n #PLOT FRAME\\n plotFrame = tk.Frame(newWindow, bg='lightgrey', width=600, height=400)\\n plotFrame.grid(row=0, column=0, sticky='nsew')\\n \\n canvas = FigureCanvasTkAgg(f, plotFrame)\\n canvas.draw()\\n canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=True)\\n canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True)\\n canvas.figure.tight_layout()\\n \\n\\n #TOOLBAR FRAME\\n toolbarFrame = ttk.Frame(newWindow, width=600, height=100)\\n toolbarFrame.grid(row=1, column=0, sticky='nsew')\\n toolbarFrame.grid_propagate(0)\\n \\n toolbar = NavigationToolbar2Tk(canvas, toolbarFrame)\\n toolbar.update()\",\n \"def plot_HDres_histos_vs_z(\\n df,\\n nameout,\\n threshold_var=\\\"class0\\\",\\n threshold_list=[0.5, 0.7, 0.9],\\n threshold_sign=\\\">\\\",\\n):\\n\\n P = df[df[\\\"class0\\\"] > 0.5]\\n Ias = df[df[\\\"target\\\"] == 0]\\n\\n TP = P[P[\\\"target\\\"] == 0]\\n FP = P[P[\\\"target\\\"] != 0]\\n\\n sel_TP_dic = {}\\n sel_FP_dic = {}\\n for t in threshold_list:\\n if threshold_sign == \\\">\\\":\\n sel_TP_dic[t] = TP[TP[threshold_var] > t]\\n sel_FP_dic[t] = FP[FP[threshold_var] > t]\\n else:\\n sel_TP_dic[t] = TP[TP[threshold_var] < t]\\n sel_FP_dic[t] = FP[FP[threshold_var] < t]\\n\\n plt.clf()\\n cm = CMAP\\n fig = plt.figure(figsize=(14, 14))\\n # gs = gridspec.GridSpec(4, 2, width_ratios=[3, 1], height_ratios=[2, 2, 1, 1])\\n # gs.update(wspace=0.1, hspace=0.3)\\n\\n # # gridspec init\\n # ax00 = plt.subplot(gs[0, 0]) # Hres Ia\\n # ax10 = plt.subplot(gs[1, 0], sharex=ax00) # Hres CC\\n # ax20 = plt.subplot(gs[2:, 0], sharex=ax00) # efficiency\\n # ax01 = plt.subplot(gs[0, 1], sharey=ax00) # histo Ia\\n # ax11 = plt.subplot(gs[1, 1], sharey=ax10) # histo CC\\n # ax21 = plt.subplot(gs[2, 1]) # histo x1\\n # ax31 = plt.subplot(gs[3, 1]) # histo c\\n gs = gridspec.GridSpec(3, 3, height_ratios=[2, 2, 1])\\n # gs.update(wspace=0.2, hspace=0.1)\\n\\n # gridspec init\\n ax00 = plt.subplot(gs[0, 0:2]) # Hres Ia\\n ax10 = plt.subplot(gs[1, 0:2], sharex=ax00) # Hres CC\\n ax20 = plt.subplot(gs[2, 0]) # redshift dist\\n ax01 = plt.subplot(gs[0, 2], sharey=ax00) # histo Ia\\n ax11 = plt.subplot(gs[1, 2], sharey=ax10) # histo CC\\n ax21 = plt.subplot(gs[2, 1]) # histo x1\\n ax31 = plt.subplot(gs[2, 2]) # histo c\\n\\n # lines\\n ax00.plot([0, 1.2], np.zeros(len([0, 1.2])), \\\"k:\\\")\\n ax10.plot([0, 1.2], np.zeros(len([0, 1.2])), \\\"k:\\\")\\n\\n mubins = np.arange(-2, 2 + 0.1, 0.1)\\n\\n # Hres w. histogram\\n def HRwhisto(\\n df, sel_dic, ax_left, ax_right, threshold_sign, ylabel=\\\"TP\\\", visible=False\\n ):\\n if ylabel == \\\"TP\\\":\\n sntyp = \\\"Ia\\\"\\n else:\\n sntyp = \\\"CC\\\"\\n ax_left.scatter(\\n df[\\\"SIM_REDSHIFT_CMB\\\"],\\n df[\\\"delmu\\\"],\\n c=df[\\\"class0\\\"],\\n cmap=CMAP,\\n vmin=0.5,\\n vmax=1,\\n s=8,\\n )\\n ax_left.errorbar(\\n df[\\\"SIM_REDSHIFT_CMB\\\"],\\n df[\\\"delmu\\\"],\\n yerr=df[\\\"delmu_err\\\"],\\n color=\\\"gray\\\",\\n zorder=0,\\n fmt=\\\"none\\\",\\n marker=\\\"none\\\",\\n )\\n\\n ax_left.set_ylim(-2, 2)\\n ax_left.set_xlim(0, 1.2)\\n ax_left.set_ylabel(f\\\"{ylabel} residual\\\", fontsize=18)\\n ax_left.tick_params(labelsize=14)\\n plt.setp(ax_left.get_xticklabels(), visible=visible)\\n if visible is True:\\n ax_left.set_xlabel(\\\"simulated redshift\\\", fontsize=18)\\n for t in threshold_list:\\n sel = sel_dic[t]\\n n_SNe = len(sel)\\n ax_right.hist(\\n sel[\\\"delmu\\\"],\\n orientation=\\\"horizontal\\\",\\n histtype=\\\"step\\\",\\n color=cm(t),\\n bins=mubins,\\n density=True,\\n label=f\\\"{n_SNe} {sntyp} {threshold_sign} {t}\\\",\\n lw=2,\\n )\\n ax_right.legend(loc=\\\"lower center\\\", prop={\\\"size\\\": 13})\\n plt.setp(ax_right.get_yticklabels(), visible=False)\\n plt.setp(ax_right.get_xticklabels(), visible=False)\\n ax_right.plot(\\n [ax_right.get_xlim()[0], ax_right.get_xlim()[1]],\\n np.zeros(len([ax_right.get_xlim()[0], ax_right.get_xlim()[1]])),\\n \\\"k:\\\",\\n )\\n\\n HRwhisto(TP, sel_TP_dic, ax00, ax01, threshold_sign, ylabel=\\\"TP\\\", visible=False)\\n HRwhisto(FP, sel_FP_dic, ax10, ax11, threshold_sign, ylabel=\\\"FP\\\", visible=True)\\n\\n # z histos\\n n, bins_to_use, tmp = ax20.hist(\\n Ias[\\\"SIM_REDSHIFT_CMB\\\"], histtype=\\\"step\\\", color=\\\"black\\\", bins=15, lw=3\\n )\\n\\n for t in threshold_list:\\n sel_TP = sel_TP_dic[t]\\n sel_FP = sel_FP_dic[t]\\n ax20.hist(\\n sel_TP[\\\"SIM_REDSHIFT_CMB\\\"], histtype=\\\"step\\\", color=cm(t), bins=bins_to_use\\n )\\n ax20.hist(\\n sel_FP[\\\"SIM_REDSHIFT_CMB\\\"],\\n histtype=\\\"step\\\",\\n color=cm(t),\\n linestyle=\\\"--\\\",\\n bins=bins_to_use,\\n )\\n ax20.set_xlim(0, 1.2)\\n ax20.tick_params(labelsize=14)\\n ax20.set_xlabel(\\\"simulated redshift\\\", fontsize=18)\\n\\n # hist stretch\\n n, bins_to_use, tmp = ax21.hist(Ias[\\\"x1\\\"], color=\\\"black\\\", histtype=\\\"step\\\", lw=3)\\n for t in threshold_list:\\n sel_TP = sel_TP_dic[t]\\n ax21.hist(\\n sel_TP[\\\"x1\\\"],\\n orientation=\\\"vertical\\\",\\n histtype=\\\"step\\\",\\n color=cm(t),\\n bins=bins_to_use,\\n lw=2,\\n )\\n ax21.set_xlabel(\\\"x1\\\", fontsize=18)\\n ax21.yaxis.set_label_position(\\\"right\\\")\\n ax21.set_xlim(-3, 3)\\n ax21.tick_params(labelsize=14)\\n # color histo\\n n, bins_to_use, tmp = ax31.hist(Ias[\\\"c\\\"], color=\\\"black\\\", histtype=\\\"step\\\", lw=3)\\n for t in threshold_list:\\n sel_TP = sel_TP_dic[t]\\n ax31.hist(\\n sel_TP[\\\"c\\\"],\\n orientation=\\\"vertical\\\",\\n histtype=\\\"step\\\",\\n color=cm(t),\\n bins=bins_to_use,\\n lw=2,\\n )\\n ax31.set_xlabel(\\\"c\\\", fontsize=18)\\n ax31.set_xlim(-1, 1)\\n ax31.tick_params(labelsize=14)\\n ax31.yaxis.set_label_position(\\\"right\\\")\\n\\n gs.tight_layout(fig)\\n plt.savefig(nameout)\\n plt.close()\\n del fig\",\n \"def app_SN_separate_moisture_gradient(self, dfs, phase_dirs, sizer_val, styler_val):\\n\\n print('Currently plotting plot_SN_separate_moisture_gradient')\\n\\n for df, direc in zip(dfs, phase_dirs):\\n # this iterates one or multiple times\\n self.plotter.plot_SN_separate_moisture_gradient(\\n df=df,\\n phase_directory=direc,\\n folder=self.large_test_data.folders['05_gradient_moisture'],\\n sizer=self.formatter.sizer[sizer_val]['1x1_partial_width'],\\n styler=self.formatter.styler[styler_val],\\n xscale=self.xscale_var.get()\\n )\\n\\n print('Done\\\\n')\",\n \"def draw_grid(self):\\n plt.imshow(py.array(\\n map(lambda x: map(lambda y: mplc.colorConverter.to_rgb(colord[y]), x), self.create_grid(self.graph))),\\n interpolation='nearest')\\n plt.show()\",\n \"def _step_plot_closure(self, step_number):\\n for image_name, image, clean_net_output in zip(self.images_names, self.images, self.clean_nets_outputs):\\n plot_image_grid(image_name + \\\"_watermark_clean_{}\\\".format(step_number),\\n [np.clip(torch_to_np(self.watermark_net_output), 0, 1),\\n np.clip(torch_to_np(clean_net_output), 0, 1)])\\n plot_image_grid(image_name + \\\"_learned_image_{}\\\".format(step_number),\\n [np.clip(torch_to_np(self.watermark_net_output) * torch_to_np(self.mask_net_output) +\\n (1 - torch_to_np(self.mask_net_output)) * torch_to_np(clean_net_output),\\n 0, 1), image])\",\n \"def print_multipage(path: Path, tick: int, rgb_image: np.ndarray, heatmaps: np.ndarray):\\n with PdfPages(path) as pdf:\\n height, width, _channels = rgb_image.shape\\n figsize = width / float(DPI), height / float(DPI)\\n fig = plt.figure(figsize=figsize)\\n ax = fig.add_axes([0, 0, 1, 1])\\n ax.axis(\\\"off\\\")\\n ax.imshow(rgb_image)\\n pdf.attach_note(\\\"RGB camera image\\\")\\n pdf.savefig(fig, bbox_inches=\\\"tight\\\")\\n plt.close()\\n\\n rescaled_heatmaps = np.power(1.16, np.log(heatmaps))\\n heatmaps_shape = rescaled_heatmaps.shape\\n\\n for command in range(heatmaps_shape[0]):\\n for waypoint in range(heatmaps_shape[1]):\\n fig = plt.figure()\\n ax = fig.add_axes([0, 0, 1, 1])\\n ax.axis(\\\"off\\\")\\n ax.imshow(\\n rescaled_heatmaps[command, waypoint, ...],\\n cmap=\\\"inferno\\\",\\n interpolation=\\\"nearest\\\",\\n )\\n pdf.attach_note(f\\\"command {command} heatmap {waypoint}\\\")\\n pdf.savefig(fig, bbox_inches=\\\"tight\\\")\\n plt.close()\\n\\n fig = plt.figure()\\n ax = fig.add_axes([0, 0, 1, 1])\\n ax.axis(\\\"off\\\")\\n ax.imshow(\\n np.sum(rescaled_heatmaps[command, ...], axis=0),\\n cmap=\\\"inferno\\\",\\n interpolation=\\\"nearest\\\",\\n )\\n pdf.attach_note(f\\\"command {command} combined heatmap\\\")\\n pdf.savefig(fig, bbox_inches=\\\"tight\\\")\\n plt.close()\\n\\n d = pdf.infodict()\\n d[\\\"Title\\\"] = f\\\"intervention-learning tick {tick}\\\"\\n d[\\\"Author\\\"] = \\\"intervention-learning\\\"\",\n \"def plot_figure4():\\n column_titles = [\\\"5th percentile\\\", \\\"32nd percentile\\\", \\\"50th percentile\\\"]\\n\\n fixed_height_ref = 100.\\n fixed_height_id = list(fixed_heights).index(fixed_height_ref)\\n\\n plot_item0 = {\\n 'data': nc.variables[\\\"p_fixed_perc5\\\"][fixed_height_id, :, :]*1e-3,\\n 'contour_fill_levels': np.linspace(0, .03, 21),\\n 'contour_line_levels': sorted([.003]+list(np.linspace(0, .03, 21)[::5])),\\n 'contour_line_label_fmt': '%.3f',\\n 'colorbar_ticks': np.linspace(0, .03, 21)[::5],\\n 'colorbar_tick_fmt': '{:.3f}',\\n 'colorbar_label': 'Power density [$kW/m^2$]',\\n }\\n plot_item1 = {\\n 'data': nc.variables[\\\"p_fixed_perc32\\\"][fixed_height_id, :, :]*1e-3,\\n 'contour_fill_levels': np.linspace(0, .45, 21),\\n 'contour_line_levels': sorted([.04]+list(np.linspace(0, .45, 21)[::4])),\\n 'contour_line_label_fmt': '%.2f',\\n 'colorbar_ticks': np.linspace(0, .45, 21)[::4],\\n 'colorbar_tick_fmt': '{:.2f}',\\n 'colorbar_label': 'Power density [$kW/m^2$]',\\n }\\n plot_item2 = {\\n 'data': nc.variables[\\\"p_fixed_perc50\\\"][fixed_height_id, :, :]*1e-3,\\n 'contour_fill_levels': np.linspace(0, 1, 21),\\n 'contour_line_levels': sorted([.1]+list(np.linspace(0, 1, 21)[::4])),\\n 'contour_line_label_fmt': '%.2f',\\n 'colorbar_ticks': np.linspace(0, 1, 21)[::4],\\n 'colorbar_tick_fmt': '{:.2f}',\\n 'colorbar_label': 'Power density [$kW/m^2$]',\\n }\\n\\n plot_items = [plot_item0, plot_item1, plot_item2]\\n\\n eval_contour_fill_levels(plot_items)\\n plot_panel_1x3_seperate_colorbar(plot_items, column_titles)\",\n \"def plot_interaction_map(model, name, matrix, output_name, first_variable, second_variable, x_coord, y_coord, output_path): \\n import matplotlib\\n import matplotlib.cm as cm\\n import matplotlib.pyplot as plt\\n\\n font = {'size' : 14}\\n\\n matplotlib.rc('font', **font)\\n fig = plt.figure(figsize=(5,5))\\n ax = plt.subplot()\\n\\n maxValue = np.max(np.abs(matrix))\\n img = ax.imshow((matrix), cmap = cm.bwr, origin='lower', vmin = -min(maxValue, 6), vmax = min(maxValue, 6), interpolation='spline16')\\n\\n first_variable = '{}'.format(first_variable)\\n second_variable = '{}'.format(second_variable)\\n ax.set_ylabel(r'$x_i$ = ' + first_variable)\\n ax.set_xlabel(r'$y_i$ = ' + second_variable)\\n ax.axes.set_xticks([0, 50, 99])\\n ax.axes.set_yticks([0, 50, 99])\\n xticks = np.linspace(np.array(model.feature_limits[first_variable]).min(), np.array(model.feature_limits[first_variable]).max(), 3)\\n yticks = np.linspace(np.array(model.feature_limits[second_variable]).min(), np.array(model.feature_limits[second_variable]).max(), 3)\\n ax.scatter([x_coord], [y_coord], marker='o', color='white', s = 250, edgecolors='black', linewidth=3)\\n\\n ax.set_yticklabels([xticks[tind] for tind in range(3)])\\n ax.set_xticklabels([yticks[tind] for tind in range(3)])\\n ax.axis([0, (100) - 1, 0, (100) - 1])\\n\\n # ax.scatter([x_coord_linear], [y_coord_linear], marker='o', color='blue', s = 250, edgecolors='black', linewidth=3)\\n t = ax.set_title(r'$\\\\mathregular{\\\\frac{\\\\delta ^2 F(\\\\bar{x})}{\\\\delta x_i \\\\delta x_j}}$')\\n # t = ax.set_title('{} and {} - '.format(first_variable, second_variable) + r'$\\\\mathregular{\\\\frac{\\\\delta ^2 F(\\\\bar{x})}{\\\\delta x_i \\\\delta x_j}}$')\\n t.set_position([.5, 1.025])\\n from mpl_toolkits.axes_grid1 import make_axes_locatable\\n divider = make_axes_locatable(ax)\\n cax = divider.append_axes(\\\"right\\\", size=\\\"5%\\\", pad=0.05)\\n cb = plt.colorbar(img, cax=cax)\\n cb.set_label(\\\"Nomralized mixed derivative\\\", rotation=90)\\n plt.savefig('{}/{}_{}_{}_{}_nonlinear_map.pdf'.format(output_path, name, output_name, first_variable, second_variable), transparent=True, bbox_inches='tight', format='pdf', dpi=600)\\n # plt.close('all')\",\n \"def _nd_plot_grid(self, **kwargs):\\n\\n from matplotlib.lines import Line2D\\n from pesummary.core.plots.publication import pcolormesh\\n\\n # only add to corner plot if plotting on an existing figure\\n if \\\"fig\\\" not in kwargs:\\n raise TypeError(\\n \\\"Can only add Grid results to an existing corner plot showing samples\\\"\\n )\\n\\n colors = kwargs.pop(\\\"colors\\\")\\n\\n fig = kwargs.pop(\\\"fig\\\")\\n ax = fig.axes\\n\\n quantiles = kwargs.pop(\\\"quantiles\\\", None)\\n grid2d = kwargs.pop(\\\"grid2d\\\", False)\\n\\n for i, (label, grid) in enumerate(self._grids.items()):\\n plotkwargs = {}\\n plotkwargs[\\\"color\\\"] = colors[i]\\n plotkwargs[\\\"label\\\"] = label\\n\\n axidx = 0\\n for j, param in enumerate(self.parameters):\\n x = grid[0].sample_points[param]\\n pdf = np.exp(\\n grid[0].marginalize_ln_posterior(not_parameters=param) - grid[1]\\n )\\n\\n ax[axidx].plot(x, pdf, **plotkwargs)\\n\\n if quantiles is not None:\\n low, high = self._credible_interval_grid(\\n grid[0], param, interval=quantiles\\n )\\n ax[axidx].axvline(low, color=colors[i], ls=\\\"--\\\")\\n ax[axidx].axvline(high, color=colors[i], ls=\\\"--\\\")\\n\\n # plot 2D posteriors\\n if grid2d:\\n meshkwargs = {}\\n meshkwargs[\\\"zorder\\\"] = kwargs.get(\\\"zorder\\\", -10)\\n meshkwargs[\\\"shading\\\"] = kwargs.get(\\\"shading\\\", \\\"gouraud\\\")\\n\\n if \\\"cmap\\\" not in kwargs:\\n if colors[i] in COLOR_MAP:\\n meshkwargs[\\\"cmap\\\"] = COLOR_MAP[colors[i]]\\n else:\\n meshkwargs[\\\"cmap\\\"] = kwargs[\\\"cmap\\\"]\\n\\n for k in range(j + 1, self._num_parameters):\\n y = grid[0].sample_points[self.parameters[k]]\\n density = np.exp(\\n grid[0].marginalize_ln_posterior(\\n not_parameters=[param, self.parameters[k]]\\n )\\n - grid[1]\\n )\\n\\n # set orientation of the 2D grid\\n p1idx = grid[0].parameter_names.index(param)\\n p2idx = grid[0].parameter_names.index(self.parameters[k])\\n if p1idx < p2idx:\\n # transpose density\\n density = density.T\\n\\n axyidx = axidx + (k - j) * self._num_parameters\\n pcolormesh(x, y, density, ax=ax[axyidx], **meshkwargs)\\n\\n axidx += self._num_parameters + 1\\n\\n # update the legend\\n handles = []\\n for legtext, leghandle in zip(\\n fig.legends[0].texts, fig.legends[0].legendHandles\\n ):\\n label = legtext.get_text()\\n legcolor = leghandle.get_color()\\n\\n handles.append(Line2D([], [], color=legcolor, label=label))\\n\\n for i, label in enumerate(self._grids):\\n for line in ax[0].get_lines():\\n linecolor = line.get_color()\\n # test that colours are the same\\n if linecolor == colors[i]:\\n handles.append(Line2D([], [], color=linecolor, label=label))\\n break\\n\\n # remove original legend\\n fig.legends = []\\n\\n # re-add legend\\n fig.legend(handles=handles, frameon=False, loc=\\\"upper right\\\")\\n\\n return fig\",\n \"def plot_prediction_grid (xx, yy, prediction_grid, filename):\\n from matplotlib.colors import ListedColormap\\n background_colormap = ListedColormap ([\\\"hotpink\\\",\\\"lightskyblue\\\", \\\"yellowgreen\\\"])\\n observation_colormap = ListedColormap ([\\\"red\\\",\\\"blue\\\",\\\"green\\\"])\\n plt.figure(figsize =(10,10))\\n plt.pcolormesh(xx, yy, prediction_grid, cmap = background_colormap, alpha = 0.5)\\n plt.scatter(predictors[:,0], predictors [:,1], c = outcomes, cmap = observation_colormap, s = 50)\\n plt.xlabel('Variable 1'); plt.ylabel('Variable 2')\\n plt.xticks(()); plt.yticks(())\\n plt.xlim (np.min(xx), np.max(xx))\\n plt.ylim (np.min(yy), np.max(yy))\\n plt.savefig(filename)\",\n \"def check_plots(tracklist_subset, tracklist):\\n\\n for trial in tracklist_subset: # Iterates over all available trials\\n\\n # Scale time for colormap\\n scaled_time = (tracklist[trial]['data'].index.values -\\n tracklist[trial]['data'].index.values.min()) / \\\\\\n tracklist[trial]['data'].index.values.ptp()\\n timemax = max(tracklist[trial]['data'].index.values)\\n data = tracklist[trial]['data']\\n colors = plt.cm.cubehelix(scaled_time)\\n m = cm.ScalarMappable(cmap=cm.cubehelix)\\n m.set_array(tracklist[trial]['data'].index.values)\\n\\n # filename = str(trial) + '.pdf'\\n\\n fig = plt.figure(figsize=(20, 20))\\n fig.suptitle(tracklist[trial]['sequence'] + ' ' +\\n tracklist[trial]['behavior'])\\n\\n ax1 = fig.add_subplot(4, 2, 1, projection='3d')\\n ax1.set_title('Pt 1 Position')\\n ax1.scatter3D(xs=tracklist[trial]['data']['pt1x_smth'],\\n ys=tracklist[trial]['data']['pt1y_smth'],\\n zs=tracklist[trial]['data']['pt1z_smth'],\\n zdir='z', s=3, c=colors, marker='o',\\n edgecolor='none') # 3D Scatter plot\\n ax1.autoscale(enable=True, tight=True)\\n ax1.set_xlabel('X position')\\n ax1.set_ylabel('Y position')\\n ax1.set_zlabel('Z position')\\n plt.colorbar(m, shrink=0.5, aspect=10)\\n\\n ax2 = fig.add_subplot(4, 2, 3)\\n ax2.plot(data.index.values, data['pt1y_v_smth'], 'bo')\\n ax2.set_ylabel('Y velocity (cm/s)', color='b')\\n ax2.tick_params('y', colors='b')\\n\\n ax3 = fig.add_subplot(4, 2, 5)\\n ax3.plot(data.index.values, data['pt1_net_v'], 'bo')\\n ax3.set_ylabel('Net Velocity (cm/s)', color='b')\\n ax3.tick_params('y', colors='b')\\n\\n ax4 = fig.add_subplot(4, 2, 7)\\n ax4.plot(data.index.values, data['pt1_net_a'], 'bo')\\n ax4.set_ylabel('Net accel (cm/s2)', color='b')\\n ax4.tick_params('y', colors='b')\\n\\n ax5 = fig.add_subplot(4, 2, 2, projection='3d')\\n ax5.set_title('Pt 2 Position')\\n ax5.scatter3D(xs=tracklist[trial]['data']['pt2x_smth'],\\n ys=tracklist[trial]['data']['pt2y_smth'],\\n zs=tracklist[trial]['data']['pt2z_smth'],\\n zdir='z', s=3, c=colors, marker='o',\\n edgecolor='none') # 3D Scatter plot\\n ax5.autoscale(enable=True, tight=True)\\n ax5.set_xlabel('X position')\\n ax5.set_ylabel('Y position')\\n ax5.set_zlabel('Z position')\\n plt.colorbar(m, shrink=0.5, aspect=10)\\n\\n ax6 = fig.add_subplot(4, 2, 4)\\n ax6.plot(data.index.values, data['pt2y_v_smth'], 'bo')\\n ax6.set_ylabel('Y velocity (cm/s)', color='b')\\n ax6.tick_params('y', colors='b')\\n\\n ax7 = fig.add_subplot(4, 2, 6)\\n ax7.plot(data.index.values, data['pt2_net_v'], 'bo')\\n ax7.set_ylabel('Net Velocity (cm/s)', color='b')\\n ax7.tick_params('y', colors='b')\\n\\n ax8 = fig.add_subplot(4, 2, 8)\\n ax8.plot(data.index.values, data['pt2_net_a'], 'bo')\\n ax8.set_ylabel('Net accel (cm/s2)', color='b')\\n ax8.tick_params('y', colors='b')\\n\\n plt.show()\",\n \"def show_2d_projections(self):\\n\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\")\\n fig, axs = plt.subplots(1, 3)\\n for i in range(3):\\n plt.sca(axs[i])\\n io.imshow(self.image.max(i), cmap='viridis')\",\n \"def montage(W):\\n import matplotlib.pyplot as plt\\n fig, ax = plt.subplots(2, 5)\\n for i in range(2):\\n for j in range(5):\\n im = W[i * 5 + j, :].reshape(32, 32, 3, order='F')\\n sim = (im - np.min(im[:])) / (np.max(im[:]) - np.min(im[:]))\\n sim = sim.transpose(1, 0, 2)\\n ax[i][j].imshow(sim, interpolation='nearest')\\n ax[i][j].set_title(\\\"y=\\\" + str(5 * i + j))\\n ax[i][j].axis('off')\\n #plt.savefig(\\\"plots/ \\\"+fname +\\\".png\\\")\\n plt.show()\",\n \"def plot_steps(self, coord_data, coord_base=\\\"umap\\\", plot_size=3, dpi=300):\\n if len(self.step_data) == 0:\\n print(\\\"No merge step to plot\\\")\\n return\\n if isinstance(coord_data, anndata.AnnData):\\n plot_data = _adata_to_coord_data(coord_data, coord_base)\\n else:\\n plot_data = coord_data.copy()\\n self.plot_before_after(coord_data, coord_base=coord_base, plot_size=plot_size, dpi=dpi)\\n\\n # initial clusters\\n for i, step in enumerate(sorted(self.step_data.keys())):\\n (\\n cur_y,\\n cmat,\\n r1_cmat,\\n r2_cmat,\\n cluster_map,\\n score,\\n step_size,\\n ) = self.step_data[step]\\n fig, axes = plt.subplots(figsize=(4 * plot_size, plot_size), ncols=4, dpi=dpi)\\n ax = axes[0]\\n sns.heatmap(ax=ax, data=cmat, cbar=None, cmap=\\\"Reds\\\")\\n ax.set(title=\\\"Confusion Matrix\\\", ylabel=f\\\"Step {step}\\\")\\n ax = axes[1]\\n sns.heatmap(ax=ax, data=r1_cmat, cbar=None, cmap=\\\"Reds\\\")\\n ax.set(title=\\\"R1 Norm.\\\")\\n ax = axes[2]\\n sns.heatmap(ax=ax, data=r2_cmat, cbar=None, cmap=\\\"Reds\\\")\\n ax.set(title=\\\"R2 Norm.\\\")\\n ax = axes[3]\\n if len(cluster_map) > 0:\\n involved_clusters = set(list(cluster_map.keys()) + list(cluster_map.values()))\\n cur_y = pd.Series(cur_y, index=plot_data.index)\\n cur_y = cur_y.apply(lambda i: cluster_map[i] if i in cluster_map else i)\\n # if not involved, mark as -1\\n cur_y = cur_y.apply(lambda i: i if i in involved_clusters else -1)\\n plot_data[\\\"cur_y\\\"] = cur_y\\n n_color = cur_y.unique().size\\n colors = list(sns.color_palette(\\\"tab10\\\", n_color))\\n cmap = {c: colors.pop() if c != -1 else (0.9, 0.9, 0.9) for c in cur_y.unique()}\\n categorical_scatter(\\n ax=ax,\\n data=plot_data,\\n coord_base=coord_base,\\n hue=\\\"cur_y\\\",\\n palette=cmap,\\n s=3,\\n )\\n ax.set(title=f\\\"Step {step} Cells After Merge\\\")\\n else:\\n ax.axis(\\\"off\\\")\\n return\",\n \"def plot_prediction_grid(xx, yy, prediction_grid, filename):\\n from matplotlib.colors import ListedColormap\\n background_colormap = ListedColormap ([\\\"hotpink\\\",\\\"lightskyblue\\\", \\\"yellowgreen\\\"])\\n observation_colormap = ListedColormap ([\\\"red\\\",\\\"blue\\\",\\\"green\\\"])\\n plt.figure(figsize =(10,10))\\n plt.pcolormesh(xx, yy, prediction_grid, cmap = background_colormap, alpha = 0.5)\\n plt.scatter(predictors[:,0], predictors [:,1], c = outcomes, cmap = observation_colormap, s = 50)\\n plt.xlabel('Variable 1'); plt.ylabel('Variable 2')\\n plt.xticks(()); plt.yticks(())\\n plt.xlim (np.min(xx), np.max(xx))\\n plt.ylim (np.min(yy), np.max(yy))\\n plt.savefig(filename)\",\n \"def plot_figure5():\\n column_titles = [\\\"50 - 150m\\\", \\\"0 - 10km\\\", \\\"Ratio\\\"]\\n\\n plot_item0 = {\\n 'data': p_integral_mean[0, :, :]*1e-6,\\n 'contour_line_levels': np.linspace(0, .31, 21)[::4],\\n 'contour_fill_levels': np.linspace(0, .31, 21),\\n 'colorbar_ticks': np.linspace(0, .31, 21)[::4],\\n 'colorbar_tick_fmt': '{:.2f}',\\n 'colorbar_label': '[$MWm/m^2$]',\\n }\\n plot_item1 = {\\n 'data': p_integral_mean[1, :, :]*1e-6,\\n 'contour_line_levels': np.linspace(0, 65, 21)[::4],\\n 'contour_fill_levels': np.linspace(0, 65, 21),\\n 'colorbar_ticks': np.linspace(0, 65, 21)[::4],\\n 'colorbar_tick_fmt': '{:.0f}',\\n 'colorbar_label': '[$MWm/m^2$]',\\n }\\n plot_item2 = {\\n 'data': plot_item1['data']/plot_item0['data'],\\n 'log_scale': True,\\n 'contour_line_levels': [300., 600.],\\n 'contour_fill_levels': np.logspace(np.log10(100.0), np.log10(6700.0), num=16),\\n 'colorbar_ticks': [100., 300., 1000., 3000.],\\n 'colorbar_tick_fmt': '{:.0f}',\\n 'colorbar_label': 'Increase factor [-]',\\n }\\n\\n plot_items = [plot_item0, plot_item1, plot_item2]\\n\\n eval_contour_fill_levels(plot_items)\\n plot_panel_1x3_seperate_colorbar(plot_items, column_titles)\",\n \"def plot_ncmc_work(self, filename):\\n with PdfPages(filename) as pdf:\\n for envname in self.get_environments():\\n modname = 'NCMCEngine'\\n work = dict()\\n for direction in ['delete', 'insert']:\\n varname = '/' + envname + '/' + modname + '/' + 'work_' + direction\\n try:\\n # TODO: For now, we analyze all but the last sample, so that this can be run on active simulations.\\n # Later, we should find some way to omit the last sample only if it is nonsensical.\\n work[direction] = self._ncfile[varname][:-1,:]\\n print('Found %s' % varname)\\n except Exception as e:\\n pass\\n\\n def plot_work_trajectories(pdf, work, title=\\\"\\\"):\\n \\\"\\\"\\\"Generate figures for the specified switching legs.\\n \\\"\\\"\\\"\\n plt.figure(figsize=(12, 8))\\n\\n nrows = 2\\n ncols = 6\\n workcols = 2\\n for (row, direction) in enumerate(['delete', 'insert']):\\n #\\n # Plot work vs step\\n #\\n\\n col = 0\\n plt.subplot2grid((nrows,ncols), (row, col), colspan=(ncols-workcols))\\n\\n # Plot average work distribution in think solid line\\n plt.plot(work[direction].mean(0), 'k-', linewidth=1.0, alpha=1.0)\\n # Plot bundle of work trajectories in transparent lines\\n plt.plot(work[direction].T, 'k-', linewidth=0.5, alpha=0.3)\\n # Adjust axes to eliminate large-magnitude outliers (keep 98% of data in-range)\\n workvals = np.ravel(np.abs(work[direction]))\\n worklim = np.percentile(workvals, 98)\\n nsteps = work[direction].shape[1]\\n plt.axis([0, nsteps, -worklim, +worklim])\\n # Label plot\\n if row == 1: plt.xlabel('steps')\\n plt.ylabel('work / kT')\\n plt.title(\\\"%s NCMC in environment '%s' : %s\\\" % (title, envname, direction))\\n plt.legend(['average work', 'NCMC attempts'])\\n\\n #\\n # Plot work histogram\\n #\\n\\n col = ncols - workcols\\n plt.subplot2grid((nrows,ncols), (row, col), colspan=workcols)\\n\\n # Plot average work distribution in think solid line\\n #nbins = 40\\n workvals = work[direction][:-1,-1]\\n #plt.hist(workvals, nbins)\\n if workvals.std() != 0.0:\\n sns.distplot(workvals, rug=True)\\n else:\\n print('workvals has stddev of zero')\\n print(workvals)\\n # Adjust axes to eliminate large-magnitude outliers (keep 98% of data in-range)\\n #worklim = np.percentile(workvals, 98)\\n #oldaxis = plt.axis()\\n #plt.axis([-worklim, +worklim, 0, oldaxis[3]])\\n # Label plot\\n if row == 1: plt.xlabel('work / kT')\\n plt.title(\\\"total %s work\\\" % direction)\\n\\n pdf.savefig() # saves the current figure into a pdf page\\n plt.close()\\n\\n if len(work) > 0:\\n # Plot work for all chemical transformations.\\n plot_work_trajectories(pdf, work, title='(all transformations)')\\n\\n # Plot work separated out for each chemical transformation\\n #[niterations, nsteps] = work.shape\\n #transformations = dict()\\n #for iteration in range(niterations):\\n # plot_work_trajectories(pdf, work, title='(all transformations)')\",\n \"def generate_image_grid(sess, df, filenames,op, op2):\\n #x_points = np.arange(0, 1, 1.5).astype(np.float32)\\n #y_points = np.arange(0, 1, 1.5).astype(np.float32)\\n\\n nx, ny = 12, 1\\n #plt.subplot()\\n gs = gridspec.GridSpec(nx, ny, hspace=1, wspace=0.05)\\n # input_x = sess.run(op2, feed_dict={x_input: df[0:24]})\\n #\\n # plt.imshow(np.array(df[0].tolist()).reshape(28, 28), cmap='gray')\\n # plt.show()\\n # x = sess.run(op, feed_dict={decoder_input: input_x[0].reshape(1,2)})\\n # img = np.array(x.tolist()).reshape(28, 28)\\n #\\n # plt.imshow(img, cmap='gray')\\n # plt.show()\\n\\n \\\"\\\"\\\" grid \\\"\\\"\\\"\\n input_x = sess.run(op2, feed_dict={x_input: df[0:24]})\\n for i, g in enumerate(gs):\\n\\n x = sess.run(op, feed_dict={decoder_input: input_x[i].reshape(1,2)})\\n ax = plt.subplot(g)\\n img = np.array(x.tolist()).reshape(28, 28)\\n ax.imshow(img, cmap='gray')\\n ax.set_xticks([])\\n ax.set_yticks([])\\n #ax.set_aspect('auto')\\n ax.set_title(filenames[i])\\n plt.show()\\n\\n for i, g in enumerate(gs):\\n\\n ax = plt.subplot(g)\\n img = np.array(df[i].tolist()).reshape(28, 28)\\n ax.imshow(img, cmap='gray')\\n ax.set_xticks([])\\n ax.set_yticks([])\\n #ax.set_aspect('auto')\\n ax.set_title(filenames[i])\\n plt.show()\",\n \"def distribution_horizontale_par_blocs(args):\\n number_files = [2,5,10,20]; fact_w = 1; fact_h = 1;\\n rep = args[\\\"path_save\\\"]+args[\\\"correction\\\"]+\\\\\\n \\\"/data_p_\\\"+str(args[\\\"p_value\\\"])+\\\"/distribution/\\\";\\n fig = plt.figure(); default_size = fig.get_size_inches(); \\n f25, ax_arrs_k25 = plt.subplots(2, 2, figsize=(default_size[0]*fact_w, \\\\\\n default_size[1]*fact_h), \\\\\\n );\\n \\n cpt1 = 0; cpt2 = 1; tab_bins = [20, 40, 80,100, 100, 100]\\n for ind, k in enumerate(number_files[:len(number_files)//2]) :\\n df = pd.read_csv(rep+args[\\\"fichier_prefix\\\"] +str(k)+args[\\\"ext\\\"], \\\\\\n names=[\\\"cpt\\\",\\\"moy_dc\\\",\\\"moy_dh\\\", \\\"aretes_matE\\\", \\\"correl_dh_dl\\\"], \\\\\\n sep=';')\\n N_graphs = df[\\\"moy_dc\\\"].count();\\n \\n# bins = range(0, (ind+1)*args[\\\"num_bins\\\"]);\\n bins = range(0, tab_bins[ind]);\\n max_count_dl, max_count_dh = count_max_df(df)\\n \\n # plot ax1\\n (mu, sigma) = norm.fit(df[\\\"moy_dc\\\"]); # best fit of data\\n sns.distplot(df[\\\"moy_dc\\\"], ax = ax_arrs_k25[cpt1, ind], \\\\\\n bins = bins, kde = False)\\n ax_arrs_k25[cpt1, ind].set(xlabel= \\\"moy_distance_correction\\\", \\\\\\n ylabel= \\\"nombre_graphe\\\", \\\\\\n title = \\\"distance de correction pour \\\\n \\\"+ str(k)+ \\\\\\n \\\" cases modifiees\\\")\\n ax_arrs_k25[cpt1, ind].plot([k+1,k+1], (0,max_count_dl), 'r--' )\\n ax_arrs_k25[cpt1, ind].set_yticklabels(['{:3.2f}%'.format(x*100/N_graphs) \\\\\\n for x in ax_arrs_k25[cpt1, ind].get_yticks()])\\n \\n #plot ax2\\n (mu, sigma) = norm.fit(df[\\\"moy_dh\\\"]); # best fit of data\\n sns.distplot(df[\\\"moy_dh\\\"], ax = ax_arrs_k25[cpt2, ind], \\\\\\n bins = bins, kde = False)\\n ax_arrs_k25[cpt2, ind].set(xlabel= \\\"moy_distance_correction\\\", \\\\\\n ylabel= \\\"nombre_graphe\\\", \\\\\\n title = \\\"distance Hamming pour \\\\n \\\"+ str(k)+\\\\\\n \\\" cases modifiees\\\")\\n ax_arrs_k25[cpt2, ind].plot([k+1,k+1], (0,max_count_dl), 'r--' )\\n ax_arrs_k25[cpt2, ind].set_yticklabels(['{:3.2f}%'.format(x*100/N_graphs) \\\\\\n for x in ax_arrs_k25[cpt2, ind].get_yticks()])\\n \\n plt.tight_layout(pad=0.4, w_pad=0.5, h_pad=1.0)\\n plt.grid(True)\\n plt.savefig(args[\\\"path_save\\\"]+args[\\\"correction\\\"]+\\\"/courbes/\\\"+\\\\\\n \\\"distributionMoyDCDHp05k25.jpeg\\\",\\\\\\n dpi= 250)\\n \\n fig = plt.figure(); default_size = fig.get_size_inches(); \\n f1020, ax_arrs_k1020 = plt.subplots(2, 2, figsize=(default_size[0]*fact_w, \\\\\\n default_size[1]*fact_h), \\\\\\n ); \\n for ind, k in enumerate(number_files[len(number_files)//2:]) :\\n df = pd.read_csv(rep+args[\\\"fichier_prefix\\\"] +str(k)+args[\\\"ext\\\"], \\\\\\n names=[\\\"cpt\\\",\\\"moy_dc\\\",\\\"moy_dh\\\", \\\"aretes_matE\\\", \\\"correl_dh_dl\\\"], \\\\\\n sep=';')\\n N_graphs = df[\\\"moy_dc\\\"].count();\\n \\n bins = range(0, tab_bins[len(number_files)//2:][ind]);\\n max_count_dl, max_count_dh = count_max_df(df)\\n \\n # plot ax1\\n (mu, sigma) = norm.fit(df[\\\"moy_dc\\\"]); # best fit of data\\n sns.distplot(df[\\\"moy_dc\\\"], ax = ax_arrs_k1020[cpt1, ind], \\\\\\n bins = bins, kde = False)\\n ax_arrs_k1020[cpt1, ind].set(xlabel= \\\"moy_distance_correction\\\", \\\\\\n ylabel= \\\"nombre_graphe\\\", \\\\\\n title = \\\"distance de correction pour \\\\n \\\"+ str(k)+ \\\\\\n \\\" cases modifiees\\\")\\n ax_arrs_k1020[cpt1, ind].plot([k+1,k+1], (0,max_count_dl), 'r--' )\\n ax_arrs_k1020[cpt1, ind].set_yticklabels(['{:3.2f}%'.format(x*100/N_graphs) \\\\\\n for x in ax_arrs_k1020[cpt1, ind].get_yticks()]) \\n \\n #plot ax2\\n (mu, sigma) = norm.fit(df[\\\"moy_dh\\\"]); # best fit of data\\n sns.distplot(df[\\\"moy_dh\\\"], ax = ax_arrs_k1020[cpt2, ind], \\\\\\n bins = bins, kde = False)\\n ax_arrs_k1020[cpt2, ind].set(xlabel= \\\"moy_distance_correction\\\", \\\\\\n ylabel= \\\"nombre_graphe\\\", \\\\\\n title = \\\"distance Hamming pour \\\\n \\\"+ str(k)+\\\\\\n \\\" cases modifiees\\\")\\n ax_arrs_k1020[cpt2, ind].plot([k+1,k+1], (0,max_count_dl), 'r--' )\\n ax_arrs_k1020[cpt2, ind].set_yticklabels(['{:3.2f}%'.format(x*100/N_graphs) \\\\\\n for x in ax_arrs_k1020[cpt2, ind].get_yticks()])\\n# fig = ax_arrs[0,0].figure ;\\n# fig.text(0.5,0.04, \\\"Some very long and even longer xlabel\\\", ha=\\\"center\\\", va=\\\"center\\\")\\n# fig.text(0.05,0.5, \\\"Some quite extensive ylabel\\\", ha=\\\"center\\\", va=\\\"center\\\", rotation=90)\\n\\n \\n plt.tight_layout(pad=0.4, w_pad=0.5, h_pad=1.0)\\n plt.grid(True)\\n plt.savefig(args[\\\"path_save\\\"]+args[\\\"correction\\\"]+\\\"/courbes/\\\"+\\\\\\n \\\"distributionMoyDCDHp05k1020.jpeg\\\",\\\\\\n dpi= 250) #190 \",\n \"def visualize_decomposition(maps_filename, timecourses_filename, out_filename, mask_nib, hgap=20, vgap=20, normalize=False):\\n\\n\\tmaps = np.load(maps_filename)\\n\\tmaps[np.abs(maps) < 5e-3] = 0\\n\\t\\n\\ttimecourses = np.load(timecourses_filename)\\n\\tncomponents = maps.shape[0]\\n\\n\\t# draw the maps and timecourses into temporary files\\n\\tmap_image_files = [tempfile.mkstemp(suffix=\\\".png\\\")[1] for k in range(ncomponents)]\\n\\ttimecourse_image_files = [tempfile.mkstemp(suffix=\\\".png\\\")[1] for k in range(ncomponents)]\\n\\n\\tfig = pyplot.figure(figsize=(4, 2))\\n\\n\\tfor k in range(ncomponents):\\n\\t\\tmap = maps[k,:]\\n\\t\\tif normalize:\\n\\t\\t\\tmap = map / np.linalg.norm(map)\\n\\t\\tplot_map(map, mask_nib, map_image_files[k])\\n\\n\\t\\tpyplot.clf()\\n\\t\\tpyplot.plot(timecourses[:,k])\\n\\t\\tpyplot.savefig(timecourse_image_files[k])\\n\\n\\tpyplot.close(fig)\\n\\n\\tmap_images = [Image.open(fname) for fname in map_image_files]\\n\\ttimecourse_images = [Image.open(fname) for fname in timecourse_image_files]\\n\\n\\tmap_width = map_images[0].size[0]\\n\\timage_height = map_images[0].size[1]\\n\\ttimecourse_width = timecourse_images[0].size[0]\\n\\n\\tresult_width = map_width + hgap + timecourse_width\\n\\tresult_height = ncomponents * (image_height + vgap)\\n\\n\\tresult = Image.new('RGB', (result_width, result_height), (255, 255, 255))\\n\\ty = 0\\n\\tfor (map_image, timecourse_image) in zip(map_images, timecourse_images):\\n\\t\\tresult.paste(im=map_image, box=(0, y))\\n\\t\\tresult.paste(im=timecourse_image, box=(map_width+hgap, y))\\n\\t\\ty += image_height + vgap\\n\\n\\tresult.save(out_filename)\\n\\n\\tfor k in range(ncomponents):\\n\\t\\tos.remove(map_image_files[k])\\n\\t\\tos.remove(timecourse_image_files[k])\",\n \"def visualize_network_samples_grid_1D(net, start=5, stop=100, step=10,\\n f_ext=\\\"pdf\\\"):\\n save_dir = make_memnet_checkpoint_dir(\\n Path(\\\"plots/vis_memnet_samples/grid/\\\"), net)\\n if not save_dir.exists():\\n save_dir.makedirs()\\n relevant_vals = range(start, stop, step)\\n grid_width = len(relevant_vals)\\n print(\\\"Loading plants.\\\")\\n inputs0, stim_vals0 = load_plants(\\n net.image_width,\\n net.trainingset_dir,\\n layer_type=net.layer_type,\\n normalize=True)\\n inputs0 = inputs0 / 255. # Normalize\\n print(\\\"Finished.\\\")\\n irrelevant_dim = int(net.input_distribution_dim == 0)\\n if irrelevant_dim == 0:\\n inds = list(product([50], relevant_vals))\\n else:\\n inds = list(product(relevant_vals, [50]))\\n inputs_valid = inputs0[stim_vals0[:, irrelevant_dim] == 50]\\n stim_vals = stim_vals0[stim_vals0[:, irrelevant_dim] == 50]\\n fig, axes = plt.subplots(\\n 1, grid_width, figsize=(50, 50 / len(relevant_vals)))\\n preds = []\\n inputs = []\\n print(\\\"Making plots...\\\")\\n for i in range(len(stim_vals)):\\n if tuple(stim_vals[i]) in inds:\\n print(\\\"Making \\\", stim_vals[i])\\n inputs.append(inputs_valid[i])\\n preds = net.predict(inputs, keep_session=True)\\n for i in range(len(preds)):\\n ax = axes[i]\\n ax.imshow(\\n preds[i:i + 1].reshape(net.image_width, net.image_width),\\n cmap=\\\"gray_r\\\")\\n ax.set_xticklabels(\\\"\\\")\\n ax.set_xticks([])\\n ax.set_xticklabels(\\\"\\\")\\n ax.set_yticks([])\\n ax.set_yticklabels(\\\"\\\")\\n plt.savefig(save_dir.joinpath('grid.' + f_ext))\\n print(\\\"Saved to \\\", save_dir.joinpath('grid.' + f_ext))\\n return\",\n \"def plotOceanParcelsAccumulatedResults(input_data_folder, output_folder, start_year, end_year, dt=1):\\n # Only for\\n tot_days = (end_year-start_year)*365\\n start_date = datetime.strptime(str(start_year),'%Y')\\n\\n open_files = []\\n for c_day in np.arange(0, tot_days, dt):\\n print(F\\\"------- {c_day}---------\\\")\\n # Released months\\n c_date = start_date + timedelta(days=int(c_day))\\n months = (c_date.year - start_date.year)*12 + c_date.month - start_date.month\\n\\n # Iterate over all the files that should contribute to the image\\n fig = plt.figure(figsize=(20,10))\\n ax = plt.subplot(1, 1, 1, projection=ccrs.PlateCarree())\\n for c_month in range(0, months + 1):\\n c_file_year = (start_date + relativedelta(months=int(c_month))).year\\n c_file_month = (start_date + relativedelta(months=int(c_month))).month\\n skip_days = c_day - (c_date - datetime.strptime(F\\\"{c_file_year}-{c_file_month}\\\",'%Y-%m')).days\\n\\n if len(open_files) <= c_month:\\n file_name = F\\\"TenYears_YesWinds_YesDiffusion_NoUnbeaching_{c_file_year}_{(c_file_month):02d}.nc\\\"\\n print(F\\\"Reading new file: {file_name}\\\")\\n open_files.append(Dataset(join(input_data_folder, file_name), \\\"r\\\", format=\\\"NETCDF4\\\"))\\n\\n c_time_step = c_day - skip_days\\n # lats = open_files[c_month].variables['lat'][:,c_time_step]\\n # lons = open_files[c_month].variables['lon'][:,c_time_step]\\n ax.scatter(open_files[c_month].variables['lon'][:,c_time_step], open_files[c_month].variables['lat'][:,c_time_step], color='c', s=1)\\n\\n title = F\\\"{start_date.strftime('%Y-%m-%d')} - {c_date.strftime('%Y-%m-%d')}\\\"\\n ax.coastlines()\\n ax.set_title(title, fontsize=30)\\n\\n # plt.show()\\n plt.savefig(F\\\"{output_folder}/{start_date.strftime('%Y_%m')}_{c_day:04d}.png\\\")\\n plt.close()\",\n \"def plot_image_grid(epoch, generated_images):\\n\\n fig = plt.figure(figsize=(GRID_SIZE, GRID_SIZE))\\n fig.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0.001, hspace=0.001)\\n\\n for ind in range(GRID_IMGS):\\n ax = fig.add_subplot(GRID_SIZE, GRID_SIZE, ind + 1, xticks=[], yticks=[])\\n ax.imshow(np.uint8(((generated_images[ind] + 1) / 2) * 255), cmap='gray')\\n\\n plt.savefig('/content/drive/My Drive/WGAN/train_images/image_iteration_{:05d}.png'.format(epoch + 1))\\n plt.close()\",\n \"def grid_image(output):\\n grid = []\\n for data in output:\\n grid += [make_grid(data, nrow=5, normalize=True)]\\n return grid\",\n \"def plot_pipeline(differences_dir, plots_dir_intonation, num_quantiles = 31):\\n perf_list = ['54363310_1939750539', '540791114_1793842568']\\n difference_path_list = [os.path.join(differences_dir, perf_list[i] + \\\".npy\\\") for i in range(len(perf_list))]\\n comparisons_list = [np.load(path) for _, path in enumerate(difference_path_list)]\\n num_samples = 10000\\n # quantile indices\\n q_indices = (np.linspace(0, 1, num_quantiles)*(num_samples-1)).astype(np.int32)\\n plt.style.use('ggplot')\\n labels = ['perf. A', 'perf. B']\\n colors = ['blue', 'red']\\n linestyles = ['dotted', 'dashed']\\n grid = plt.GridSpec(2, 2)\\n ax1 = plt.subplot(grid[1, 0])\\n ax2 = plt.subplot(grid[1, 1])\\n ax4 = plt.subplot(grid[0, :])\\n ax4.plot(comparisons_list[0], color=colors[0], label=labels[0], linestyle=linestyles[0])\\n ax4.plot(comparisons_list[1], color=colors[1], label=labels[1], linestyle=linestyles[1])\\n ax4.set_title(\\\"Difference between MIDI and pYIN, two performances\\\")\\n ax4.set_ylabel(\\\"Cents\\\")\\n ax4.set_xlabel(\\\"Frames\\\")\\n ax4.axhline(y=200, linestyle=\\\"solid\\\", linewidth=0.7, c=\\\"black\\\", zorder=2, label=\\\"thresh.\\\")\\n ax4.axhline(y=-200, linestyle=\\\"solid\\\", linewidth=0.7, c=\\\"black\\\", zorder=2)\\n ax4.legend(loc=\\\"upper right\\\")\\n ax1.set_title(\\\"10k random sample of distances\\\")\\n ax1.set_ylabel(r\\\"$|$Cents$|$\\\")\\n ax1.set_xlabel(\\\"Frames sorted by distance\\\")\\n ax2.set_title(\\\"Sample quantiles\\\")\\n ax2.set_xlabel(\\\"Quantile indices\\\")\\n # run analysis song by song\\n for i, arr in enumerate(comparisons_list):\\n # random sample so all arrays have the same size\\n samples = np.random.choice(arr, num_samples, replace=True)\\n # sort\\n samples = np.sort(np.abs(samples))\\n # discard the high values (might be due to misalignment, etc...)\\n samples = samples[samples <= 200]\\n samples = np.random.choice(samples, num_samples, replace=True)\\n samples = np.sort(np.abs(samples))\\n ax1.plot(samples, color=colors[i], linestyle=linestyles[i], label=labels[i])\\n # get the quantiles\\n samples = samples[q_indices]\\n ax2.plot(samples, color=colors[i], linestyle=linestyles[i], label=labels[i])\\n ax1.legend()\\n ax2.legend()\\n plt.tight_layout()\\n plt.savefig(os.path.join(plots_dir_intonation, \\\"data processing pipeline.eps\\\"), format=\\\"eps\\\")\\n plt.show()\",\n \"def vis_mechanically_coupled_regions(img_dir,output_dir,data,dbscn_length,dbscn_min_size,display_not_save=False):\\n #Read in the image that is segmented/labelled for nuclei\\n img=imread(img_dir)\\n\\n #save plots to show clusters\\n fig = plt.figure(figsize=(6, 2))\\n ax0 = fig.add_subplot(131)\\n ax1 = fig.add_subplot(132)\\n ax3 = fig.add_subplot(133)\\n #show segmented image labels\\n ax0.imshow(img,aspect='auto') \\n ax0.axis('off')\\n #nuclear centroid color-coded by their orientation\\n img1=ax1.scatter(data[\\\"Y\\\"], data[\\\"X\\\"], c=data[\\\"angles\\\"],s=1)\\n ax1.set_xlim(0,img.shape[0])\\n ax1.set_ylim(img.shape[1],0)\\n plt.colorbar(img1)\\n ax1.axis('off')\\n\\n # plot the cluster assignments\\n img3=ax3.scatter(data[data[\\\"clusters\\\"]> -1][\\\"Y\\\"], data[data[\\\"clusters\\\"]> -1][\\\"X\\\"], \\n c=data[data[\\\"clusters\\\"]> -1][\\\"clusters\\\"],cmap=\\\"plasma\\\",s=1)\\n ax3.set_xlim(0,img.shape[0])\\n ax3.set_ylim(img.shape[1],0)\\n ax3.axis('off')\\n\\n #add titles\\n ax0.title.set_text('Segmented Image')\\n ax1.title.set_text('Filtered Orientation')\\n ax3.title.set_text('Clusters')\\n\\n if display_not_save:\\n plt.show()\\n else: \\n plt.savefig((output_dir+\\\"/\\\"+img_dir.rsplit('/', 1)[-1][:-4]+\\\"_\\\"+str(dbscn_length)+\\\"_\\\"+ str(dbscn_min_size)+\\\".png\\\"),dpi=600, bbox_inches = 'tight',pad_inches = 0)\\n fig.clf()\\n plt.close(fig)\\n plt.close('all')\\n \\n \\n del fig,ax0,ax1,ax3,img1,img3\",\n \"def visualize_gradient_norms(gradient_norms, parameter_names, plot_filepath):\\n\\n fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(2 * 10, 2 * 5), sharex=\\\"all\\\", sharey=\\\"all\\\")\\n fig.suptitle(\\\"Gradient norms vs. batch_norm & skip_con\\\", fontsize=18)\\n for i, (param_combo, grad_norms) in enumerate(gradient_norms.items()):\\n grad_norms = pd.DataFrame(grad_norms, columns=parameter_names[param_combo])\\n # Clip very small gradient norms for better log scale plotting\\n grad_norms[grad_norms < 1e-6] = 1e-6\\n ax = axes[i // 2, i % 2]\\n ax.set_title(str(param_combo), fontsize=14)\\n ax.set_xlabel(\\\"Mini-batch\\\", fontsize=12)\\n ax.set_ylabel(\\\"Gradient norm\\\", fontsize=12)\\n ax.tick_params(axis=\\\"x\\\", labelsize=10)\\n ax.tick_params(axis=\\\"y\\\", labelsize=10)\\n grad_norms.plot.line(ax=ax, figsize=(10, 5),\\n colormap=\\\"plasma_r\\\",\\n logy=True,\\n ylim=(1e-6, 1e6))\\n ax.legend(title=\\\"Depth\\\", prop={\\\"size\\\": 6}, title_fontsize=8)\\n plt.tight_layout()\\n plt.subplots_adjust(top=0.85)\\n plt.savefig(fname=plot_filepath, dpi=\\\"figure\\\", format=\\\"eps\\\")\\n plt.close()\",\n \"def gridPlot48(img_stack):\\r\\n F = plt.figure(figsize = (50,50))\\r\\n F.subplots_adjust(left = 0.05, right = 0.95)\\r\\n grid = ImageGrid(F, 142, nrows_ncols = (6,8), axes_pad = 0.0, share_all = True,\\r\\n label_mode = \\\"L\\\", cbar_location = \\\"top\\\", cbar_mode = \\\"single\\\")\\r\\n \\r\\n i = 0\\r\\n for img in img_stack[0:48]:\\r\\n im = grid[i].imshow(img, interpolation = \\\"nearest\\\", vmin = 0, vmax = 255)\\r\\n i += 1 \\r\\n grid.cbar_axes[0].colorbar(im)\\r\\n plt.savefig('gplot48.png')\\r\\n# for cax in grid.cbar_axes:\\r\\n# cax.toggle_label(False)\\r\\n return\",\n \"def EventDisplay( tubes, quantities, PMTFlatMapPositive, title=\\\"Charge\\\", cutrange=[-1,-1] ):\\n \\n fig, ax= plt.subplots(figsize=[30,30])\\n preimage = np.zeros( preimage_dimensions )\\n \\n imgmin = quantities.min()\\n imgmax = quantities.max()\\n\\n for idx, tube in enumerate( tubes ):\\n if cutrange[0] != cutrange[1]:\\n if quantities[idx] < cutrange[0] or quantities[idx] > cutrange[1]:\\n continue\\n for dx in range(-3,4):\\n for dy in range(-3,4):\\n if abs(dx)==3 and abs(dy)==3:\\n continue\\n \\n #print( \\\"idx=\\\", idx, \\\" len(quantities)=\\\",len(quantities), \\\" tube=\\\", tube, \\\" len(PMTFlatMap)=\\\", len(PMTFlatMapPositive))\\n preimage[ PMTFlatMapPositive[tube][1]+dx, PMTFlatMapPositive[tube][0]+dy ] = quantities[idx]\\n\\n if cutrange[0] != cutrange[1]:\\n imgmin = cutrange[0]\\n imgmax = cutrange[1]\\n \\n im = ax.imshow( preimage, extent = [-positive_x_offset,positive_x_offset,-lower_endcap_offset,lower_endcap_offset], vmin=imgmin, vmax=imgmax )\\n\\n fig.suptitle(title, fontsize=80)\\n\\n plt.rc('xtick', labelsize=24) \\n plt.rc('ytick', labelsize=24) \\n plt.xlabel('Distance CCW on perimeter from x-axis (cm)', fontsize=48)\\n plt.ylabel('Y (cm)', fontsize=48)\\n\\n plt.set_cmap('gist_heat_r')\\n\\n # Create colourbar\\n divider = make_axes_locatable(ax)\\n cax = divider.append_axes(\\\"right\\\", size=\\\"5%\\\", pad=0.05)\\n cbar = plt.colorbar(im, cax=cax)\\n cbar.ax.tick_params(labelsize=24)\\n\\n # Fix title height\\n plt.subplots_adjust(top=0.5)\\n plt.tight_layout()\",\n \"def show_filters(self):\\n w_mat = np.transpose(self.sess.run(self.W_fc1))\\n\\n plt.figure(figsize=(10,10), facecolor='w', edgecolor='w')\\n plot_positions = [(0,0),(0,1),(1,0),(1,1)]\\n for ch in range(self.n_input_channels):\\n grid,_ = ia.image_grid_RGB( w_mat,\\n n_channels=self.n_input_channels,\\n image_size=(self.y_res,self.x_res), n_x=6, n_y=6,\\n channel_order=(ch,ch,ch), amplitude_scaling=(1,1,1),\\n line_color=1, auto_scale=True, return_borders=False )\\n colormax = np.abs(grid).max()\\n with sns.axes_style(\\\"white\\\"):\\n ax = plt.subplot2grid( (2,2), plot_positions[ch] )\\n ax.imshow( grid[:,:,0], interpolation='nearest',\\n cmap=plt.get_cmap('seismic'),\\n clim=(-1*colormax,colormax) )\\n ax.set_title(\\\"Hidden units, channel {}\\\".format(ch))\\n plt.axis('tight')\\n plt.axis('off')\\n plt.tight_layout()\",\n \"def heatmap_plot(savefigure=False):\\n treenumber,depth = [1, 5, 10, 50, 100, 500, 1000], list(range(1,11))\\n iter_list = list(product(treenumber, depth))\\n result_list = np.load('npy-data/result_big_run.npy')\\n heat_arr = result_list.reshape((len(treenumber), len(depth)))\\n\\n fig, ax = plt.subplots(figsize=(8,8))\\n im = ax.matshow(heat_arr, cmap=plt.cm.coolwarm, vmin=.8, vmax=1)\\n divider = make_axes_locatable(ax)\\n cax = divider.append_axes(\\\"right\\\", size=\\\"5%\\\", pad=0.2)\\n\\n ax.set_xticks(np.arange(heat_arr.shape[1]))\\n ax.set_xticklabels(depth)\\n ax.set_yticks(np.arange(heat_arr.shape[0]))\\n ax.set_yticklabels(treenumber)\\n ax.set_xlim(-.5,heat_arr.shape[1]-.5)\\n ax.set_ylim(heat_arr.shape[0]-.5,-.5)\\n ax.set_xlabel(\\\"Maximum depth\\\")\\n ax.set_ylabel(\\\"Number of trees\\\")\\n ax.xaxis.set_ticks_position('bottom')\\n plt.colorbar(im, cax=cax)\\n for i, z in enumerate(heat_arr):\\n for j in range(len(z)):\\n ax.text(j, i, '{:.3f}'.format(z[j]), ha='center', va='center')\\n if savefigure:\\n plt.savefig('img/xgb_heatmap_maxdepth_n_estimators.pdf', bbox_inches='tight')\\n plt.show()\",\n \"def main(config):\\n file_paths_info = [('GLOFRIS','WATCH','ARG_inunriver_historical_000000000WATCH_1980_rp01000.tif'),\\n \\t\\t\\t\\t('GLOFRIS','RCP45','ARG_inunriver_rcp4p5_0000GFDL-ESM2M_2030_rp01000.tif'),\\n \\t\\t\\t\\t('GLOFRIS','RCP85','ARG_inunriver_rcp8p5_0000GFDL-ESM2M_2030_rp01000.tif'),\\n \\t\\t\\t\\t('FATHOM','AR_fluvial_undefended_merged','AR-FU-1000.tif'),\\n \\t\\t\\t\\t('FATHOM','AR_pluvial_undefended_merged','AR-PU-1000.tif')\\n \\t\\t\\t\\t]\\n figure_names = ['GLOFRIS-WATCH-fluvial','GLOFRIS-RCP45-fluvial','GLOFRIS-RCP85-fluvial','FATHOM-fluvial','FATHOM-pluvial']\\n figure_titles = ['current fluvial flooding','RCP4.5 fluvial flooding','RCP8.5 fluvial flooding','current fluvial flooding','current pluvial flooding']\\n for f_i in range(len(file_paths_info)):\\n\\t hazard_file = os.path.join(config['paths']['data'],'flood_data', file_paths_info[f_i][0],file_paths_info[f_i][1],file_paths_info[f_i][2])\\n\\t output_file = os.path.join(config['paths']['figures'], 'flood-map-{}.png'.format(figure_names[f_i]))\\n\\t ax = get_axes()\\n\\t plot_basemap(ax, config['paths']['data'])\\n\\t scale_bar(ax, location=(0.8, 0.05))\\n\\t plot_basemap_labels(ax, config['paths']['data'], include_regions=True,include_zorder=3)\\n\\n\\t proj_lat_lon = ccrs.PlateCarree()\\n\\n\\n\\t # Create color map\\n\\t colors = plt.get_cmap('Blues')\\n\\n\\t # Read in raster data\\n\\t data, lat_lon_extent = get_data(hazard_file)\\n\\t data[(data <= 0) | (data > 5)] = np.nan\\n\\t max_val = np.nanmax(data)\\n\\t norm=mpl.colors.Normalize(vmin=0, vmax=max_val)\\n\\n\\t # Plot population data\\n\\t im = ax.imshow(data, extent=lat_lon_extent,transform=proj_lat_lon, cmap=colors,norm =norm, zorder=2)\\n\\n\\t # Add colorbar\\n\\t cbar = plt.colorbar(im, ax=ax,fraction=0.1, shrink=0.87,pad=0.01, drawedges=False, orientation='horizontal',\\n\\t norm=mpl.colors.Normalize(vmin=0, vmax=max_val), ticks=list(np.linspace(0,max_val,3)))\\n\\t cbar.set_clim(vmin=0,vmax=max_val)\\n\\n\\n\\t cbar.outline.set_color(\\\"none\\\")\\n\\t cbar.ax.yaxis.set_tick_params(color='black')\\n\\t cbar.ax.set_xlabel('Flood depths (m)',fontsize=12,color='black')\\n\\n\\t plt.title('1 in 1000 year {}'.format(figure_titles[f_i]), fontsize = 14)\\n\\t save_fig(output_file)\\n\\t plt.close()\",\n \"def make_plots(fig_title, \\n t_csd_x, t_csd_y, t_csd_z, true_csd, \\n ele_x, ele_y, ele_z, pots,\\n k_csd_x, k_csd_y, k_csd_z, est_csd):\\n fig = plt.figure(figsize=(10,16))\\n #True CSD\\n z_steps = 5\\n height_ratios = [1 for i in range(z_steps)]\\n height_ratios.append(0.1)\\n gs = gridspec.GridSpec(z_steps+1, 3, height_ratios=height_ratios)\\n t_max = np.max(np.abs(true_csd))\\n levels = np.linspace(-1*t_max, t_max, 16)\\n ind_interest = np.mgrid[0:t_csd_z.shape[2]:np.complex(0,z_steps+2)]\\n ind_interest = np.array(ind_interest, dtype=np.int)[1:-1]\\n for ii, idx in enumerate(ind_interest):\\n ax = plt.subplot(gs[ii, 0])\\n im = plt.contourf(t_csd_x[:,:,idx], t_csd_y[:,:,idx], true_csd[:,:,idx], \\n levels=levels, cmap=cm.bwr_r)\\n ax.get_xaxis().set_visible(False)\\n ax.get_yaxis().set_visible(False)\\n title = str(t_csd_z[:,:,idx][0][0])[:4]\\n ax.set_title(label=title, fontdict={'x':0.8, 'y':0.8})\\n ax.set_aspect('equal')\\n cax = plt.subplot(gs[z_steps,0])\\n cbar = plt.colorbar(im, cax=cax, orientation='horizontal')\\n cbar.set_ticks(levels[::2])\\n cbar.set_ticklabels(np.around(levels[::2], decimals=2))\\n #Potentials\\n v_max = np.max(np.abs(pots))\\n levels_pot = np.linspace(-1*v_max, v_max, 16)\\n ele_res = int(np.ceil(len(pots)**(3**-1))) \\n ele_x = ele_x.reshape(ele_res, ele_res, ele_res)\\n ele_y = ele_y.reshape(ele_res, ele_res, ele_res)\\n ele_z = ele_z.reshape(ele_res, ele_res, ele_res)\\n pots = pots.reshape(ele_res, ele_res, ele_res)\\n for idx in range(min(5,ele_res)):\\n X,Y,Z = grid(ele_x[:,:,idx], ele_y[:,:,idx], pots[:,:,idx])\\n ax = plt.subplot(gs[idx, 1])\\n im = plt.contourf(X, Y, Z, levels=levels_pot, cmap=cm.PRGn)\\n ax.hold(True)\\n plt.scatter(ele_x[:,:,idx], ele_y[:,:,idx], 5)\\n ax.get_xaxis().set_visible(False)\\n ax.get_yaxis().set_visible(False)\\n title = str(ele_z[:,:,idx][0][0])[:4]\\n ax.set_title(label=title, fontdict={'x':0.8, 'y':0.8})\\n ax.set_aspect('equal')\\n ax.set_xlim([0.,1.])\\n ax.set_ylim([0.,1.])\\n cax = plt.subplot(gs[z_steps,1])\\n cbar2 = plt.colorbar(im, cax=cax, orientation='horizontal')\\n cbar2.set_ticks(levels_pot[::2])\\n cbar2.set_ticklabels(np.around(levels_pot[::2], decimals=2))\\n # #KCSD\\n t_max = np.max(np.abs(est_csd[:,:,:,0]))\\n levels_kcsd = np.linspace(-1*t_max, t_max, 16)\\n ind_interest = np.mgrid[0:k_csd_z.shape[2]:np.complex(0,z_steps+2)]\\n ind_interest = np.array(ind_interest, dtype=np.int)[1:-1]\\n for ii, idx in enumerate(ind_interest):\\n ax = plt.subplot(gs[ii, 2])\\n im = plt.contourf(k_csd_x[:,:,idx], k_csd_y[:,:,idx], est_csd[:,:,idx,0], \\n levels=levels_kcsd, cmap=cm.bwr_r)\\n #im = plt.contourf(k_csd_x[:,:,idx], k_csd_y[:,:,idx], est_csd[:,:,idx,0], \\n # levels=levels, cmap=cm.bwr_r)\\n ax.get_xaxis().set_visible(False)\\n ax.get_yaxis().set_visible(False)\\n title = str(k_csd_z[:,:,idx][0][0])[:4]\\n ax.set_title(label=title, fontdict={'x':0.8, 'y':0.8})\\n ax.set_aspect('equal')\\n cax = plt.subplot(gs[z_steps,2])\\n cbar3 = plt.colorbar(im, cax=cax, orientation='horizontal')\\n cbar3.set_ticks(levels_kcsd[::2])\\n #cbar3.set_ticks(levels[::2])\\n cbar3.set_ticklabels(np.around(levels_kcsd[::2], decimals=2))\\n #cbar3.set_ticklabels(np.around(levels[::2], decimals=2))\\n fig.suptitle(\\\"Lambda,R,CV_Error,RMS_Error,Time = \\\"+fig_title)\\n gs.tight_layout(fig, rect=[0, 0.03, 1, 0.95]) \\n # #Showing\\n #plt.tight_layout()\\n plt.show()\\n return\",\n \"def plot(path, subjects):\\n transformToXYZmm = np.array([[-3.125, 0, 0, 81.250], [0, 3.125, 0, -115.625], [0, 0, 6, -54.000], [0, 0, 0, 1.000]])\\n data = data_load.load_data(path, subjects)\\n dimx = int(data[0][\\\"meta\\\"][\\\"dimx\\\"][0])\\n dimy = int(data[0][\\\"meta\\\"][\\\"dimy\\\"][0])\\n dimz = int(data[0][\\\"meta\\\"][\\\"dimz\\\"][0])\\n coordToCol = data[0][\\\"meta\\\"][\\\"coordToCol\\\"][0][0]\\n images = {}\\n max_val = 0\\n voxels = np.load(\\\"data/general_selected_500_1.npy\\\")\\n directory = os.listdir(\\\"data/input/\\\")\\n bar = pyprind.ProgBar(len(directory), title='Info extraction and Image Building')\\n bar2 = pyprind.ProgBar(len(images.keys()), title='Saving Pictures')\\n for file in directory:\\n file_name = \\\"data/input/{}\\\".format(file)\\n fh = open(file_name)\\n activation_values = np.asarray(list(map(lambda x: float(x), filter(lambda x: x != '', fh.read().split(\\\",\\\")))))\\n fh.close()\\n plot_matrix = np.zeros((dimx, dimy, dimz))\\n for x in range(dimx):\\n for y in range(dimy):\\n for z in range(dimz):\\n indice = coordToCol[x][y][z]\\n if indice != 0:\\n if indice in list(voxels):\\n voxel_indice = list(voxels).index(indice)\\n value = activation_values[voxel_indice]\\n if abs(value) > max_val:\\n max_val = abs(value)\\n plot_matrix[x][y][z] = value\\n image = nib.Nifti1Image(plot_matrix, transformToXYZmm)\\n images[file_name] = image\\n bar.update(force_flush=True)\\n print(bar)\\n for image in images:\\n plotting.plot_glass_brain(images[image], display_mode='ortho', vmax=max_val, plot_abs=False, threshold=None, colorbar=True, output_file=\\\"{}-wom1.png\\\".format(image))\\n bar2.update(force_flush=True)\\n print(bar2)\",\n \"def plot_2d_results(model):\\n\\n # Create the figure\\n fig, ax = newfig(1.5, 1.5)\\n ax.axis('off')\\n gs = gridspec.GridSpec(3, 3)\\n gs.update(top=0.8, bottom=0.2, left=0.1, right=0.9, wspace=0.7, hspace=0.7)\\n\\n # Loop to plot different slices of the Green's function\\n for i in range(2):\\n for j in range(2):\\n # Evaluate the Green's function network\\n input_data, shape_Green, axis_limit, axis_labels = input_data_slice(\\n model, Green_slice=2 * i + j + 1)\\n G_pred_identifier = model.sess.run(\\n model.G_network[0][0].evaluate(input_data))\\n G_pred = G_pred_identifier.reshape(shape_Green)\\n ax = plt.subplot(gs[i, j])\\n h = ax.imshow(G_pred, interpolation='lanczos', cmap='jet',\\n extent=axis_limit,\\n origin='lower', aspect='auto')\\n divider = make_axes_locatable(ax)\\n cax = divider.append_axes(\\\"right\\\", size=\\\"5%\\\", pad=0.05)\\n fig.colorbar(h, cax=cax)\\n ax.set_xlabel(axis_labels[0])\\n ax.set_ylabel(axis_labels[1], rotation=0, labelpad=12)\\n ax.set_title('$G$%s' % (axis_labels[2]), fontsize=10)\\n\\n # Get axis limit\\n x1min = np.min(model.x_G)\\n x1max = np.max(model.x_G)\\n x2min = np.min(model.y_G)\\n x2max = np.max(model.y_G)\\n\\n # Exact Homogeneous solution\\n ax = plt.subplot(gs[0, 2])\\n X_G, Y_G = np.meshgrid(model.x_G, model.y_G)\\n x1 = X_G.flatten()[:, None]\\n x2 = Y_G.flatten()[:, None]\\n U_hom = np.transpose(model.U_hom.reshape(\\n (model.y_G.shape[0], model.x_G.shape[0])))\\n h = ax.imshow(U_hom, interpolation='lanczos', cmap='jet',\\n extent=[x1min, x1max, x2min, x2max],\\n origin='lower', aspect='auto')\\n divider = make_axes_locatable(ax)\\n cax = divider.append_axes(\\\"right\\\", size=\\\"5%\\\", pad=0.05)\\n fig.colorbar(h, cax=cax)\\n ax.set_xlabel('$x$')\\n ax.set_ylabel('$y$', rotation=0, labelpad=12)\\n ax.set_title('Exact Hom', fontsize=10)\\n\\n # Learned Homogeneous solution\\n ax = plt.subplot(gs[1, 2])\\n input_data = np.concatenate((x1, x2), 1).astype(dtype=config.real(np))\\n N_pred_identifier = model.sess.run(\\n model.idn_N_pred[0].evaluate(input_data))\\n N_pred = N_pred_identifier.reshape(X_G.shape)\\n h = ax.imshow(N_pred, interpolation='lanczos', cmap='jet',\\n extent=[x1min, x1max, x2min, x2max],\\n origin='lower', aspect='auto')\\n divider = make_axes_locatable(ax)\\n cax = divider.append_axes(\\\"right\\\", size=\\\"5%\\\", pad=0.05)\\n fig.colorbar(h, cax=cax)\\n ax.set_xlabel('$x$')\\n ax.set_ylabel('$y$', rotation=0, labelpad=12)\\n ax.set_title('Learned Hom', fontsize=10)\\n\\n # Save the figure\\n savefig(\\\"%s/%s_%s\\\" % (model.path_result, model.example_name,\\n model.activation_name), crop=False)\",\n \"def plot_spatial_res(data_obj, test_num):\\n\\n #---------------------------------------------------------------------------------------------#\\n # Go through each file [image] and plot the spatial resolution ROI images and MTF data graphs #\\n #---------------------------------------------------------------------------------------------#\\n for i in range(len(data_obj.files)):\\n\\n fig = new_pdf_page(data_obj.pdf_obj) #Create a new pdf page\\n plt.axis('off')\\n\\n # Create and plot the (centered) title of the page - that also states the MTF20 values\\n str1 = 'Test ' + str(test_num) + ': Spatial Resolution \\\\n' + \\\\\\n 'MTF20x = ' + \\\"{0:.2f}\\\".format(data_obj.MTF_data.MTF20_x) + \\\\\\n '\\\\n MTF20y = ' + \\\"{0:.2f}\\\".format(data_obj.MTF_data.MTF20_y)\\n plt.suptitle(str1)\\n\\n #-----------------------------------------------#\\n # Plot the main image in the middle of the page #\\n #-----------------------------------------------#\\n ax1 = fig.add_subplot(312)\\n plt.imshow(data_obj.img_data[i].lead_foil_ROI.img) #Display the ROI image of the lead foil\\n\\n # Display the title of the ROI image - the orientation\\n plt.title('Orientation ' + str(data_obj.img_data[i].orientation))\\n plt.xticks([]) # labels\\n plt.yticks([])\\n ax = plt.gca()\\n ax.xaxis.set_ticks_position('none') # tick markers\\n ax.yaxis.set_ticks_position('none')\\n\\n if data_obj.img_data[i].orientation % 2 == 1:\\n plt.xlabel('x axis')\\n plt.ylabel('y axis')\\n else:\\n plt.xlabel('y axis')\\n plt.ylabel('x axis')\\n\\n #-----------------------------#\\n # Display the Horizontal plot #\\n #-----------------------------#\\n ax2 = fig.add_subplot(325)\\n plt.ylabel('MTFx')\\n plt.xlabel('Spatial frequency (cycles/mm)')\\n plt.plot(data_obj.img_data[i].MTF_obj.MTF_x_f, data_obj.img_data[i].MTF_obj.MTF_x)\\n text = 'MTF20x = ' + \\\"{0:.2f}\\\".format(data_obj.img_data[i].MTF_obj.MTF20_x)\\n\\n ax2.annotate(text,\\n xy=(data_obj.img_data[i].MTF_obj.MTF20_x, 0.2),\\n xytext=(np.max(data_obj.img_data[i].MTF_obj.MTF_x_f), 0.7),\\n arrowprops=dict(facecolor='black', shrink=0.05, width=0.5, headwidth=4),\\n horizontalalignment='right')\\n\\n #---------------#\\n # Vertical plot #\\n #---------------#\\n ax3 = fig.add_subplot(326)\\n plt.ylabel('MTFy')\\n plt.xlabel('Spatial frequency (cycles/mm)')\\n plt.plot(data_obj.img_data[i].MTF_obj.MTF_y_f, data_obj.img_data[i].MTF_obj.MTF_y)\\n text = 'MTF20y = ' + \\\"{0:.2f}\\\".format(data_obj.img_data[i].MTF_obj.MTF20_y)\\n\\n ax3.annotate(text,\\n xy=(data_obj.img_data[i].MTF_obj.MTF20_y, 0.2),\\n xytext=(np.max(data_obj.img_data[i].MTF_obj.MTF_y_f), 0.7),\\n arrowprops=dict(facecolor='black', shrink=0.05, width=0.5, headwidth=4),\\n horizontalalignment='right')\",\n \"def show_lanes(self, images, cols = 2, rows = 4, figsize=(15,13)):\\n fig, axes = plt.subplots(rows, cols, figsize=figsize)\\n indexes = range(cols * rows)\\n self.fits = []\\n self.fits_curve = []\\n for ax, idx in zip(axes.flat, indexes):\\n if idx < len(images):\\n image = images[idx]\\n left_fit, right_fit, left_fit_curve, right_fit_curve = self.plot_lanes(image, ax)\\n self.fits.append((left_fit, right_fit))\\n self.fits_curve.append((left_fit_curve, right_fit_curve))\",\n \"def plot_grid(information,\\n var_to_plot,\\n vmin,\\n vmax,\\n xmin,\\n xmax,\\n ymin,\\n ymax,\\n file_name,\\n c_scheme,\\n yax_shift,\\n subplot):\\n\\n grain_type = True if \\\"grain type\\\" in var_to_plot else False\\n\\n grid = information['grid']\\n dates = information['dates']\\n\\n # Make the plot\\n\\n if subplot:\\n ax = subplot\\n else:\\n fig, ax = plt.subplots(1 ,1 ,figsize=(10 ,6))\\n\\n # Specify the colormap\\n\\n if grain_type:\\n my_cmap = grain_type_colormap()\\n grid = transform_grid_for_grain_type(grid)\\n else:\\n my_cmap = plt.get_cmap(c_scheme)\\n\\n\\n # Set the limits of the plot\\n\\n x_lims = mdates.date2num([dates[0] ,dates[-1]])\\n if xmin and xmax:\\n x_lims_specified = mdates.date2num([xmin, xmax])\\n # for spec in x_lims_specified:\\n # assert (x_lims[0] < spec < x_lims[1])\\n x_lims = x_lims_specified\\n\\n if ymin and ymax:\\n information['min_height'] = ymin\\n information['max_height'] = ymax\\n\\n extent = [x_lims[0],\\n x_lims[1] ,\\n information['min_height'] - yax_shift,\\n information['max_height'] - yax_shift]\\n\\n ax.xaxis_date()\\n date_format = mdates.DateFormatter('%m/%d')\\n ax.xaxis.set_major_formatter(date_format)\\n\\n #######################\\n\\n im = ax.imshow(grid,\\n extent= extent,\\n aspect='auto',\\n vmin=vmin ,vmax=vmax,\\n cmap=my_cmap)\\n\\n\\n ax.tick_params(right=True)\\n\\n ax.set_ylabel('Height (cm)', fontsize='x-large')\\n\\n if subplot:\\n return ax\\n else:\\n\\n cbar = fig.colorbar(im, ax=ax, pad=0.075)\\n\\n if grain_type: cbar.ax.set_yticklabels(get_grain_tick_labels())\\n else: cbar.set_label(var_to_plot, fontsize='x-large')\\n\\n\\n if file_name:\\n fig.savefig(file_name ,dpi=500, bbox_inches='tight')\\n\\n plt.show()\\n\\n return 0\",\n \"def plot_results(models,\\n data,\\n batch_size=128,\\n model_name=None):\\n\\n encoder, decoder = models\\n x_test, y_test = data\\n # display a 2D plot of the digit classes in the latent space\\n z_mean = encoder(x_test)\\n plt.figure(figsize=(12, 10))\\n plt.scatter(z_mean[:, 0], z_mean[:, 1], c=y_test)\\n plt.colorbar()\\n plt.xlabel(\\\"z[0]\\\")\\n plt.ylabel(\\\"z[1]\\\")\\n \\n plt.show()\\n if not model_name is None:\\n os.makedirs(model_name, exist_ok=True)\\n filename = os.path.join(model_name, \\\"vae_mean.png\\\")\\n plt.savefig(filename)\\n filename = os.path.join(model_name, \\\"digits_over_latent.png\\\")\\n # display a 30x30 2D manifold of digits\\n n = 30\\n digit_size = 28\\n figure = np.zeros((digit_size * n, digit_size * n))\\n # linearly spaced coordinates corresponding to the 2D plot\\n # of digit classes in the latent space\\n grid_x = np.linspace(-4, 4, n)\\n grid_y = np.linspace(-4, 4, n)[::-1]\\n\\n for i, yi in enumerate(grid_y):\\n for j, xi in enumerate(grid_x):\\n z_sample = np.array([[xi, yi]])\\n x_decoded = decoder(z_sample)\\n digit = x_decoded[0].reshape(digit_size, digit_size)\\n figure[i * digit_size: (i + 1) * digit_size,\\n j * digit_size: (j + 1) * digit_size] = digit\\n\\n plt.figure(figsize=(10, 10))\\n start_range = digit_size // 2\\n end_range = n * digit_size + start_range + 1\\n pixel_range = np.arange(start_range, end_range, digit_size)\\n sample_range_x = np.round(grid_x, 1)\\n sample_range_y = np.round(grid_y, 1)\\n plt.xticks(pixel_range, sample_range_x)\\n plt.yticks(pixel_range, sample_range_y)\\n plt.xlabel(\\\"z[0]\\\")\\n plt.ylabel(\\\"z[1]\\\")\\n plt.imshow(figure, cmap='Greys_r')\\n if not model_name is None:\\n plt.savefig(filename)\\n plt.show()\",\n \"def run(self):\\n # fill the x_values,y_values,z_values dictionaries\\n if not self.__fillCoordinatesFromSource():\\n self.raiseAWarning('Nothing to Plot Yet. Returning.')\\n return\\n\\n self.counter += 1\\n if self.counter > 1:\\n self.actcm = None\\n clusterDict = deepcopy(self.outStreamTypes)\\n\\n # start plotting.... loop over the plots that need to be included in this figure\\n for pltIndex in range(len(self.outStreamTypes)):\\n plotSettings = self.options['plotSettings']['plot'][pltIndex]\\n if 'gridLocation' in plotSettings:\\n x = None\\n y = None\\n if 'x' in plotSettings['gridLocation']:\\n x = list(map(int, plotSettings['gridLocation']['x'].strip().split(' ')))\\n else:\\n x = None\\n if 'y' in plotSettings['gridLocation'].keys():\\n y = list(map(int, plotSettings['gridLocation']['y'].strip().split(' ')))\\n else:\\n y = None\\n if pltIndex == 0:\\n self.ax.remove() # remove axis so that there is not an extra axis on plot with subplots\\n if (len(x) == 1 and len(y) == 1):\\n if self.dim == 2:\\n self.ax = self.fig.add_subplot(self.gridSpace[x[0], y[0]])\\n else:\\n self.ax = self.fig.add_subplot(self.gridSpace[x[0], y[0]], projection='3d')\\n elif (len(x) == 1 and len(y) != 1):\\n if self.dim == 2:\\n self.ax = self.fig.add_subplot(self.gridSpace[x[0], y[0]:y[-1]])\\n else:\\n self.ax = self.fig.add_subplot(self.gridSpace[x[0], y[0]:y[-1]], projection='3d')\\n elif (len(x) != 1 and len(y) == 1):\\n if self.dim == 2:\\n self.ax = self.fig.add_subplot(self.gridSpace[x[0]:x[-1], y[0]])\\n else:\\n self.ax = self.fig.add_subplot(self.gridSpace[x[0]:x[-1], y[0]], projection='3d')\\n else:\\n if self.dim == 2:\\n self.ax = self.fig.add_subplot(self.gridSpace[x[0]:x[-1], y[0]:y[-1]])\\n else:\\n self.ax = self.fig.add_subplot(self.gridSpace[x[0]:x[-1], y[0]:y[-1]], projection='3d')\\n\\n if 'gridSpace' in self.options['plotSettings']:\\n self.ax.locator_params(axis='y', nbins=4)\\n self.ax.locator_params(axis='x', nbins=2)\\n if 'range' in plotSettings:\\n axes_range = plotSettings['range']\\n if 'ymin' in axes_range:\\n self.ax.set_ylim(bottom=ast.literal_eval(axes_range['ymin']))\\n if 'ymax' in axes_range:\\n self.ax.set_ylim(top=ast.literal_eval(axes_range['ymax']))\\n if 'xmin' in axes_range:\\n self.ax.set_xlim(left=ast.literal_eval(axes_range['xmin']))\\n if 'xmax' in axes_range:\\n self.ax.set_xlim(right=ast.literal_eval(axes_range['xmax']))\\n if self.dim == 3:\\n if 'zmin' in axes_range.options['plotSettings']['plot'][pltIndex]:\\n if 'zmax' not in axes_range.options['plotSettings']:\\n self.raiseAWarning('zmin inputted but not zmax. zmin ignored! ')\\n else:\\n self.ax.set_zlim(bottom=ast.literal_eval(axes_range['zmin']), top=ast.literal_eval(self.options['plotSettings']['zmax']))\\n if 'zmax' in axes_range:\\n if 'zmin' not in axes_range:\\n self.raiseAWarning('zmax inputted but not zmin. zmax ignored! ')\\n else:\\n self.ax.set_zlim(bottom=ast.literal_eval(axes_range['zmin']), top=ast.literal_eval(axes_range['zmax']))\\n if 'xlabel' not in plotSettings:\\n self.ax.set_xlabel('x')\\n else:\\n self.ax.set_xlabel(plotSettings['xlabel'])\\n if 'ylabel' not in plotSettings:\\n self.ax.set_ylabel('y')\\n else:\\n self.ax.set_ylabel(plotSettings['ylabel'])\\n if 'zlabel' in plotSettings:\\n if self.dim == 2:\\n self.raiseAWarning('zlabel keyword does not make sense in 2-D Plots!')\\n elif self.dim == 3 and self.zCoordinates:\\n self.ax.set_zlabel(plotSettings['zlabel'])\\n elif self.dim == 3 and self.zCoordinates:\\n self.ax.set_zlabel('z')\\n else:\\n if 'xlabel' not in self.options['plotSettings']:\\n self.ax.set_xlabel('x')\\n else:\\n self.ax.set_xlabel(self.options['plotSettings']['xlabel'])\\n if 'ylabel' not in self.options['plotSettings']:\\n self.ax.set_ylabel('y')\\n else:\\n self.ax.set_ylabel(self.options['plotSettings']['ylabel'])\\n if 'zlabel' in self.options['plotSettings']:\\n if self.dim == 2:\\n self.raiseAWarning('zlabel keyword does not make sense in 2-D Plots!')\\n elif self.dim == 3 and self.zCoordinates:\\n self.ax.set_zlabel(self.options['plotSettings']['zlabel'])\\n elif self.dim == 3 and self.zCoordinates:\\n self.ax.set_zlabel('z')\\n\\n if 'legend' in self.options['plotSettings']:\\n if 'label' not in plotSettings.get('attributes', {}):\\n if 'attributes' not in plotSettings:\\n plotSettings['attributes'] = {}\\n plotSettings['attributes']['label'] = self.outStreamTypes[pltIndex] + ' ' + str(pltIndex)\\n #################\\n # SCATTER PLOT #\\n #################\\n self.raiseADebug(f'creating plot {self.name}')\\n if self.outStreamTypes[pltIndex] == 'scatter':\\n if 's' not in plotSettings:\\n plotSettings['s'] = '20'\\n if 'c' not in plotSettings:\\n plotSettings['c'] = 'b'\\n if 'marker' not in plotSettings:\\n plotSettings['marker'] = 'o'\\n if 'alpha' not in plotSettings:\\n plotSettings['alpha'] = 'None'\\n if 'linewidths' not in plotSettings:\\n plotSettings['linewidths'] = 'None'\\n if self.colorMapCoordinates[pltIndex] is not None:\\n # Find the max and min colormap values\\n firstKey = utils.first(self.xValues[pltIndex].keys())\\n vmin = np.amin(self.colorMapValues[pltIndex][firstKey])\\n vmax = np.amax(self.colorMapValues[pltIndex][firstKey])\\n for key in self.xValues[pltIndex]:\\n vmin = min(vmin,np.amin(self.colorMapValues[pltIndex][key]))\\n vmax = max(vmax,np.amax(self.colorMapValues[pltIndex][key]))\\n plotSettings['norm'] = matplotlib.colors.Normalize(vmin,vmax)\\n for key in self.xValues[pltIndex]:\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n scatterPlotOptions = {'s': ast.literal_eval(plotSettings['s']),\\n 'marker': (plotSettings['marker']),\\n 'alpha': ast.literal_eval(plotSettings['alpha']),\\n 'linewidths': ast.literal_eval(plotSettings['linewidths'])}\\n if self.colorMapCoordinates[pltIndex] is not None:\\n scatterPlotOptions['norm'] = plotSettings['norm']\\n scatterPlotOptions.update(plotSettings.get('attributes', {}))\\n if self.dim == 2:\\n if self.colorMapCoordinates[pltIndex] is not None:\\n scatterPlotOptions['c'] = self.colorMapValues[pltIndex][key][xIndex]\\n scatterPlotOptions['cmap'] = matplotlib.cm.get_cmap(\\\"winter\\\")\\n if self.actcm:\\n first = False\\n else:\\n first = True\\n if plotSettings['cmap'] == 'None':\\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n **scatterPlotOptions)\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n if first:\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_array(self.colorMapValues[pltIndex][key])\\n self.actcm = self.fig.colorbar(m)\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n try:\\n self.actcm.draw_all()\\n # this is not good, what exception will be thrown?\\n except:\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_array(self.colorMapValues[pltIndex][key])\\n self.actcm = self.fig.colorbar(m)\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n scatterPlotOptions['cmap'] = plotSettings['cmap']\\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n **scatterPlotOptions)\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n if first:\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_array(self.colorMapValues[pltIndex][key])\\n self.actcm = self.fig.colorbar(m, ax=self.ax)\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_clim(vmin = min(self.colorMapValues[pltIndex][key][-1]), vmax=max(self.colorMapValues[pltIndex][key][-1]))\\n self.actcm.draw_all()\\n else:\\n if 'color' not in scatterPlotOptions:\\n scatterPlotOptions['c'] = plotSettings['c']\\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n **scatterPlotOptions)\\n else:\\n for zIndex in range(len(self.zValues[pltIndex][key])):\\n if self.colorMapCoordinates[pltIndex] is not None:\\n scatterPlotOptions['c'] = self.colorMapValues[pltIndex][key][zIndex]\\n if self.actcm:\\n first = False\\n else:\\n first = True\\n if plotSettings['cmap'] == 'None':\\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], self.zValues[pltIndex][key][zIndex], **scatterPlotOptions)\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n if first:\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_array(self.colorMapValues[pltIndex][key])\\n self.actcm = self.fig.colorbar(m)\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n self.actcm.draw_all()\\n else:\\n scatterPlotOptions['cmap'] = plotSettings['cmap']\\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], self.zValues[pltIndex][key][zIndex], **scatterPlotOptions)\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n if first:\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_array(self.colorMapValues[pltIndex][key])\\n self.actcm = self.fig.colorbar(m)\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n m = matplotlib.cm.ScalarMappable(cmap = self.actPlot.cmap, norm = self.actPlot.norm)\\n m.set_clim(vmin = min(self.colorMapValues[pltIndex][key][-1]), vmax=max(self.colorMapValues[pltIndex][key][-1]))\\n self.actcm.draw_all()\\n else:\\n if 'color' not in scatterPlotOptions:\\n scatterPlotOptions['c'] = plotSettings['c']\\n self.actPlot = self.ax.scatter(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], self.zValues[pltIndex][key][zIndex], **scatterPlotOptions)\\n #################\\n # LINE PLOT #\\n #################\\n elif self.outStreamTypes[pltIndex] == 'line':\\n minV = 0\\n maxV = 0\\n # If the user does not define an appropriate cmap, then use matplotlib's default.\\n if 'cmap' not in plotSettings or plotSettings['cmap'] not in matplotlib.cm.datad:\\n plotSettings['cmap'] = None\\n if bool(self.colorMapValues):\\n for key in self.xValues[pltIndex]:\\n minV = min(minV,self.colorMapValues[pltIndex][key][-1][-1])\\n maxV = max(maxV,self.colorMapValues[pltIndex][key][-1][-1])\\n cmap = matplotlib.cm.ScalarMappable(matplotlib.colors.Normalize(minV, maxV, True), plotSettings['cmap'])\\n cmap.set_array([minV,maxV])\\n for key in self.xValues[pltIndex]:\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n if self.colorMapCoordinates[pltIndex] is not None:\\n plotSettings['interpPointsX'] = str(max(200, len(self.xValues[pltIndex][key][xIndex])))\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n if self.dim == 2:\\n if self.yValues[pltIndex][key][yIndex].size < 2:\\n return\\n xi, yi = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], plotSettings, returnCoordinate=True)\\n if self.colorMapCoordinates[pltIndex] is not None:\\n self.ax.plot(xi, yi, c=cmap.cmap(self.colorMapValues[pltIndex][key][-1][-1]/(maxV-minV)))\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n if self.actcm is None:\\n self.actcm = self.fig.colorbar(cmap)\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n self.actcm.draw_all()\\n else:\\n self.actPlot = self.ax.plot(xi, yi, **plotSettings.get('attributes', {}))\\n else:\\n for zIndex in range(len(self.zValues[pltIndex][key])):\\n if self.zValues[pltIndex][key][zIndex].size <= 3:\\n return\\n if self.colorMapCoordinates[pltIndex] is not None:\\n self.ax.plot(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n self.zValues[pltIndex][key][zIndex],\\n c=cmap.cmap(self.colorMapValues[pltIndex][key][-1][-1]/(maxV-minV)))\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n if self.actcm is None:\\n self.actcm = self.fig.colorbar(cmap)\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n self.actcm.draw_all()\\n else:\\n self.actPlot = self.ax.plot(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n self.zValues[pltIndex][key][zIndex],\\n **plotSettings.get('attributes', {}))\\n ##################\\n # HISTOGRAM PLOT #\\n ##################\\n elif self.outStreamTypes[pltIndex] == 'histogram':\\n if 'bins' not in plotSettings:\\n if self.dim == 2:\\n plotSettings['bins'] = '10'\\n else:\\n plotSettings['bins'] = '4'\\n if 'normed' not in plotSettings:\\n plotSettings['normed'] = 'False'\\n if 'weights' not in plotSettings:\\n plotSettings['weights'] = 'None'\\n if 'cumulative' not in plotSettings:\\n plotSettings['cumulative'] = 'False'\\n if 'histtype' not in plotSettings:\\n plotSettings['histtype'] = 'bar'\\n if 'align' not in plotSettings:\\n plotSettings['align'] = 'mid'\\n if 'orientation' not in plotSettings:\\n plotSettings['orientation'] = 'vertical'\\n if 'rwidth' not in plotSettings:\\n plotSettings['rwidth'] = 'None'\\n if 'log' not in plotSettings:\\n plotSettings['log'] = 'None'\\n if 'color' not in plotSettings:\\n plotSettings['color'] = 'b'\\n if 'stacked' not in plotSettings:\\n plotSettings['stacked'] = 'None'\\n if self.sourceData[0].type.strip() == 'HistorySet':\\n #####################################################################################################################################\\n # @MANDD: This 'if' condition has been added in order to allow the user the correctly create an histogram out of an historySet #\\n # If the histogram is created out of the input variables, then the plot has an identical meaning of the one generated by a pointSet #\\n # However, if the histogram is created out of the output variables, then the plot consider only the last value of the array #\\n #####################################################################################################################################\\n data = {}\\n data['x'] = np.empty(0)\\n data['y'] = np.empty(0)\\n for index in range(len(self.outStreamTypes)):\\n for key in self.xValues[index]:\\n data['x'] = np.append(data['x'], self.xValues[index][key][0][-1])\\n if self.dim == 3:\\n data['y'] = np.append(data['y'], self.yValues[index][key][0][-1])\\n del self.xValues[index]\\n self.xValues = {}\\n self.xValues[index] = {}\\n self.xValues[index][0] = []\\n self.xValues[index][0].append(deepcopy(data['x']))\\n if self.dim == 3:\\n del self.yValues[index]\\n self.yValues = {}\\n self.yValues[index] ={ }\\n self.yValues[index][0] = []\\n self.yValues[index][0].append(deepcopy(data['y']))\\n\\n for key in self.xValues[pltIndex]:\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n try:\\n colorss = ast.literal_eval(plotSettings['color'])\\n # unknown what specific error is anticipated here, but I don't like a bare except...\\n # ast.literal_eval can raise the exceptions listed below (see library docs):\\n except (ValueError, TypeError, SyntaxError, MemoryError, RecursionError):\\n colorss = plotSettings['color']\\n if self.dim == 2:\\n self.ax.hist(self.xValues[pltIndex][key][xIndex],\\n bins=ast.literal_eval(plotSettings['bins']),\\n density=ast.literal_eval(plotSettings['normed']),\\n weights=ast.literal_eval(plotSettings['weights']),\\n cumulative=ast.literal_eval(plotSettings['cumulative']),\\n histtype=plotSettings['histtype'],\\n align=plotSettings['align'],\\n orientation=plotSettings['orientation'],\\n rwidth=ast.literal_eval(plotSettings['rwidth']),\\n log=ast.literal_eval(plotSettings['log']),\\n color=colorss,\\n stacked=ast.literal_eval(plotSettings['stacked']),\\n **plotSettings.get('attributes', {}))\\n else:\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n hist, xedges, yedges = np.histogram2d(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n bins=ast.literal_eval(plotSettings['bins']))\\n elements = (len(xedges) - 1) * (len(yedges) - 1)\\n if 'x_offset' in plotSettings:\\n xoffset = float(plotSettings['x_offset'])\\n else:\\n xoffset = 0.25\\n if 'y_offset' in plotSettings:\\n yoffset = float(plotSettings['y_offset'])\\n else:\\n yoffset = 0.25\\n if 'dx' in plotSettings:\\n dxs = float(plotSettings['dx'])\\n else:\\n dxs = (self.xValues[pltIndex][key][xIndex].max() - self.xValues[pltIndex][key][xIndex].min()) / float(plotSettings['bins'])\\n if 'dy' in plotSettings:\\n dys = float(plotSettings['dy'])\\n else:\\n dys = (self.yValues[pltIndex][key][yIndex].max() - self.yValues[pltIndex][key][yIndex].min()) / float(plotSettings['bins'])\\n xpos, ypos = np.meshgrid(xedges[:-1] + xoffset, yedges[:-1] + yoffset)\\n self.actPlot = self.ax.bar3d(xpos.flatten(),\\n ypos.flatten(),\\n np.zeros(elements),\\n dxs*np.ones_like(elements),\\n dys*np.ones_like(elements),\\n hist.flatten(),\\n color=colorss,\\n zsort='average',\\n **plotSettings.get('attributes', {}))\\n ##################\\n # STEM PLOT #\\n ##################\\n elif self.outStreamTypes[pltIndex] == 'stem':\\n if 'linefmt' not in plotSettings:\\n plotSettings['linefmt'] = 'b-'\\n if 'markerfmt' not in plotSettings:\\n plotSettings['markerfmt'] = 'bo'\\n if 'basefmt' not in plotSettings:\\n plotSettings['basefmt'] = 'r-'\\n for key in self.xValues[pltIndex]:\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n if self.dim == 2:\\n self.actPlot = self.ax.stem(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n linefmt=plotSettings['linefmt'],\\n markerfmt=plotSettings['markerfmt'],\\n basefmt = plotSettings['linefmt'],\\n use_line_collection=True,\\n **plotSettings.get('attributes', {}))\\n else:\\n # it is a basic stem plot constructed using a standard line plot. For now we do not use the previous defined keywords...\\n for zIndex in range(len(self.zValues[pltIndex][key])):\\n for xx, yy, zz in zip(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], self.zValues[pltIndex][key][zIndex]):\\n self.ax.plot([xx, xx], [yy, yy], [0, zz], '-')\\n ##################\\n # STEP PLOT #\\n ##################\\n elif self.outStreamTypes[pltIndex] == 'step':\\n if self.dim == 2:\\n if 'where' not in plotSettings:\\n plotSettings['where'] = 'mid'\\n for key in self.xValues[pltIndex]:\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n if self.xValues[pltIndex][key][xIndex].size < 2:\\n xi = self.xValues[pltIndex][key][xIndex]\\n else:\\n xi = np.linspace(self.xValues[pltIndex][key][xIndex].min(), self.xValues[pltIndex][key][xIndex].max(), ast.literal_eval(plotSettings['interpPointsX']))\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n if self.yValues[pltIndex][key][yIndex].size <= 3:\\n return\\n yi = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex], self.yValues[pltIndex][key][yIndex], plotSettings)\\n self.actPlot = self.ax.step(xi, yi, where=plotSettings['where'], **plotSettings.get('attributes', {}))\\n else:\\n self.raiseAWarning('step Plot not available in 3D')\\n return\\n ########################\\n # PSEUDOCOLOR PLOT #\\n ########################\\n elif self.outStreamTypes[pltIndex] == 'pseudocolor':\\n if self.dim == 2:\\n for key in self.xValues[pltIndex]:\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n # Hopefully, x,y, and z are all the same length, so checking this\\n # here should be good enough.\\n # The problem is you cannot interpolate any amount of space if\\n # you only have a single data point.\\n if self.xValues[pltIndex][key][xIndex].size == 1:\\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\\n continue\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n if not self.colorMapCoordinates:\\n self.raiseAMessage('pseudocolor Plot needs coordinates for color map... Returning without plotting')\\n return\\n for zIndex in range(len(self.colorMapValues[pltIndex][key])):\\n if self.colorMapValues[pltIndex][key][zIndex].size <= 3:\\n return\\n xig, yig, Ci = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n plotSettings,\\n z=self.colorMapValues[pltIndex][key][zIndex],\\n returnCoordinate=True)\\n if plotSettings['cmap'] == 'None':\\n self.actPlot = self.ax.pcolormesh(xig,\\n yig,\\n ma.masked_where(np.isnan(Ci), Ci),\\n **plotSettings.get('attributes', {}))\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n else:\\n self.actPlot = self.ax.pcolormesh(xig,\\n yig,\\n ma.masked_where(np.isnan(Ci), Ci),\\n cmap=matplotlib.cm.get_cmap(name = plotSettings['cmap']),\\n **plotSettings.get('attributes', {}))\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_array(ma.masked_where(np.isnan(Ci), Ci))\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n actcm = self.fig.colorbar(m)\\n actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n self.raiseAWarning('pseudocolor Plot is considered a 2D plot, not a 3D!')\\n return\\n ########################\\n # SURFACE PLOT #\\n ########################\\n elif self.outStreamTypes[pltIndex] == 'surface':\\n if self.dim == 2:\\n self.raiseAWarning('surface Plot is NOT available for 2D plots, IT IS A 3D!')\\n return\\n else:\\n if 'rstride' not in plotSettings:\\n plotSettings['rstride'] = '1'\\n if 'cstride' not in plotSettings:\\n plotSettings['cstride'] = '1'\\n if 'antialiased' not in plotSettings:\\n plotSettings['antialiased'] = 'False'\\n if 'linewidth' not in plotSettings:\\n plotSettings['linewidth'] = '0'\\n for key in self.xValues[pltIndex]:\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n # Hopefully, x,y, and z are all the same length, so checking this\\n # here should be good enough.\\n # The problem is you cannot interpolate any amount of space if\\n # you only have a single data point.\\n if self.xValues[pltIndex][key][xIndex].size == 1:\\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\\n continue\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n for zIndex in range(len(self.zValues[pltIndex][key])):\\n if self.zValues[pltIndex][key][zIndex].size <= 3:\\n return\\n if self.colorMapCoordinates[pltIndex] is not None:\\n xig, yig, Ci = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n plotSettings,\\n z=self.colorMapValues[pltIndex][key][zIndex],\\n returnCoordinate=True)\\n xig, yig, zi = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n plotSettings,\\n z=self.zValues[pltIndex][key][zIndex],\\n returnCoordinate=True)\\n if self.colorMapCoordinates[pltIndex] is not None:\\n if self.actcm:\\n first = False\\n else:\\n first = True\\n if plotSettings['cmap'] == 'None':\\n plotSettings['cmap'] = 'jet'\\n self.actPlot = self.ax.plot_surface(xig,\\n yig,\\n ma.masked_where(np.isnan(zi), zi),\\n rstride=ast.literal_eval(plotSettings['rstride']),\\n cstride=ast.literal_eval(plotSettings['cstride']),\\n facecolors=matplotlib.cm.get_cmap(name=plotSettings['cmap'])(ma.masked_where(np.isnan(Ci), Ci)),\\n cmap=matplotlib.cm.get_cmap(name = plotSettings['cmap']),\\n linewidth=ast.literal_eval(plotSettings['linewidth']),\\n antialiased=ast.literal_eval(plotSettings['antialiased']),\\n **plotSettings.get('attributes', {}))\\n if first:\\n self.actPlot.cmap = matplotlib.cm.get_cmap(name=plotSettings['cmap'])\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n if first:\\n m = matplotlib.cm.ScalarMappable(cmap = self.actPlot.cmap, norm = self.actPlot.norm)\\n m.set_array(self.colorMapValues[pltIndex][key])\\n self.actcm = self.fig.colorbar(m)\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_clim(vmin=min(self.colorMapValues[pltIndex][key][-1]), vmax=max(self.colorMapValues[pltIndex][key][-1]))\\n self.actcm.draw_all()\\n else:\\n if plotSettings['cmap'] == 'None':\\n self.actPlot = self.ax.plot_surface(xig,\\n yig,\\n ma.masked_where(np.isnan(zi), zi),\\n rstride=ast.literal_eval(plotSettings['rstride']),\\n cstride=ast.literal_eval(plotSettings['cstride']),\\n linewidth=ast.literal_eval(plotSettings['linewidth']),\\n antialiased=ast.literal_eval(plotSettings['antialiased']),\\n **plotSettings.get('attributes', {}))\\n if 'color' in plotSettings.get('attributes', {}):\\n self.actPlot.set_color = plotSettings.get('attributes', {})['color']\\n else:\\n self.actPlot.set_color = 'blue'\\n else:\\n self.actPlot = self.ax.plot_surface(xig,\\n yig,\\n ma.masked_where(np.isnan(zi), zi),\\n rstride=ast.literal_eval(plotSettings['rstride']),\\n cstride=ast.literal_eval(plotSettings['cstride']),\\n cmap=matplotlib.cm.get_cmap(name = plotSettings['cmap']),\\n linewidth=ast.literal_eval(plotSettings['linewidth']),\\n antialiased=ast.literal_eval(plotSettings['antialiased']),\\n **plotSettings.get('attributes', {}))\\n ########################\\n # TRI-SURFACE PLOT #\\n ########################\\n elif self.outStreamTypes[pltIndex] == 'tri-surface':\\n if self.dim == 2:\\n self.raiseAWarning('TRI-surface Plot is NOT available for 2D plots, it is 3D!')\\n return\\n else:\\n if 'color' not in plotSettings:\\n plotSettings['color'] = 'b'\\n if 'shade' not in plotSettings:\\n plotSettings['shade'] = 'False'\\n for key in self.xValues[pltIndex]:\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n # Hopefully, x,y, and z are all the same length, so checking this\\n # here should be good enough.\\n # The problem is you cannot interpolate any amount of space if\\n # you only have a single data point.\\n if self.xValues[pltIndex][key][xIndex].size == 1:\\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\\n continue\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n for zIndex in range(len(self.zValues[pltIndex][key])):\\n metric = (self.xValues[pltIndex][key][xIndex] ** 2 + self.yValues[pltIndex][key][yIndex] ** 2) ** 0.5\\n metricIndeces = np.argsort(metric)\\n xs = np.zeros(self.xValues[pltIndex][key][xIndex].shape)\\n ys = np.zeros(self.yValues[pltIndex][key][yIndex].shape)\\n zs = np.zeros(self.zValues[pltIndex][key][zIndex].shape)\\n for sindex in range(len(metricIndeces)):\\n xs[sindex] = self.xValues[pltIndex][key][xIndex][metricIndeces[sindex]]\\n ys[sindex] = self.yValues[pltIndex][key][yIndex][metricIndeces[sindex]]\\n zs[sindex] = self.zValues[pltIndex][key][zIndex][metricIndeces[sindex]]\\n surfacePlotOptions = {'color': plotSettings['color'],\\n 'shade': ast.literal_eval(plotSettings['shade'])}\\n surfacePlotOptions.update(plotSettings.get('attributes', {}))\\n if self.zValues[pltIndex][key][zIndex].size <= 3:\\n return\\n if self.colorMapCoordinates[pltIndex] is not None:\\n if self.actcm:\\n first = False\\n else:\\n first = True\\n if plotSettings['cmap'] == 'None':\\n plotSettings['cmap'] = 'jet'\\n surfacePlotOptions['cmap'] = matplotlib.cm.get_cmap(name = plotSettings['cmap'])\\n self.actPlot = self.ax.plot_trisurf(xs, ys, zs, **surfacePlotOptions)\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n if first:\\n self.actPlot.cmap = matplotlib.cm.get_cmap(name=plotSettings['cmap'])\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_array(self.colorMapValues[pltIndex][key])\\n self.actcm = self.fig.colorbar(m)\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_clim(vmin=min(self.colorMapValues[pltIndex][key][-1]), vmax=max(self.colorMapValues[pltIndex][key][-1]))\\n self.actcm.draw_all()\\n else:\\n if plotSettings['cmap'] != 'None':\\n surfacePlotOptions[\\\"cmap\\\"] = matplotlib.cm.get_cmap(name=plotSettings['cmap'])\\n self.actPlot = self.ax.plot_trisurf(xs, ys, zs, **surfacePlotOptions)\\n ########################\\n # WIREFRAME PLOT #\\n ########################\\n elif self.outStreamTypes[pltIndex] == 'wireframe':\\n if self.dim == 2:\\n self.raiseAWarning('wireframe Plot is NOT available for 2D plots, IT IS A 3D!')\\n return\\n else:\\n if 'rstride' not in plotSettings:\\n plotSettings['rstride'] = '1'\\n if 'cstride' not in plotSettings:\\n plotSettings['cstride'] = '1'\\n for key in self.xValues[pltIndex]:\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n # Hopefully, x,y, and z are all the same length, so checking this\\n # here should be good enough.\\n # The problem is you cannot interpolate any amount of space if\\n # you only have a single data point.\\n if self.xValues[pltIndex][key][xIndex].size == 1:\\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\\n continue\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n for zIndex in range(len(self.zValues[pltIndex][key])):\\n if self.zValues[pltIndex][key][zIndex].size <= 3:\\n return\\n if self.colorMapCoordinates[pltIndex] is not None:\\n xig, yig, Ci = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n plotSettings,\\n z=self.colorMapValues[pltIndex][key][zIndex],\\n returnCoordinate=True)\\n xig, yig, zi = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n plotSettings,\\n z=self.zValues[pltIndex][key][zIndex],\\n returnCoordinate=True)\\n if self.colorMapCoordinates[pltIndex] is not None:\\n self.raiseAWarning(f'Currently, ax.plot_wireframe() in MatPlotLib version: {matplotlib.__version__} does not support a colormap! Wireframe plotted on a surface plot...')\\n if self.actcm:\\n first = False\\n else:\\n first = True\\n if plotSettings['cmap'] == 'None':\\n plotSettings['cmap'] = 'jet'\\n self.actPlot = self.ax.plot_wireframe(xig,\\n yig,\\n ma.masked_where(np.isnan(zi), zi),\\n rstride=ast.literal_eval(plotSettings['rstride']),\\n cmap=matplotlib.cm.get_cmap(name = plotSettings['cmap']),\\n cstride=ast.literal_eval(plotSettings['cstride']),\\n **plotSettings.get('attributes', {}))\\n self.actPlot = self.ax.plot_surface(xig,\\n yig,\\n ma.masked_where(np.isnan(zi), zi),\\n alpha=0.4,\\n rstride=ast.literal_eval(plotSettings['rstride']),\\n cmap=matplotlib.cm.get_cmap(name=plotSettings['cmap']),\\n cstride=ast.literal_eval(plotSettings['cstride']),\\n **plotSettings.get('attributes', {}))\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n if first:\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_array(self.colorMapValues[pltIndex][key])\\n self.actcm = self.fig.colorbar(m)\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n m = matplotlib.cm.ScalarMappable(cmap=self.actPlot.cmap, norm=self.actPlot.norm)\\n m.set_clim(vmin=min(self.colorMapValues[pltIndex][key][-1]), vmax=max(self.colorMapValues[pltIndex][key][-1]))\\n self.actcm.draw_all()\\n else:\\n if plotSettings['cmap'] == 'None':\\n self.actPlot = self.ax.plot_wireframe(xig,\\n yig,\\n ma.masked_where(np.isnan(zi), zi),\\n rstride=ast.literal_eval(plotSettings['rstride']),\\n cstride=ast.literal_eval(plotSettings['cstride']),\\n **plotSettings.get('attributes', {}))\\n if 'color' in plotSettings.get('attributes', {}):\\n self.actPlot.set_color = plotSettings.get('attributes', {})['color']\\n else:\\n self.actPlot.set_color = 'blue'\\n else:\\n self.actPlot = self.ax.plot_wireframe(xig,\\n yig,\\n ma.masked_where(np.isnan(zi), zi),\\n rstride=ast.literal_eval(plotSettings['rstride']),\\n cstride=ast.literal_eval(plotSettings['cstride']),\\n **plotSettings.get('attributes', {}))\\n ########################\\n # CONTOUR PLOT #\\n ########################\\n elif self.outStreamTypes[pltIndex] == 'contour' or self.outStreamTypes[pltIndex] == 'filledContour':\\n if self.dim == 2:\\n if 'numberBins' in plotSettings:\\n nbins = int(plotSettings['numberBins'])\\n else:\\n nbins = 5\\n for key in self.xValues[pltIndex]:\\n if not self.colorMapCoordinates:\\n self.raiseAWarning(self.outStreamTypes[pltIndex] + ' Plot needs coordinates for color map... Returning without plotting')\\n return\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n # Hopefully, x,y, and z are all the same length, so checking this\\n # here should be good enough.\\n # The problem is you cannot interpolate any amount of space if\\n # you only have a single data point.\\n if self.xValues[pltIndex][key][xIndex].size == 1:\\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\\n continue\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n for zIndex in range(len(self.colorMapValues[pltIndex][key])):\\n if self.actcm:\\n first = False\\n else:\\n first = True\\n xig, yig, Ci = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n plotSettings,\\n z=self.colorMapValues[pltIndex][key][zIndex],\\n returnCoordinate=True)\\n if self.outStreamTypes[pltIndex] == 'contour':\\n if plotSettings['cmap'] == 'None':\\n if 'color' in plotSettings.get('attributes', {}):\\n color = plotSettings.get('attributes', {})['color']\\n else:\\n color = 'blue'\\n self.actPlot = self.ax.contour(xig,\\n yig,\\n ma.masked_where(np.isnan(Ci), Ci),\\n nbins,\\n colors=color,\\n **plotSettings.get('attributes', {}))\\n else:\\n self.actPlot = self.ax.contour(xig,\\n yig,\\n ma.masked_where(np.isnan(Ci), Ci),\\n nbins,\\n **plotSettings.get('attributes', {}))\\n else:\\n if plotSettings['cmap'] == 'None':\\n plotSettings['cmap'] = 'jet'\\n self.actPlot = self.ax.contourf(xig,\\n yig,\\n ma.masked_where(np.isnan(Ci), Ci),\\n nbins,\\n **plotSettings.get('attributes', {}))\\n self.ax.clabel(self.actPlot, inline=1, fontsize=10)\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n if first:\\n self.actcm = self.fig.colorbar(self.actPlot, shrink=0.8, extend='both')\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n m = matplotlib.cm.ScalarMappable(cmap = self.actPlot.cmap, norm = self.actPlot.norm)\\n m.set_clim(vmin = min(self.colorMapValues[pltIndex][key][-1]), vmax = max(self.colorMapValues[pltIndex][key][-1]))\\n self.actcm.draw_all()\\n else:\\n self.raiseAWarning('contour/filledContour is a 2-D plot, where x,y are the surface coordinates and colorMap vector is the array to visualize!\\\\n contour3D/filledContour3D are 3-D! ')\\n return\\n # These should be combined: ^^^ & vvv\\n elif self.outStreamTypes[pltIndex] == 'contour3D' or self.outStreamTypes[pltIndex] == 'filledContour3D':\\n if self.dim == 2:\\n self.raiseAWarning('contour3D/filledContour3D Plot is NOT available for 2D plots, IT IS A 2D! Check \\\"contour/filledContour\\\"!')\\n return\\n else:\\n if 'numberBins' in plotSettings:\\n nbins = int(plotSettings['numberBins'])\\n else:\\n nbins = 5\\n if 'extend3D' in plotSettings:\\n ext3D = bool(plotSettings['extend3D'])\\n else:\\n ext3D = False\\n for key in self.xValues[pltIndex]:\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n # Hopefully, x,y, and z are all the same length, so checking this\\n # here should be good enough.\\n # The problem is you cannot interpolate any amount of space if\\n # you only have a single data point.\\n if self.xValues[pltIndex][key][xIndex].size == 1:\\n self.raiseAWarning('Nothing to Plot Yet. Continuing to next plot.')\\n continue\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n for zIndex in range(len(self.colorMapValues[pltIndex][key])):\\n if self.actcm:\\n first = False\\n else:\\n first = True\\n xig, yig, Ci = mathUtils.interpolateFunction(self.xValues[pltIndex][key][xIndex],\\n self.yValues[pltIndex][key][yIndex],\\n plotSettings,\\n z=self.colorMapValues[pltIndex][key][zIndex],\\n returnCoordinate=True)\\n if self.outStreamTypes[pltIndex] == 'contour3D':\\n if plotSettings['cmap'] == 'None':\\n if 'color' in plotSettings.get('attributes', {}):\\n color = plotSettings.get('attributes', {})['color']\\n else:\\n color = 'blue'\\n self.actPlot = self.ax.contour3D(xig,\\n yig,\\n ma.masked_where(np.isnan(Ci), Ci),\\n nbins,\\n colors=color,\\n extend3d=ext3D,\\n **plotSettings.get('attributes', {}))\\n else:\\n self.actPlot = self.ax.contour3D(xig,\\n yig,\\n ma.masked_where(np.isnan(Ci), Ci),\\n nbins,\\n extend3d=ext3D,\\n cmap=matplotlib.cm.get_cmap(name=plotSettings['cmap']),\\n **plotSettings.get('attributes', {}))\\n else:\\n if plotSettings['cmap'] == 'None':\\n plotSettings['cmap'] = 'jet'\\n self.actPlot = self.ax.contourf3D(xig,\\n yig,\\n ma.masked_where(np.isnan(Ci), Ci),\\n nbins,\\n cmap=matplotlib.cm.get_cmap(name=plotSettings['cmap']),\\n **plotSettings.get('attributes', {}))\\n self.ax.clabel(self.actPlot, inline=1, fontsize=10)\\n if 'colorbar' not in self.options or self.options['colorbar']['colorbar'] != 'off':\\n if first:\\n self.actcm = self.fig.colorbar(self.actPlot, shrink = 0.8, extend = 'both')\\n self.actcm.set_label(self.colorMapCoordinates[pltIndex][0].split('|')[-1].replace(')', ''))\\n else:\\n m = matplotlib.cm.ScalarMappable(cmap = self.actPlot.cmap, norm = self.actPlot.norm)\\n m.set_clim(vmin = min(self.colorMapValues[pltIndex][key][-1]), vmax = max(self.colorMapValues[pltIndex][key][-1]))\\n self.actcm.draw_all()\\n ########################\\n # DataMining PLOT #\\n ########################\\n elif self.outStreamTypes[pltIndex] == 'dataMining':\\n colors = cycle(['#88CCEE', '#DDCC77', '#AA4499', '#117733', '#332288', '#999933', '#44AA99', '#882255', '#CC6677', '#CD6677', '#DC6877', '#886677', '#AA6677', '#556677', '#CD7865'])\\n if 's' not in plotSettings:\\n plotSettings['s'] = '20'\\n if 'c' not in plotSettings:\\n plotSettings['c'] = 'b'\\n if 'marker' not in plotSettings:\\n plotSettings['marker'] = 'o'\\n if 'alpha' not in plotSettings:\\n plotSettings['alpha'] = 'None'\\n if 'linewidths' not in plotSettings:\\n plotSettings['linewidths'] = 'None'\\n clusterDict[pltIndex] = {}\\n for key in self.xValues[pltIndex]:\\n for xIndex in range(len(self.xValues[pltIndex][key])):\\n for yIndex in range(len(self.yValues[pltIndex][key])):\\n dataMiningPlotOptions = {'s': ast.literal_eval(plotSettings['s']),\\n 'marker': (plotSettings['marker']),\\n 'alpha': ast.literal_eval(plotSettings['alpha']),\\n 'linewidths': ast.literal_eval(plotSettings['linewidths'])}\\n if self.colorMapCoordinates[pltIndex] is not None:\\n self.raiseAWarning('ColorMap values supplied, however DataMining plots do not use colorMap from input.')\\n if plotSettings['cmap'] == 'None':\\n self.raiseAWarning('ColorSet supplied, however DataMining plots do not use color set from input.')\\n if 'cluster' == plotSettings['SKLtype']:\\n # TODO: include the cluster Centers to the plot\\n if 'noClusters' in plotSettings.get('attributes', {}):\\n clusterDict[pltIndex]['noClusters'] = int(plotSettings.get('attributes', {})['noClusters'])\\n plotSettings.get('attributes', {}).pop('noClusters')\\n else:\\n clusterDict[pltIndex]['noClusters'] = np.amax(self.clusterValues[pltIndex][1][0]) + 1\\n dataMiningPlotOptions.update(plotSettings.get('attributes', {}))\\n if self.dim == 2:\\n clusterDict[pltIndex]['clusterValues'] = np.zeros(shape=(len(self.xValues[pltIndex][key][xIndex]), 2))\\n else:\\n clusterDict[pltIndex]['clusterValues'] = np.zeros(shape=(len(self.xValues[pltIndex][key][xIndex]), 3))\\n clusterDict[pltIndex]['clusterValues'][:, 0] = self.xValues[pltIndex][key][xIndex]\\n clusterDict[pltIndex]['clusterValues'][:, 1] = self.yValues[pltIndex][key][yIndex]\\n if self.dim == 2:\\n for k, col in zip(range(int(clusterDict[pltIndex]['noClusters'])), colors):\\n myMembers = self.clusterValues[pltIndex][1][0] == k\\n self.actPlot = self.ax.scatter(clusterDict[pltIndex]['clusterValues'][myMembers, 0],\\n clusterDict[pltIndex]['clusterValues'][myMembers, 1],\\n color=col,\\n **dataMiningPlotOptions)\\n\\n # Handle all of the outlying data\\n myMembers = self.clusterValues[pltIndex][1][0] == -1\\n # resize the points\\n dataMiningPlotOptions['s'] /= 2\\n # and hollow out their markers\\n if 'facecolors' in dataMiningPlotOptions:\\n faceColors = dataMiningPlotOptions['facecolors']\\n else:\\n faceColors = None\\n dataMiningPlotOptions['facecolors'] = 'none'\\n\\n self.actPlot = self.ax.scatter(clusterDict[pltIndex]['clusterValues'][myMembers, 0],\\n clusterDict[pltIndex]['clusterValues'][myMembers, 1],\\n color='#000000',\\n **dataMiningPlotOptions)\\n\\n # Restore the plot options to their original values\\n dataMiningPlotOptions['s'] *= 2\\n if faceColors is not None:\\n dataMiningPlotOptions['facecolors'] = faceColors\\n else:\\n del dataMiningPlotOptions['facecolors']\\n\\n else:\\n for zIndex in range(len(self.zValues[pltIndex][key])):\\n clusterDict[pltIndex]['clusterValues'][:, 2] = self.zValues[pltIndex][key][zIndex]\\n for k, col in zip(range(int(clusterDict[pltIndex]['noClusters'])), colors):\\n myMembers = self.clusterValues[pltIndex][1][0] == k\\n self.actPlot = self.ax.scatter(clusterDict[pltIndex]['clusterValues'][myMembers, 0],\\n clusterDict[pltIndex]['clusterValues'][myMembers, 1],\\n clusterDict[pltIndex]['clusterValues'][myMembers, 2],\\n color=col,\\n **dataMiningPlotOptions)\\n\\n # Handle all of the outlying data\\n myMembers = self.clusterValues[pltIndex][1][0] == -1\\n # resize the points\\n dataMiningPlotOptions['s'] /= 2\\n # and hollow out their markers\\n if 'facecolors' in dataMiningPlotOptions:\\n faceColors = dataMiningPlotOptions['facecolors']\\n else:\\n faceColors = None\\n dataMiningPlotOptions['facecolors'] = 'none'\\n\\n self.actPlot = self.ax.scatter(clusterDict[pltIndex]['clusterValues'][myMembers, 0],\\n clusterDict[pltIndex]['clusterValues'][myMembers, 1],\\n clusterDict[pltIndex]['clusterValues'][myMembers, 2],\\n color='#000000',\\n **dataMiningPlotOptions)\\n\\n # Restore the plot options to their original values\\n dataMiningPlotOptions['s'] *= 2\\n if faceColors is not None:\\n dataMiningPlotOptions['facecolors'] = faceColors\\n else:\\n del dataMiningPlotOptions['facecolors']\\n\\n elif 'bicluster' == plotSettings['SKLtype']:\\n self.raiseAnError(IOError, 'SKLType Bi-Cluster Plots are not implemented yet!..')\\n elif 'mixture' == plotSettings['SKLtype']:\\n if 'noMixtures' in plotSettings.get('attributes', {}):\\n clusterDict[pltIndex]['noMixtures'] = int(plotSettings.get('attributes', {})['noMixtures'])\\n plotSettings.get('attributes', {}).pop('noMixtures')\\n else:\\n clusterDict[pltIndex]['noMixtures'] = np.amax(self.mixtureValues[pltIndex][1][0]) + 1\\n if self.dim == 3:\\n self.raiseAnError(IOError, 'SKLType Mixture Plots are only available in 2-Dimensions')\\n else:\\n clusterDict[pltIndex]['mixtureValues'] = np.zeros(shape = (len(self.xValues[pltIndex][key][xIndex]), 2))\\n clusterDict[pltIndex]['mixtureValues'][:, 0] = self.xValues[pltIndex][key][xIndex]\\n clusterDict[pltIndex]['mixtureValues'][:, 1] = self.yValues[pltIndex][key][yIndex]\\n if 'mixtureCovars' in plotSettings.get('attributes', {}):\\n split = self.__splitVariableNames('mixtureCovars', (pltIndex, 0))\\n # mixtureCovars = self.sourceData[pltIndex].getParam(split[1], split[2], nodeId = 'ending')\\n plotSettings.get('attributes', {}).pop('mixtureCovars')\\n # else:\\n # mixtureCovars = None\\n if 'mixtureMeans' in plotSettings.get('attributes', {}):\\n split = self.__splitVariableNames('mixtureMeans', (pltIndex, 0))\\n # mixtureMeans = self.sourceData[pltIndex].getParam(split[1], split[2], nodeId = 'ending')\\n plotSettings.get('attributes', {}).pop('mixtureMeans')\\n # else:\\n # mixtureMeans = None\\n # mixtureCovars.reshape(3, 4)\\n # mixtureMeans.reshape(3, 4)\\n # for i, (mean, covar, col) in enumerate(zip(mixtureMeans, mixtureCovars, colors)):\\n for i, col in zip(range(clusterDict[pltIndex]['noMixtures']), colors):\\n if not np.any(self.mixtureValues[pltIndex][1][0] == i):\\n continue\\n myMembers = self.mixtureValues[pltIndex][1][0] == i\\n self.actPlot = self.ax.scatter(clusterDict[pltIndex]['mixtureValues'][myMembers, 0],\\n clusterDict[pltIndex]['mixtureValues'][myMembers, 1],\\n color=col,\\n **dataMiningPlotOptions)\\n elif 'manifold' == plotSettings['SKLtype']:\\n if self.dim == 2:\\n manifoldValues = np.zeros(shape=(len(self.xValues[pltIndex][key][xIndex]), 2))\\n else:\\n manifoldValues = np.zeros(shape=(len(self.xValues[pltIndex][key][xIndex]), 3))\\n manifoldValues[:, 0] = self.xValues[pltIndex][key][xIndex]\\n manifoldValues[:, 1] = self.yValues[pltIndex][key][yIndex]\\n if 'clusterLabels' in plotSettings.get('attributes', {}):\\n split = self.__splitVariableNames('clusterLabels', (pltIndex, 0))\\n clusterDict[pltIndex]['clusterLabels'] = self.sourceData[pltIndex].getParam(split[1], split[2], nodeId = 'ending')\\n plotSettings.get('attributes', {}).pop('clusterLabels')\\n else:\\n clusterDict[pltIndex]['clusterLabels'] = None\\n if 'noClusters' in plotSettings.get('attributes', {}):\\n clusterDict[pltIndex]['noClusters'] = int(plotSettings.get('attributes', {})['noClusters'])\\n plotSettings.get('attributes', {}).pop('noClusters')\\n else:\\n clusterDict[pltIndex]['noClusters'] = np.amax(self.clusterValues[pltIndex][1][0]) + 1\\n if self.clusterValues[pltIndex][1][0] is not None:\\n if self.dim == 2:\\n for k, col in zip(range(clusterDict[pltIndex]['noClusters']), colors):\\n myMembers = self.clusterValues[pltIndex][1][0] == k\\n self.actPlot = self.ax.scatter(manifoldValues[myMembers, 0],\\n manifoldValues[myMembers, 1],\\n color=col,\\n **dataMiningPlotOptions)\\n else:\\n for zIndex in range(len(self.zValues[pltIndex][key])):\\n manifoldValues[:, 2] = self.zValues[pltIndex][key][zIndex]\\n for k, col in zip(range(clusterDict[pltIndex]['noClusters']), colors):\\n myMembers = self.clusterValues[pltIndex][1][0] == k\\n self.actPlot = self.ax.scatter(manifoldValues[myMembers, 0],\\n manifoldValues[myMembers, 1],\\n manifoldValues[myMembers, 2],\\n color=col,\\n **dataMiningPlotOptions)\\n else:\\n if self.dim == 2:\\n self.actPlot = self.ax.scatter(manifoldValues[:, 0],\\n manifoldValues[:, 1],\\n **dataMiningPlotOptions)\\n else:\\n for zIndex in range(len(self.zValues[pltIndex][key])):\\n manifoldValues[:, 2] = self.zValues[pltIndex][key][zIndex]\\n self.actPlot = self.ax.scatter(manifoldValues[:, 0],\\n manifoldValues[:, 1],\\n manifoldValues[:, 2],\\n **dataMiningPlotOptions)\\n elif 'decomposition' == plotSettings['SKLtype']:\\n if self.dim == 2:\\n decompositionValues = np.zeros(shape = (len(self.xValues[pltIndex][key][xIndex]), 2))\\n else:\\n decompositionValues = np.zeros(shape = (len(self.xValues[pltIndex][key][xIndex]), 3))\\n decompositionValues[:, 0] = self.xValues[pltIndex][key][xIndex]\\n decompositionValues[:, 1] = self.yValues[pltIndex][key][yIndex]\\n if 'noClusters' in plotSettings.get('attributes', {}):\\n clusterDict[pltIndex]['noClusters'] = int(plotSettings.get('attributes', {})['noClusters'])\\n plotSettings.get('attributes', {}).pop('noClusters')\\n else:\\n clusterDict[pltIndex]['noClusters'] = np.amax(self.clusterValues[pltIndex][1][0]) + 1\\n if self.clusterValues[pltIndex][1][0] is not None:\\n if self.dim == 2:\\n for k, col in zip(range(clusterDict[pltIndex]['noClusters']), colors):\\n myMembers = self.clusterValues[pltIndex][1][0] == k\\n self.actPlot = self.ax.scatter(decompositionValues[myMembers, 0],\\n decompositionValues[myMembers, 1],\\n color=col,\\n **dataMiningPlotOptions)\\n else:\\n for zIndex in range(len(self.zValues[pltIndex][key])):\\n decompositionValues[:, 2] = self.zValues[pltIndex][key][zIndex]\\n for k, col in zip(range(clusterDict[pltIndex]['noClusters']), colors):\\n myMembers = self.clusterValues[pltIndex][1][0] == k\\n self.actPlot = self.ax.scatter(decompositionValues[myMembers, 0],\\n decompositionValues[myMembers, 1],\\n decompositionValues[myMembers, 2],\\n color=col,\\n **dataMiningPlotOptions)\\n else:\\n # no ClusterLabels\\n if self.dim == 2:\\n self.actPlot = self.ax.scatter(decompositionValues[:, 0],\\n decompositionValues[:, 1],\\n **dataMiningPlotOptions)\\n else:\\n for zIndex in range(len(self.zValues[pltIndex][key])):\\n decompositionValues[:, 2] = self.zValues[pltIndex][key][zIndex]\\n self.actPlot = self.ax.scatter(decompositionValues[:, 0],\\n decompositionValues[:, 1],\\n decompositionValues[:, 2],\\n **dataMiningPlotOptions)\\n else:\\n # Let's try to \\\"write\\\" the code for the plot on the fly\\n self.raiseAWarning('Trying to create a non-predefined plot of type ' + self.outStreamTypes[pltIndex] + '. If this fails, please refer to the and/or the related matplotlib method specification.')\\n kwargs = {}\\n for kk in plotSettings:\\n if kk != 'attributes' and kk != self.outStreamTypes[pltIndex]:\\n try:\\n kwargs[kk] = ast.literal_eval(plotSettings[kk])\\n except ValueError:\\n kwargs[kk] = plotSettings[kk]\\n try:\\n if self.dim == 2:\\n customFunctionCall = getattr(self.ax, self.outStreamTypes[pltIndex])\\n else:\\n customFunctionCall = getattr(self.ax, self.outStreamTypes[pltIndex])\\n self.actPlot = customFunctionCall(**kwargs)\\n except AttributeError as ae:\\n self.raiseAnError(RuntimeError, '<' + str(ae) + '> -> in execution custom plot \\\"' + self.outStreamTypes[pltIndex] + '\\\" in Plot ' + self.name + '.\\\\nSTREAM MANAGER: ERROR -> command has been called in the following way: ' + 'ax.' + self.outStreamTypes[pltIndex])\\n\\n if 'legend' in self.options['plotSettings']:\\n self.fig.legend(**self.options['plotSettings']['legend'])\\n\\n # SHOW THE PICTURE\\n self.__executeActions()\\n self.fig.canvas.draw_idle()\\n\\n if 'screen' in self.destinations and display:\\n def handle_close(event):\\n \\\"\\\"\\\"\\n This method is aimed to handle the closing of figures (overall when in interactive mode)\\n @ In, event, instance, the event to close\\n @ Out, None\\n \\\"\\\"\\\"\\n self.fig.canvas.stop_event_loop()\\n self.raiseAMessage('Closed Figure')\\n self.fig.canvas.mpl_connect('close_event', handle_close)\\n # self.plt.pause(1e-6)\\n # The following code is extracted from pyplot.pause without actually\\n # needing to force the code to sleep, according to MPL's documentation,\\n # this feature is experimental, hopefully by not calling the pause\\n # function, we can obtain consistent results.\\n # We are skipping a few of the sanity checks done in that function,\\n # since we are sure we have an interactive backend and access to the\\n # correct type of canvas and figure.\\n self.fig.canvas.draw()\\n # If your graphs are unresponsive to user input, you may want to consider\\n # adjusting this timeout, to allow more time for the input to be handled.\\n self.fig.canvas.start_event_loop(1e-3)\\n\\n # self.fig.canvas.flush_events()\\n\\n for fileType in self.destinations:\\n if fileType == 'screen':\\n continue\\n\\n if not self.overwrite:\\n prefix = str(self.counter) + '-'\\n else:\\n prefix = ''\\n\\n if len(self.filename) > 0:\\n name = self.filename\\n else:\\n name = prefix + self.name + '_' + str(self.outStreamTypes).replace(\\\"'\\\", \\\"\\\").replace(\\\"[\\\", \\\"\\\").replace(\\\"]\\\", \\\"\\\").replace(\\\",\\\", \\\"-\\\").replace(\\\" \\\", \\\"\\\")\\n\\n if self.subDirectory is not None:\\n name = os.path.join(self.subDirectory,name)\\n\\n self.fig.savefig(name + '.' + fileType, format=fileType)\\n\\n if 'screen' not in self.destinations:\\n plt.close(fig=self.fig)\\n\\n gc.collect()\",\n \"def plot_grid(filename, title, names, x):\\n fig = plt.figure(figsize=(10,6))\\n ax = fig.add_subplot(111)\\n ax.set_title(title)\\n plt.imshow(x, interpolation=\\\"nearest\\\", cmap=plt.get_cmap(\\\"hot\\\"))\\n ax.set_aspect('equal')\\n plt.xticks(range(6), names, rotation='vertical')\\n plt.yticks(range(6), names)\\n plt.subplots_adjust(bottom=0.25)\\n # ax.set_xticklabels(('',) + names)\\n # ax.set_yticklabels(('',) + names)\\n cax = fig.add_axes([0.12, 0.1, 0.78, 0.8])\\n cax.get_xaxis().set_visible(False)\\n cax.get_yaxis().set_visible(False)\\n cax.patch.set_alpha(0)\\n cax.set_frame_on(False)\\n plt.colorbar(orientation='vertical')\\n plt.savefig(filename+\\\".pdf\\\")\\n fig.clear()\",\n \"def plot_directory_numex(path, vals, param='density', outname=None, show=True,\\n xscale=1e-3,yscale=1e2):\\n #vals = arange(2300.0, 2800.0, 50.0)\\n outdirs = np.sort(os.listdir(path))\\n plt.figure()\\n\\n # Plot surface profiles for each parameter\\n for val,outdir in zip(vals,outdirs):\\n pointsFile = os.path.join(path, outdir, 'points.h5')\\n print(pointsFile)\\n x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile, output=True, adjustRadial=True)\\n x_fem = x_fem / xscale\\n ur_fem = ur_fem / yscale\\n uz_fem = uz_fem / yscale\\n l, = plt.plot(x_fem,uz_fem,'.-',label=str(val))\\n plt.plot(x_fem,ur_fem,'.-',color=l.get_color())\\n\\n # Annotate\\n plt.axhline(color='k') #zero displacement line\\n plt.title(param)\\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\\n plt.legend()\\n\\n if outname: plt.savefig(outname)\\n if show: plt.show()\",\n \"def do_data_plots(cat, subdir):\\n dla_data.noterdaeme_12_data()\\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(zmax=5,color=\\\"blue\\\")\\n np.savetxt(path.join(subdir,\\\"cddf_all.txt\\\"), (l_N, cddf, cddf68[:,0], cddf68[:,1], cddf95[:,0],cddf95[:,1]))\\n plt.xlim(1e20, 1e23)\\n plt.ylim(1e-28, 5e-21)\\n plt.legend(loc=0)\\n save_figure(path.join(subdir, \\\"cddf_gp\\\"))\\n plt.clf()\\n\\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(zmax=5,color=\\\"blue\\\", moment=True)\\n plt.xlim(1e20, 1e23)\\n plt.legend(loc=0)\\n save_figure(path.join(subdir, \\\"cddf_moment_gp\\\"))\\n plt.clf()\\n\\n #Evolution with redshift\\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(4,5, label=\\\"4-5\\\", color=\\\"brown\\\")\\n np.savetxt(path.join(subdir,\\\"cddf_z45.txt\\\"), (l_N, cddf, cddf68[:,0], cddf68[:,1], cddf95[:,0],cddf95[:,1]))\\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(3,4, label=\\\"3-4\\\", color=\\\"black\\\")\\n np.savetxt(path.join(subdir,\\\"cddf_z34.txt\\\"), (l_N, cddf, cddf68[:,0], cddf68[:,1], cddf95[:,0],cddf95[:,1]))\\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(2.5,3, label=\\\"2.5-3\\\", color=\\\"green\\\")\\n np.savetxt(path.join(subdir,\\\"cddf_z253.txt\\\"), (l_N, cddf, cddf68[:,0], cddf68[:,1], cddf95[:,0],cddf95[:,1]))\\n (l_N, cddf, cddf68, cddf95) = cat.plot_cddf(2,2.5, label=\\\"2-2.5\\\", color=\\\"blue\\\")\\n np.savetxt(path.join(subdir,\\\"cddf_z225.txt\\\"), (l_N, cddf, cddf68[:,0], cddf68[:,1], cddf95[:,0],cddf95[:,1]))\\n plt.xlim(1e20, 1e23)\\n plt.ylim(1e-28, 5e-21)\\n plt.legend(loc=0)\\n save_figure(path.join(subdir,\\\"cddf_zz_gp\\\"))\\n plt.clf()\\n\\n #dNdX\\n dla_data.dndx_not()\\n dla_data.dndx_pro()\\n (z_cent, dNdX, dndx68, dndx95) = cat.plot_line_density(zmax=5)\\n np.savetxt(path.join(subdir,\\\"dndx_all.txt\\\"), (z_cent, dNdX, dndx68[:,0],dndx68[:,1], dndx95[:,0],dndx95[:,1]) )\\n plt.legend(loc=0)\\n plt.ylim(0,0.16)\\n save_figure(path.join(subdir,\\\"dndx_gp\\\"))\\n plt.clf()\\n\\n #Omega_DLA\\n dla_data.omegahi_not()\\n dla_data.omegahi_pro()\\n dla_data.crighton_omega()\\n (z_cent, omega_dla, omega_dla_68, omega_dla_95) = cat.plot_omega_dla(zmax=5)\\n# cat.tophat_prior = True\\n# cat.plot_omega_dla(zmax=5, label=\\\"Tophat Prior\\\", twosigma=False)\\n# cat.tophat_prior = False\\n np.savetxt(path.join(subdir,\\\"omega_dla_all.txt\\\"), (z_cent, omega_dla, omega_dla_68[:,0],omega_dla_68[:,1], omega_dla_95[:,0], omega_dla_95[:,1]))\\n plt.legend(loc=0)\\n plt.xlim(2,5)\\n plt.ylim(0,2.5)\\n save_figure(path.join(subdir,\\\"omega_gp\\\"))\\n plt.clf()\",\n \"def residmapComparison():\\n srcmap001 = fits.open('dataFiles/6gev_srcmap_001.fits')\\n srcmap03 = fits.open('dataFiles/6gev_srcmap_03.fits')\\n\\n image_data = fits.getdata('dataFiles/6gev_image.fits')\\n filename = get_pkg_data_filename('dataFiles/6gev_image.fits')\\n hdu = fits.open(filename)[0]\\n wcs = WCS(hdu.header)\\n\\n #Given the results of the fit, calculate the model\\n modelData001 = np.zeros(srcmap001[0].shape)\\n modelData03 = np.zeros(srcmap03[0].shape)\\n\\n file = open('plotsData/fitResults001.pk1','rb')\\n fit001 = pickle.load(file)\\n file.close()\\n\\n file = open('plotsData/fitResults03.pk1','rb')\\n fit03 = pickle.load(file)\\n file.close()\\n\\n\\n for source in fit001:\\n the_index = srcmap001.index_of(source)\\n\\n modelData001 += fit001[source][:, None, None]*srcmap001[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap001[the_index].data, axis=2), axis=1)[:-1, None, None]\\n for source in fit03:\\n the_index = srcmap03.index_of(source)\\n modelData03 += fit03[source][:, None, None]*srcmap03[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap03[the_index].data, axis=2), axis=1)[:-1, None, None]\\n\\n fig = plt.figure(figsize=[12, 4.5])\\n\\n vmin = -25.0\\n vmax = 25.0\\n cbStep = 5.0\\n ax = fig.add_subplot(121, projection=wcs)\\n ax=plt.gca()\\n ax.tick_params(direction='in')\\n c = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax.get_transform('galactic'))\\n ax.add_patch(c)\\n mappable=plt.imshow((image_data-np.sum(modelData001,axis=0)),cmap='seismic',origin='lower',vmin=vmin, vmax=vmax, interpolation='gaussian')#\\n plt.xlabel('Galactic Longitude')\\n plt.ylabel('Galactic Latitude')\\n plt.title('GC Point Source ($>6$ GeV)')\\n cb = plt.colorbar(mappable, label='Residual counts per pixel', pad=0.01,ticks=np.arange(vmin, vmax+cbStep, cbStep))\\n cb.ax.tick_params(width=0)\\n\\n\\n ax2=fig.add_subplot(122, projection=wcs)\\n ax2 = plt.gca()\\n c2 = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax2.get_transform('galactic'))\\n ax2.add_patch(c2)\\n mappable2 = plt.imshow((image_data-np.sum(modelData03,axis=0)), cmap='seismic',origin='lower',vmin=vmin, vmax=vmax, interpolation='gaussian')\\n plt.xlabel('Galactic Longitude')\\n plt.ylabel('Galactic Latitude')\\n plt.title('GC Extended Source ($>6$ GeV)')\\n cb2 = plt.colorbar(mappable2, label='Residual counts per pixel', pad=0.01, ticks=np.arange(vmin, vmax+cbStep, cbStep))\\n cb2.ax.tick_params(width=0)\\n fig.tight_layout()\\n plt.subplots_adjust(wspace = 0.13, left=0.04, bottom=0.13, top=0.92)\\n #plt.savefig('plots/residComparison.pdf',bbox_inches='tight')\\n plt.show()\",\n \"def generateStationPlot(dir_path, traj_list, color_scheme='light'):\\n\\n\\n # Choose the color scheme\\n cs = MapColorScheme()\\n \\n if color_scheme == 'light':\\n cs.light()\\n\\n else:\\n cs.dark()\\n\\n\\n plt.figure(figsize=(19.2, 10.8))\\n\\n # Init the map\\n m = Basemap(projection='cyl', resolution='i')\\n\\n # Draw the coast boundary and fill the oceans with the given color\\n m.drawmapboundary(fill_color=cs.map_background)\\n\\n # Fill continents, set lake color same as ocean color\\n m.fillcontinents(color=cs.continents, lake_color=cs.lakes, zorder=1)\\n\\n # Draw country borders\\n m.drawcountries(color=cs.countries)\\n m.drawstates(color=cs.states, linestyle='--')\\n\\n\\n\\n ### PLOT WORLD MAP ###\\n\\n # Group stations into countries\\n country_dict = {}\\n for traj in traj_list:\\n\\n for obs in traj.observations:\\n\\n # Extract country code\\n country_code = obs.station_id[:2]\\n\\n if country_code not in country_dict:\\n country_dict[country_code] = {}\\n \\n\\n if obs.station_id not in country_dict[country_code]:\\n country_dict[country_code][obs.station_id] = [obs.lat, obs.lon]\\n\\n\\n\\n # Plot stations in all countries\\n for country_code in country_dict:\\n\\n station_dict = country_dict[country_code]\\n\\n # Extract lat/lon\\n lat = np.degrees([station_dict[station_id][0] for station_id in station_dict])\\n lon = np.degrees([station_dict[station_id][1] for station_id in station_dict])\\n\\n # Convert lat/lon to x/y\\n x, y = m(lon, lat)\\n\\n plt.scatter(x, y, s=0.75, zorder=5, label=\\\"{:s}: {:d}\\\".format(country_code, len(lat)))\\n\\n\\n plt.legend(loc='lower left')\\n\\n plt.tight_layout()\\n\\n plt.savefig(os.path.join(dir_path, \\\"world_map.png\\\"), dpi=100)\\n\\n plt.close()\\n\\n ### ###\",\n \"def map_sim_property(**kwargs):\\n\\n GR = glo.global_results()\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n counter = 0\\n fignum = 1\\n if p.gal_index == 'all':\\n\\n for gal_index in GR.N_gal - np.arange(GR.N_gal) - 1:\\n\\n if counter == 0:\\n fig, axes = plt.subplots(3, 3, figsize=(20,15))\\n axs = [axes[0,0],axes[0,1],axes[0,2],axes[1,0],axes[1,1],axes[1,2],axes[2,0],axes[2,1],axes[2,2]]\\n counter = 9\\n\\n gal_ob = gal.galaxy(GR=GR, gal_index=gal_index)\\n simgas = aux.load_temp_file(gal_ob=gal_ob,data_type='simgas')\\n map2D,lab,max_scale = make_projection_map(simgas,prop=p.prop)\\n if p.prop == 'm': map2D = map2D * simgas.m.sum()/np.sum(map2D) \\n\\n # Plot\\n Rmax = max_scale/2\\n ax1 = axs[9 - counter]\\n if p.log:\\n map2D[map2D < 10.**p.vmin] = 10.**p.vmin/2\\n map2D[map2D > 10.**p.vmax] = 10.**p.vmax\\n map2D = np.log10(map2D)\\n if not p.log:\\n map2D[map2D < p.vmin] = p.vmin/2\\n map2D[map2D > p.vmax] = p.vmax\\n im = ax1.imshow(map2D,\\\\\\n extent=[-Rmax,Rmax,-Rmax,Rmax],vmin=p.vmin,cmap=p.cmap)\\n fig.colorbar(im,shrink=0.8,ax=ax1,label=lab)\\n if not p.add: ax1.set_xlabel('x [kpc]'); ax1.set_ylabel('y [kpc]')\\n # Limit axes limits a bit to avoid area with no particles...\\n ax1.set_xlim([-0.99*Rmax,0.99*Rmax])\\n ax1.set_ylim([-0.99*Rmax,0.99*Rmax])\\n if (p.prop == 'm') & (p.text == True):\\n ax1.text(0.05,0.85,'M$_{gas}$=%.2eM$_{\\\\odot}$' % np.sum(simgas.m),\\\\\\n fontsize=14,transform=ax1.transAxes,color='white')\\n ax1.text(0.05,0.75,'SFR=%.2eM$_{\\\\odot}$/yr' % GR.SFR[gal_index],\\\\\\n fontsize=14,transform=ax1.transAxes,color='white')\\n\\n counter -= 1\\n\\n #if counter == 0:\\n # ax1 = plt.subplots(1, 1)\\n #cbar = fig.colorbar(im, ax=axes.ravel().tolist(), shrink=0.95, label=lab)\\n # fig.colorbar(im,shrink=0.8,label=lab)\\n\\n if counter == 0 or gal_index == GR.N_gal-1:\\n print('Saving in ' + p.d_plot + 'sim_data/map_%s_%s_gals_%i.%s' % (p.prop,p.z1,fignum,p.format))\\n # plt.tight_layout()\\n if not os.path.isdir(p.d_plot + 'sim_data/'): os.mkdir(p.d_plot + 'sim_data/')\\n plt.savefig(p.d_plot + 'sim_data/map_%s_%s_gals_%i.%s' % (p.prop,p.z1,fignum,p.format), format=p.format, dpi=250, facecolor='w')\\n fignum += 1\\n\\n else:\\n if p.add:\\n fig, ax1 = plt.gcf(), p.ax\\n if not p.add:\\n fig = plt.figure(figsize=(8,6))\\n ax1 = fig.add_axes([0.1, 0.01, 0.8, 0.8]) \\n ax1.axis('equal')\\n\\n gal_ob = gal.galaxy(GR=GR, gal_index=p.gal_index)\\n simgas = aux.load_temp_file(gal_ob=gal_ob,data_type=p.sim_type)\\n if p.R_max:\\n # Cut out square\\n simgas = simgas[(np.abs(simgas.x) < p.R_max) & (np.abs(simgas.y) < p.R_max)]\\n # Add bottom left corner\\n extra_row = simgas.iloc[0] # to ensure that map gets the right size\\n extra_row['x'],extra_row['y'] = -p.R_max,-p.R_max\\n extra_row[p.prop] = 0\\n simgas = simgas.append(extra_row).reset_index(drop=True) \\n # Add top right corner\\n extra_row = simgas.iloc[0] # to ensure that map gets the right size\\n extra_row['x'],extra_row['y'] = p.R_max,p.R_max\\n extra_row[p.prop] = 0\\n simgas = simgas.append(extra_row).reset_index(drop=True) \\n else:\\n pass\\n map2D,lab,max_scale = make_projection_map(simgas,prop=p.prop)\\n if p.prop == 'm': map2D = map2D * simgas.m.sum()/np.sum(map2D) \\n print('Min and max of map: ',map2D.min(),map2D.max())\\n #map2D[map2D < 1e4] = 1e6\\n # Plot map\\n if not p.R_max:\\n p.R_max = max_scale/2\\n if p.log: \\n if not p.vmax: p.vmax = np.log10(map2D).max()\\n if not p.vmin: p.vmin = np.log10(map2D).max() - 4\\n map2D[map2D < 10.**p.vmin] = 10.**p.vmin/2\\n map2D[map2D > 10.**p.vmax] = 10.**p.vmax\\n map2D = np.log10(map2D)\\n else:\\n if not p.vmax: p.vmax = np.max(map2D)\\n if not p.vmin: p.vmin = np.min(map2D) / 1e3\\n map2D[map2D < p.vmin] = p.vmin #np.min(map2D[map2D > 0])\\n map2D = np.flipud(map2D)\\n\\n im = ax1.imshow(map2D,\\\\\\n extent=[-max_scale/2,max_scale/2,-max_scale/2,max_scale/2],vmin=p.vmin,vmax=p.vmax,cmap=p.cmap)\\n # Limit axes limits a bit to avoid area with no particles...\\n zoom = 1#/1.5\\n ax1.set_xlim([-1/zoom * p.R_max,1/zoom * p.R_max])\\n ax1.set_ylim([-1/zoom * p.R_max,1/zoom * p.R_max])\\n if p.colorbar: \\n divider = make_axes_locatable(ax1)\\n cax1 = divider.append_axes(\\\"right\\\", size=\\\"5%\\\", pad=0.05)\\n fig.colorbar(im,cax=cax1,label=lab)\\n if not p.add: ax1.set_xlabel('x [kpc]'); ax1.set_ylabel('y [kpc]')\\n if (p.prop == 'm') & (p.text == True):\\n simstar = aux.load_temp_file(gal_ob=gal_ob,data_type='simstar')\\n ax1.text(0.05,0.92,'M$_{star}$=%.1e M$_{\\\\odot}$' % np.sum(simstar.m),\\\\\\n fontsize=14,transform=ax1.transAxes,color='white')\\n ax1.text(0.05,0.86,'M$_{gas}$=%.1e M$_{\\\\odot}$' % np.sum(simgas.m),\\\\\\n fontsize=14,transform=ax1.transAxes,color='white')\\n ax1.text(0.05,0.80,'SFR=%.2f M$_{\\\\odot}$/yr' % GR.SFR[p.gal_index],\\\\\\n fontsize=14,transform=ax1.transAxes,color='white')\\n if p.savefig:\\n if not os.path.isdir(p.d_plot + 'sim_data/'): os.mkdir(p.d_plot + 'sim_data/') \\n plt.savefig(p.d_plot + 'sim_data/map_%s_G%i.png' % (p.prop,p.gal_index), format=p.format, dpi=250, facecolor='w')\\n\\n if not p.colorbar: return(im)\",\n \"def compositePlots(self):\\n if not self.master: return\\n\\n # get the HTML page\\n page = [page for page in self.layout.pages if \\\"MeanState\\\" in page.name][0]\\n \\n models = []\\n colors = []\\n corr = {}\\n std = {}\\n cycle = {}\\n has_cycle = False\\n has_std = False\\n for fname in glob.glob(os.path.join(self.output_path,\\\"*.nc\\\")):\\n dataset = Dataset(fname)\\n if \\\"MeanState\\\" not in dataset.groups: continue\\n dset = dataset.groups[\\\"MeanState\\\"]\\n models.append(dataset.getncattr(\\\"name\\\"))\\n colors.append(dataset.getncattr(\\\"color\\\"))\\n for region in self.regions:\\n \\n if not cycle.has_key(region): cycle[region] = []\\n key = [v for v in dset.variables.keys() if (\\\"cycle_\\\" in v and region in v)]\\n if len(key)>0:\\n has_cycle = True\\n cycle[region].append(Variable(filename=fname,groupname=\\\"MeanState\\\",variable_name=key[0]))\\n\\n if not std. has_key(region): std [region] = []\\n if not corr. has_key(region): corr [region] = []\\n\\n key = []\\n if \\\"scalars\\\" in dset.groups:\\n key = [v for v in dset.groups[\\\"scalars\\\"].variables.keys() if (\\\"Spatial Distribution Score\\\" in v and region in v)]\\n if len(key) > 0:\\n has_std = True\\n sds = dset.groups[\\\"scalars\\\"].variables[key[0]]\\n corr[region].append(sds.getncattr(\\\"R\\\" ))\\n std [region].append(sds.getncattr(\\\"std\\\"))\\n\\n # composite annual cycle plot\\n if has_cycle and len(models) > 2:\\n page.addFigure(\\\"Spatially integrated regional mean\\\",\\n \\\"compcycle\\\",\\n \\\"RNAME_compcycle.png\\\",\\n side = \\\"ANNUAL CYCLE\\\",\\n legend = False)\\n\\n for region in self.regions:\\n if not cycle.has_key(region): continue\\n fig,ax = plt.subplots(figsize=(6.8,2.8),tight_layout=True)\\n for name,color,var in zip(models,colors,cycle[region]):\\n dy = 0.05*(self.limits[\\\"cycle\\\"][region][\\\"max\\\"]-self.limits[\\\"cycle\\\"][region][\\\"min\\\"])\\n var.plot(ax,lw=2,color=color,label=name,\\n ticks = time_opts[\\\"cycle\\\"][\\\"ticks\\\"],\\n ticklabels = time_opts[\\\"cycle\\\"][\\\"ticklabels\\\"],\\n vmin = self.limits[\\\"cycle\\\"][region][\\\"min\\\"]-dy,\\n vmax = self.limits[\\\"cycle\\\"][region][\\\"max\\\"]+dy)\\n ylbl = time_opts[\\\"cycle\\\"][\\\"ylabel\\\"]\\n if ylbl == \\\"unit\\\": ylbl = post.UnitStringToMatplotlib(var.unit)\\n ax.set_ylabel(ylbl)\\n fig.savefig(os.path.join(self.output_path,\\\"%s_compcycle.png\\\" % (region)))\\n plt.close()\\n\\n # plot legends with model colors (sorted with Benchmark data on top)\\n page.addFigure(\\\"Spatially integrated regional mean\\\",\\n \\\"legend_compcycle\\\",\\n \\\"legend_compcycle.png\\\",\\n side = \\\"MODEL COLORS\\\",\\n legend = False)\\n def _alphabeticalBenchmarkFirst(key):\\n key = key[0].upper()\\n if key == \\\"BENCHMARK\\\": return 0\\n return key\\n tmp = sorted(zip(models,colors),key=_alphabeticalBenchmarkFirst)\\n fig,ax = plt.subplots()\\n for model,color in tmp:\\n ax.plot(0,0,'o',mew=0,ms=8,color=color,label=model)\\n handles,labels = ax.get_legend_handles_labels()\\n plt.close()\\n \\n ncol = np.ceil(float(len(models))/11.).astype(int)\\n if ncol > 0:\\n fig,ax = plt.subplots(figsize=(3.*ncol,2.8),tight_layout=True)\\n ax.legend(handles,labels,loc=\\\"upper right\\\",ncol=ncol,fontsize=10,numpoints=1)\\n ax.axis('off')\\n fig.savefig(os.path.join(self.output_path,\\\"legend_compcycle.png\\\"))\\n fig.savefig(os.path.join(self.output_path,\\\"legend_spatial_variance.png\\\"))\\n fig.savefig(os.path.join(self.output_path,\\\"legend_temporal_variance.png\\\"))\\n plt.close()\\n \\n # spatial distribution Taylor plot\\n if has_std:\\n page.addFigure(\\\"Temporally integrated period mean\\\",\\n \\\"spatial_variance\\\",\\n \\\"RNAME_spatial_variance.png\\\",\\n side = \\\"SPATIAL TAYLOR DIAGRAM\\\",\\n legend = False)\\n page.addFigure(\\\"Temporally integrated period mean\\\",\\n \\\"legend_spatial_variance\\\",\\n \\\"legend_spatial_variance.png\\\",\\n side = \\\"MODEL COLORS\\\",\\n legend = False) \\n if \\\"Benchmark\\\" in models: colors.pop(models.index(\\\"Benchmark\\\"))\\n for region in self.regions:\\n if not (std.has_key(region) and corr.has_key(region)): continue\\n if len(std[region]) != len(corr[region]): continue\\n if len(std[region]) == 0: continue\\n fig = plt.figure(figsize=(6.0,6.0))\\n post.TaylorDiagram(np.asarray(std[region]),np.asarray(corr[region]),1.0,fig,colors)\\n fig.savefig(os.path.join(self.output_path,\\\"%s_spatial_variance.png\\\" % region))\\n plt.close()\",\n \"def show_image_grid(imgs):\\n grd = make_grid(imgs)\\n npimg = grd.numpy()\\n plt.imshow(np.transpose(npimg, (1,2,0)), interpolation='nearest')\\n plt.ion()\\n plt.show()\",\n \"def plot_outputgrid(self, scalefactor=1, **kwargs):\\n\\n if not (type(scalefactor) == 'int'):\\n scalefactor = round(scalefactor)\\n\\n xx = np.arange(self.xori, self.xend, scalefactor * self.dx)\\n yy = np.arange(self.yori, self.yend, scalefactor * self.dy)\\n plt.hlines(yy, self.xori, self.xend, linewidth=0.2, **kwargs)\\n plt.vlines(xx, self.yori, self.yend, linewidth=0.2, **kwargs)\\n\\n logger.debug('Adding output grid to plot')\",\n \"def plot(model, center, extent, outname):\\n # define model grid\\n xg = np.linspace(-extent, extent, model.shape[0])\\n yg = xg.copy()\\n interp_func = RectBivariateSpline(xg, yg, model)\\n\\n x = np.array([-2, -1, 0, 1, 2]) + center[0]\\n y = np.array([-2, -1, 0, 1, 2]) + center[1]\\n psf = interp_func(x, y)\\n\\n x, y = np.meshgrid(x, y)\\n f = pl.figure(figsize=(10, 5))\\n\\n pl.gray()\\n ax1 = pl.subplot(121)\\n ax1.imshow(model, interpolation='nearest', origin='lower',\\n extent=(-extent, extent, -extent, extent),\\n norm=LogNorm(vmin=model.min(), vmax=model.max()))\\n ax1.plot(x, y, 's', mec='r', mfc='none', mew=2)\\n\\n pl.xlim(-2.5, 2.5)\\n pl.ylim(-2.5, 2.5)\\n ax2 = pl.subplot(122)\\n ax2.imshow(psf, interpolation='nearest', origin='lower',\\n extent=(-extent, extent, -extent, extent),\\n norm=LogNorm(vmin=model.min(), vmax=model.max()))\\n\\n ax2.set_xticks([-2, -1, 0, 1, 2])\\n ax2.set_yticks([-2, -1, 0, 1, 2])\\n ax2.set_xticklabels(['%0.3f' % v for v in x[0]])\\n ax2.set_yticklabels(['%0.3f' % v for v in y[:, 0]])\\n\\n coordsA, coordsB = \\\"data\\\", \\\"data\\\"\\n pixels = np.array([[0.0, 0.0], [2., 2.], [-1., -1.]])\\n locs = np.array([[-0.5, 0.5], [-0.5, 0.5], [-0.5, -0.5]])\\n rads = [0.15, 0.25, -0.25]\\n for i, p in enumerate(pixels):\\n xy1 = p + center\\n xy2 = p + locs[i]\\n con = ConnectionPatch(xyA=xy2, xyB=xy1, coordsA=coordsA,\\n coordsB=coordsB, axesA=ax2, axesB=ax1,\\n arrowstyle=\\\"<-, head_length=1.2, head_width=0.8\\\", \\n shrinkB=5,\\n connectionstyle='arc3, rad=%s' % rads[i],\\n color='r', lw=2)\\n ax2.add_artist(con)\\n ax2.plot(p[0], p[1], 's', mfc='none', mec='r', mew=2, ms=50)\\n\\n #pl.xlim(-2.5, 2.5)\\n #pl.ylim(-2.5, 2.5)\\n f.savefig(outname)\",\n \"def show_filters(self):\\n weight_mat = self.sess.run(self.W_fc_out)\\n\\n # Loop channels\\n plt.figure(figsize=(12,5), facecolor='w', edgecolor='w')\\n with sns.axes_style(\\\"white\\\"):\\n for cl in range(weight_mat.shape[1]):\\n # Get filters of this output class\\n w_list = ia.vec2image( lin_image=weight_mat[:,cl],\\n n_channels=self.n_input_channels,\\n image_size=(self.y_res,self.x_res) )\\n\\n # Show channels\\n for ch,w in enumerate(w_list):\\n colormax = np.abs(w).max()\\n ax = plt.subplot2grid( (self.n_output_classes,\\n self.n_input_channels), (cl,ch) )\\n ax.imshow( w, interpolation='nearest',\\n cmap=plt.get_cmap('seismic'),\\n clim=(-1*colormax,colormax) )\\n ax.set_title(\\\"Class {}, Channel {}\\\".format(cl,ch))\\n plt.axis('tight')\\n plt.axis('off')\\n colormax = np.abs(w).max()\\n\\n if self.n_output_classes == 2:\\n plt.figure(figsize=(12,5), facecolor='w', edgecolor='w')\\n with sns.axes_style(\\\"white\\\"):\\n # Get filters of this output class\\n w_list0 = ia.vec2image( lin_image=weight_mat[:,0],\\n n_channels=self.n_input_channels,\\n image_size=(self.y_res,self.x_res) )\\n w_list1 = ia.vec2image( lin_image=weight_mat[:,1],\\n n_channels=self.n_input_channels,\\n image_size=(self.y_res,self.x_res) )\\n for ch in range(len(w_list)):\\n w_both = w_list1[ch]-w_list0[ch]\\n\\n colormax = np.abs(w_both).max()\\n ax = plt.subplot2grid( (1,\\n self.n_input_channels), (0,ch) )\\n ax.imshow( w_both, interpolation='nearest',\\n cmap=plt.get_cmap('seismic'),\\n clim=(-1*colormax,colormax) )\\n ax.set_title(\\\"Class {}, Channel {}\\\".format(cl,ch))\\n plt.axis('tight')\\n plt.axis('off')\\n plt.tight_layout()\",\n \"def plot_map(data, pixlist, nside, runconf, title, unit):\\n hpmap = np.repeat(np.nan, hp.pixelfunc.nside2npix(nside))\\n hpmap[pixlist] = data\\n plot_lon_cen, plot_lat_cen = runconf['ra'], runconf['dec']\\n if plot_lon_cen > 180:\\n plot_lon_cen -= 360\\n plot_bounds = (1.0 + 1.1 * runconf['radius']) * np.array([-1.0, 1.0])\\n \\n hp.cartview(hpmap, rot=(plot_lon_cen, plot_lat_cen, 0), \\n lonra=plot_bounds, latra=plot_bounds,\\n notext=True, unit=unit, title=title, \\n min=min(data), max=max(data), coord='C', flip='astro')\\n\\n dec0 = np.round(runconf['dec'])\\n dec_spacing = runconf['radius']/2.0\\n decs = dec0 + np.arange(-2*runconf['radius'], 2.1*runconf['radius'], dec_spacing)\\n decs_min, decs_max = min(decs), max(decs)\\n\\n ra0 = np.round(runconf['ra'])\\n cosdelt =np.cos(np.deg2rad(dec0)) \\n ra_spacing = runconf['radius']/cosdelt / 2.0\\n ras = ra0 + np.arange(-2.0*runconf['radius']/cosdelt, 2.1*runconf['radius']/cosdelt, ra_spacing)\\n ras_min, ras_max = min(ras), max(ras)\\n #num_ras = np.ceil(1.0 * runconf['radius'] / grid_spacing / np.cos(np.deg2rad(min(decs))) )\\n\\n line_dec = np.linspace(decs_min, decs_max, 100)\\n line_ra = np.linspace(ras_min, ras_max, 100)\\n for ra in ras:\\n hp.projplot(np.repeat(ra, 100), line_dec, lonlat=True, ls='dashed', color='black')\\n hp.projtext(ra, dec0, r\\\"{ra:0.1f}$^\\\\circ$\\\".format(ra=ra), lonlat=True, clip_on=True)\\n for dec in decs:\\n hp.projplot(line_ra, np.repeat(dec, 100), lonlat=True, ls='dashed', color='black')\\n hp.projtext(ra0, dec, r\\\"{dec:0.1f}$^\\\\circ$\\\".format(dec=dec), lonlat=True, clip_on=True, rotation=90)\\n return\",\n \"def plot_steps(out_dict, units):\\n from bokeh.models import BoxAnnotation\\n from bokeh.plotting import figure, show, output_notebook\\n import bokeh.models as bmd\\n\\n tooltips = [\\n (\\\"Step (total)\\\", \\\"@index\\\"),\\n (\\\"Step (stage)\\\", \\\"@step\\\"),\\n (\\\"Energy\\\", \\\"@energy eV/atom\\\"),\\n (\\\"Energy (dispersion)\\\", \\\"@dispersion_energy_au Ha\\\"),\\n (\\\"SCF converged\\\", \\\"@scf_converged\\\"),\\n (\\\"Cell A\\\", \\\"@cell_a_angs Angs\\\"),\\n (\\\"Cell Vol\\\", \\\"@cell_vol_angs3 Angs^3\\\"),\\n (\\\"MAX Step\\\", \\\"@max_step_au Bohr\\\"),\\n (\\\"Pressure\\\", \\\"@pressure_bar bar\\\")\\n ]\\n hover = bmd.HoverTool(tooltips=tooltips)\\n TOOLS = [\\\"pan\\\", \\\"wheel_zoom\\\", \\\"box_zoom\\\", \\\"reset\\\", \\\"save\\\", hover]\\n\\n natoms = out_dict['natoms']\\n values = [ x/natoms*ha2u[units] for x in out_dict['step_info']['energy_au'] ]\\n values = [ x-min(values) for x in values ]\\n\\n data = bmd.ColumnDataSource(data=dict( index=range(len(values)),\\n step=out_dict['step_info']['step'],\\n energy=values,\\n dispersion_energy_au=out_dict['step_info']['dispersion_energy_au'],\\n scf_converged=out_dict['step_info']['scf_converged'],\\n cell_a_angs=out_dict['step_info']['cell_a_angs'],\\n cell_vol_angs3=out_dict['step_info']['cell_vol_angs3'],\\n max_step_au=out_dict['step_info']['max_step_au'],\\n pressure_bar=out_dict['step_info']['pressure_bar'],\\n ))\\n\\n p = figure(tools=TOOLS, title='Energy profile of the DFT minimization',\\n height=350, width=550)\\n\\n p.xgrid.grid_line_color=None\\n p.xaxis.axis_label = 'Steps'\\n p.yaxis.axis_label = 'Energy ({}/atom)'.format(units)\\n\\n # Colored background\\n colors = ['red','orange','green','yellow','cyan','pink','palegreen']\\n start = 0\\n for i,steps in enumerate(out_dict['stage_info']['nsteps']):\\n end = start+steps\\n p.add_layout(BoxAnnotation(left=start, right=end, fill_alpha=0.2, fill_color=colors[i]))\\n start = end\\n\\n # Trace line and markers\\n p.line('index', 'energy', source=data, line_color='blue')\\n p.circle('index', 'energy', source=data, line_color='blue', size=3)\\n return p\",\n \"def plot_figure9_lower():\\n column_titles = None\\n\\n height_ceiling = 500.\\n height_ceiling_id = list(height_range_ceilings).index(height_ceiling)\\n\\n fixed_height_ref = 100.\\n fixed_height_id = list(fixed_heights).index(fixed_height_ref)\\n\\n plot_item0 = {\\n 'data': nc.variables[\\\"p_ceiling_perc5\\\"][height_ceiling_id, :, :]\\n / nc.variables[\\\"p_fixed_perc5\\\"][fixed_height_id, :, :],\\n 'contour_fill_levels': np.linspace(1, 6., 21),\\n 'contour_line_levels': np.arange(2., 5., 1.),\\n 'contour_line_label_fmt': '%.1f',\\n 'colorbar_ticks': np.linspace(1, 6., 21)[::4],\\n 'colorbar_tick_fmt': '{:.1f}',\\n 'colorbar_label': 'Increase factor [-]',\\n 'extend': 'max',\\n }\\n plot_item1 = {\\n 'data': nc.variables[\\\"p_ceiling_perc32\\\"][height_ceiling_id, :, :]\\n / nc.variables[\\\"p_fixed_perc32\\\"][fixed_height_id, :, :],\\n 'contour_fill_levels': np.linspace(1, 3.5, 21),\\n 'contour_line_levels': np.linspace(1, 3.5, 21)[::4],\\n 'contour_line_label_fmt': '%.1f',\\n 'colorbar_ticks': np.linspace(1, 3.5, 21)[::4],\\n 'colorbar_tick_fmt': '{:.1f}',\\n 'colorbar_label': 'Increase factor [-]',\\n 'extend': 'max',\\n }\\n plot_item2 = {\\n 'data': nc.variables[\\\"p_ceiling_perc50\\\"][height_ceiling_id, :, :]\\n / nc.variables[\\\"p_fixed_perc50\\\"][fixed_height_id, :, :],\\n 'contour_fill_levels': np.linspace(1, 3.5, 21),\\n 'contour_line_levels': np.linspace(1, 3.5, 21)[::4],\\n 'contour_line_label_fmt': '%.1f',\\n 'colorbar_ticks': np.linspace(1, 3.5, 21)[::4],\\n 'colorbar_tick_fmt': '{:.1f}',\\n 'colorbar_label': 'Increase factor [-]',\\n 'extend': 'max',\\n }\\n\\n plot_items = [plot_item0, plot_item1, plot_item2]\\n\\n eval_contour_fill_levels(plot_items)\\n plot_panel_1x3_seperate_colorbar(plot_items, column_titles)\",\n \"def cartesian_map_array(self, fn, vmin=None, vmax=None, bands=8, title='',cblabel='', \\n ecliptic=False, equatorial=False, nocolorbar=False, cmap=plt.get_cmap('coolwarm')):\\n if vmin is None:vmin=fn.vmin\\n if vmax is None: vmax=fn.vmax\\n nrows, ncols = ((bands+1)//4, 4 ) if bands>=4 else (1, bands)\\n \\n fig, axx = plt.subplots(nrows, ncols, figsize=(3+3*ncols,1+3*nrows), sharex=True, sharey=True)\\n plt.subplots_adjust(left=0.1, right=0.92, hspace=0.15, wspace=0.01, bottom=0.15)\\n if ecliptic:\\n lon, sinlat = self.ecliptic_coords()\\n elif equatorial:\\n lon, sinlat = self.equatorial_coords()\\n else:\\n lon = self.df.glon\\n sinlat = self.singlat\\n for iband,energy in enumerate(self.energy[:bands]):\\n ax = axx.flatten()[iband] if bands>1 else axx\\n scat=self.basic_skyplot(ax, lon, sinlat, fn(iband).clip(vmin,vmax),\\n title='%d MeV'%energy,\\n vmin=vmin,vmax=vmax, s=30, edgecolor='none', colorbar=False, labels=False, cmap=cmap)\\n\\n fig.text(0.5, 0.95, getattr(fn, 'title', title), ha='center', size=14)\\n if nocolorbar: return fig\\n #put colorbar at right \\n cbax = fig.add_axes((0.92, 0.15, 0.02, 0.7) )\\n cb=plt.colorbar(scat, cbax, orientation='vertical')\\n cb.set_label(getattr(fn, 'cblabel', cblabel))\\n fig.text(0.5, 0.025, 'longitude', ha='center', fontsize=14)\\n fig.text(0.05, 0.5, 'sin(latitude)', rotation='vertical', va='center', fontsize=14)\\n return fig\",\n \"def plotMSSpectra3D(listOfFilesToPlot, listOfNames=None, listOfColors=None, gridLines=False, yMin=0.5, yMax=2.5, yScale = 1.0,\\r\\n legend=True, normalizeToN15=False, subtractRef=None, legendLoc=4, lw=1.5, xMin=0, xMax=2000, scaleP=False, scaleI=0, scaleVal=1.0,\\r\\n figsize=(10,10), tLeft=0, tRight=-1, fixedOffset=False, noTicks=False, xlabel='mass', zlabel='intensity', a14=1.0): \\r\\n if listOfNames==None:\\r\\n listOfNames = listOfFilesToPlot\\r\\n if listOfColors==None:\\r\\n listOfColors = [pylab.cm.jet(float(i)/float(len(listOfFilesToPlot))) for i in range(len(listOfFilesToPlot))]\\r\\n \\r\\n fig = pylab.figure(figsize=figsize)\\r\\n ax = fig.add_subplot(111, projection='3d')\\r\\n\\r\\n yTotal = len(listOfFilesToPlot)\\r\\n top = 0.0\\r\\n\\r\\n if not (subtractRef is None):\\r\\n [bhah, zsRef, blah] = qMS.readMSSpectraFile(listOfFilesToPlot[subtractRef])\\r\\n #zsRef = list(numpy.array(zsRef)-fixedOffset\\r\\n zNorm = max(zsRef[len(zsRef)/2:])\\r\\n zsRef = numpy.array(zsRef)/zNorm\\r\\n \\r\\n for i,f in enumerate(listOfFilesToPlot):\\r\\n [xs, zs, name] = qMS.readMSSpectraFile(f)\\r\\n if fixedOffset:\\r\\n off = zs[len(zs)/2]\\r\\n print off\\r\\n #zs = list(numpy.array(zs)-zs[len(zs)/2])\\r\\n zs = list(numpy.array(zs)-off)\\r\\n ys = [yTotal-i]*len(xs)\\r\\n ys = numpy.array(ys)*yScale\\r\\n if normalizeToN15:\\r\\n zNorm = max(zs[len(zs)/2:])\\r\\n zs = numpy.array(zs)/zNorm\\r\\n if not (subtractRef is None):\\r\\n zNorm = max(zs[len(zs)/2:])\\r\\n zs = numpy.array(zs)/zNorm\\r\\n zs[:len(zsRef)/2] = zs[:len(zs)/2]-zsRef[:len(zsRef)/2]\\r\\n zs = zs*zNorm\\r\\n #xs = xs[:len(xs)/2]\\r\\n #ys = ys[:len(ys)/2]\\r\\n #zs = zs[:len(zs)/2]\\r\\n zs[:len(zs)/2] = numpy.array(zs[:len(zs)/2])*a14\\r\\n if (scaleP is True) and (i==scaleI):\\r\\n zs = numpy.array(zs)*scaleVal\\r\\n ax.plot(numpy.array(xs[tLeft:tRight]),numpy.array(ys[tLeft:tRight]),numpy.array(zs[tLeft:tRight]), color=listOfColors[i], lw=lw, label=listOfNames[i])\\r\\n top = max([top, float(max(zs))])\\r\\n\\r\\n\\r\\n ax.w_xaxis.pane.set_visible(False)\\r\\n ax.w_yaxis.pane.set_visible(False)\\r\\n ax.w_zaxis.pane.set_visible(False)\\r\\n\\r\\n if gridLines: \\r\\n ax.w_xaxis.gridlines.set_linewidth(1)\\r\\n ax.w_yaxis.gridlines.set_linewidth(1)\\r\\n ax.w_zaxis.gridlines.set_linewidth(1)\\r\\n \\r\\n else:\\r\\n ax.w_xaxis.gridlines.set_visible(False)\\r\\n ax.w_yaxis.gridlines.set_visible(False)\\r\\n ax.w_zaxis.gridlines.set_visible(False)\\r\\n\\r\\n [i.set_linewidth(1) for i in ax.w_xaxis.get_ticklines()]\\r\\n [i.set_linewidth(1) for i in ax.w_yaxis.get_ticklines()]\\r\\n [i.set_linewidth(1) for i in ax.w_zaxis.get_ticklines()]\\r\\n\\r\\n ax.w_xaxis.line.set_linewidth(1)\\r\\n ax.w_yaxis.line.set_linewidth(1)\\r\\n ax.w_zaxis.line.set_linewidth(1)\\r\\n \\r\\n ax.set_zticks([round(i,1) for i in [0, top/3, 2*top/3, top]])\\r\\n ax.set_zlim3d([0, top])\\r\\n ax.set_ylim3d(yMin, yMax)\\r\\n ax.set_yticks(range(1,yTotal+1))\\r\\n pylab.yticks(range(1,yTotal+1), ['']*yTotal)\\r\\n ax.set_xlim3d([xMin, xMax])\\r\\n \\r\\n if noTicks:\\r\\n ax.set_zticks([])\\r\\n ax.set_xticks([])\\r\\n ax.set_yticks([])\\r\\n\\r\\n ax.set_xlabel(xlabel)\\r\\n ax.set_zlabel(zlabel)\\r\\n\\r\\n ax.view_init(15, -60)\\r\\n if legend:\\r\\n pylab.legend(loc=legendLoc)\\r\\n \\r\\n pylab.tight_layout()\\r\\n return ax\",\n \"def plot_examples(cms):\\r\\n data = amp_axis\\r\\n\\r\\n fig, axs = plt.subplots(1, 2, figsize=(30, 8)) #create two plots\\r\\n for [ax, cmap] in zip(axs, cms):\\r\\n psm = ax.pcolormesh(time_axis, tof_axis, data, cmap=cmap, rasterized=True, vmin = 250) #specify axis and minimum amplitude value to show on the graph\\r\\n fig.colorbar(psm, ax=ax, label = 'Amplitude') #define the legend of the amplitude data\\r\\n \\r\\n ax.set_ylabel('Time of Flight [\\\\u03bcs]') #set label for y axis\\r\\n ax.set_xlabel('Time [min]') #set label for x axis\\r\\n \\r\\n ax.hlines(8.744, 0, stop_time, colors = 'white') #create two white lines for the safe operating range for ToF\\r\\n ax.hlines(9.555, 0, stop_time, colors = 'white') \\r\\n \\r\\n plt.show()\",\n \"def dataModel():\\n srcmap001 = fits.open('dataFiles/6gev_srcmap_001.fits')\\n srcmap03 = fits.open('dataFiles/6gev_srcmap_03.fits')\\n\\n image_data = fits.getdata('6gev_image.fits')\\n filename = get_pkg_data_filename('6gev_image.fits')\\n hdu = fits.open(filename)[0]\\n wcs = WCS(hdu.header)\\n\\n #Given the results of the fit, calculate the model\\n modelData001 = np.zeros(srcmap001[0].shape)\\n modelData03 = np.zeros(srcmap03[0].shape)\\n\\n file = open('plotsData/fitResults001.pk1','rb')\\n fit001 = pickle.load(file)\\n file.close()\\n\\n file = open('plotsData/fitResults03.pk1','rb')\\n fit03 = pickle.load(file)\\n file.close()\\n\\n\\n for source in fit001:\\n the_index = srcmap001.index_of(source)\\n\\n modelData001 += fit001[source][:, None, None]*srcmap001[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap001[the_index].data, axis=2), axis=1)[:-1, None, None]\\n for source in fit03:\\n the_index = srcmap03.index_of(source)\\n modelData03 += fit03[source][:, None, None]*srcmap03[the_index].data[:-1, :, :]/np.sum(np.sum(srcmap03[the_index].data, axis=2), axis=1)[:-1, None, None]\\n\\n fig = plt.figure(figsize=[12, 4.5])\\n\\n vmin = 0\\n vmax = 70.0\\n cbStep = 10.0\\n ax = fig.add_subplot(121, projection=wcs)\\n ax=plt.gca()\\n ax.tick_params(direction='in')\\n c = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax.get_transform('galactic'))\\n ax.add_patch(c)\\n mappable=plt.imshow((image_data),cmap='inferno',origin='lower',norm=colors.PowerNorm(gamma=0.6),vmin=vmin, vmax=vmax, interpolation='gaussian')#\\n plt.xlabel('Galactic Longitude')\\n plt.ylabel('Galactic Latitude')\\n plt.title('Data ($>6$ GeV)')\\n cb = plt.colorbar(mappable, label='Counts per pixel', pad=0.01,ticks=np.arange(vmin, vmax+cbStep, cbStep))\\n cb.ax.tick_params(width=0)\\n\\n\\n ax2=fig.add_subplot(122, projection=wcs)\\n ax2 = plt.gca()\\n\\n sources = []\\n sources.append({\\n 'Name':'3FGL J1745.3-2903c',\\n 'RA':266.3434922,\\n 'DEC':-29.06274323,\\n 'color':'xkcd:bright light blue'})\\n\\n sources.append({\\n 'Name':'1FIG J1748.2-2816',\\n 'RA':267.1000722,\\n 'DEC':-28.27707114,\\n 'color':'xkcd:fire engine red'\\n })\\n\\n sources.append({\\n 'Name':'1FIG J1746.4-2843',\\n 'RA':266.5942898,\\n 'DEC':-28.86244442,\\n 'color':'xkcd:fluorescent green'\\n })\\n\\n sources.append({\\n 'Name':'Galactic Center',\\n 'RA':266.417,\\n 'DEC':-29.0079,\\n 'color':'black'\\n })\\n\\n #Add source names:\\n for source in sources:\\n l, b = ra_dec_to_l_b(source['RA'], source['DEC'])\\n ax2.scatter(l, b, color=source['color'],marker='x',s=45.0, transform=ax2.get_transform('galactic'), label=source['Name'])\\n\\n c2 = Wedge((gc_l, gc_b), 1.0, theta1=0.0, theta2=360.0, width=14.0, edgecolor='black', facecolor='#474747', transform=ax2.get_transform('galactic'))\\n ax2.add_patch(c2)\\n mappable2 = plt.imshow((np.sum(modelData03,axis=0)), cmap='inferno',norm=colors.PowerNorm(gamma=0.6),origin='lower',vmin=vmin, vmax=vmax, interpolation='gaussian')\\n plt.xlabel('Galactic Longitude')\\n plt.ylabel('Galactic Latitude')\\n plt.title('Model ($>6$ GeV)')\\n cb2 = plt.colorbar(mappable2, label='Counts per pixel', pad=0.01, ticks=np.arange(vmin, vmax+cbStep, cbStep))\\n cb2.ax.tick_params(width=0)\\n leg = plt.legend(loc=1,frameon=True)\\n leg.get_frame().set_alpha(0.5)\\n leg.get_frame().set_edgecolor('white')\\n text1 = leg.get_texts()\\n for text in text1:\\n text.set_color('black')\\n\\n fig.tight_layout()\\n plt.subplots_adjust(wspace = 0.13, left=0.04, bottom=0.13, top=0.92)\\n plt.show()\\n #plt.savefig('plots/dataModelComparison.pdf',bbox_inches='tight')\",\n \"def P_AI_Rocky(in_dict):\\n # START\\n fs = 16\\n plt.rc('font', size=fs)\\n fig = plt.figure(figsize=(14,12))\\n ds = nc.Dataset(in_dict['fn'])\\n\\n # PLOT CODE\\n aa = [-122.8, -122.54, 47.92, 48.22]\\n import cmocean\\n cmap = cmocean.cm.balance\\n # cmap = 'RdYlBu_r'\\n\\n from warnings import filterwarnings\\n filterwarnings('ignore') # skip some warning messages\\n \\n # plot Code\\n \\n # calculate divergence and vorticity\\n uu = ds['u'][0, -1, :, :]\\n vv = ds['v'][0, -1, :, :]\\n u = zfun.fillit(uu)\\n v = zfun.fillit(vv)\\n u[np.isnan(u)] = 0\\n v[np.isnan(v)] = 0\\n \\n G = zrfun.get_basic_info(in_dict['fn'], only_G=True)\\n \\n dive = ((np.diff(u, axis=1)/G['DX'][:, 1:-1])[1:-1, :]\\n + (np.diff(v, axis = 0)/G['DY'][1:-1, :])[:, 1:-1])\\n #dive[G['mask_rho'][1:-1,1:-1]==False] = np.nan\\n \\n vort = np.diff(v, axis=1)/G['DX'][1:,1:] - np.diff(u, axis=0)/G['DY'][1:,1:]\\n #vort[G['mask_rho'][1:,1:]==False] = np.nan\\n \\n scl = 2e-3\\n \\n # panel 1\\n ax = fig.add_subplot(121)\\n # cs = plt.pcolormesh(G['lon_psi'], G['lat_psi'], dive/scl, cmap=cmap,\\n # vmin=-1, vmax=1)\\n cs = plt.pcolormesh(G['lon_rho'][1:-1,1:-1], G['lat_rho'][1:-1,1:-1], dive/scl, cmap=cmap,\\n vmin=-1, vmax=1, shading='gouraud')\\n tstr = (r'Surface Divergence (%0.1e $s^{-1}$)' % (scl))\\n #pfun.add_bathy_contours(ax, ds, txt=True)\\n pfun.add_coast(ax)\\n ax.axis(aa)\\n pfun.dar(ax)\\n ax.set_xlabel('Longitude')\\n ax.set_ylabel('Latitude')\\n ax.set_title(tstr)\\n pfun.add_info(ax, in_dict['fn'])\\n ax.set_xticks([-122.8, -122.7, -122.6])\\n ax.set_yticks([48, 48.1, 48.2])\\n #\\n # panel 2\\n ax = fig.add_subplot(122)\\n # cs = plt.pcolormesh(G['lon_rho'], G['lat_rho'], vort/scl, cmap=cmap,\\n # vmin=-1, vmax=1)\\n cs = plt.pcolormesh(G['lon_psi'], G['lat_psi'], vort/scl, cmap=cmap,\\n vmin=-1, vmax=1, shading='gouraud')\\n tstr = (r'Surface Vorticity (%0.1e $s^{-1}$)' % (scl))\\n ax.set_xticks([-122.8, -122.7, -122.6])\\n ax.set_yticks([])\\n #fig.colorbar(cs)\\n \\n # Inset colorbar\\n from mpl_toolkits.axes_grid1.inset_locator import inset_axes\\n cbaxes = inset_axes(ax, width=\\\"4%\\\", height=\\\"40%\\\", loc='lower left')\\n fig.colorbar(cs, cax=cbaxes, orientation='vertical')\\n \\n #pfun.add_bathy_contours(ax, ds)\\n pfun.add_coast(ax)\\n ax.axis(aa)\\n pfun.dar(ax)\\n ax.set_xlabel('Longitude')\\n ax.set_title(tstr) \\n \\n #fig.tight_layout()\\n # FINISH\\n ds.close()\\n if len(in_dict['fn_out']) > 0:\\n plt.savefig(in_dict['fn_out'])\\n plt.close()\\n else:\\n plt.show()\\n plt.rcdefaults()\",\n \"def plot_reconstruction_diagnostics(self, figsize=(20, 10)):\\n figs = []\\n fig_names = []\\n\\n # upsampled frequency\\n fx_us = tools.get_fft_frqs(2 * self.nx, 0.5 * self.dx)\\n fy_us = tools.get_fft_frqs(2 * self.ny, 0.5 * self.dx)\\n\\n # plot different stages of inversion\\n extent = tools.get_extent(self.fy, self.fx)\\n extent_upsampled = tools.get_extent(fy_us, fx_us)\\n\\n for ii in range(self.nangles):\\n fig = plt.figure(figsize=figsize)\\n grid = plt.GridSpec(3, 4)\\n\\n for jj in range(self.nphases):\\n\\n # ####################\\n # separated components\\n # ####################\\n ax = plt.subplot(grid[jj, 0])\\n\\n to_plot = np.abs(self.separated_components_ft[ii, jj])\\n to_plot[to_plot <= 0] = np.nan\\n plt.imshow(to_plot, norm=LogNorm(), extent=extent)\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 0:\\n plt.title('O(f)otf(f)')\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 1:\\n plt.title('m*O(f-fo)otf(f)')\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 2:\\n plt.title('m*O(f+fo)otf(f)')\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n # ####################\\n # deconvolved component\\n # ####################\\n ax = plt.subplot(grid[jj, 1])\\n\\n plt.imshow(np.abs(self.components_deconvolved_ft[ii, jj]), norm=LogNorm(), extent=extent)\\n\\n if jj == 0:\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 1:\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 2:\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 0:\\n plt.title('deconvolved component')\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n # ####################\\n # shifted component\\n # ####################\\n ax = plt.subplot(grid[jj, 2])\\n\\n # avoid any zeros for LogNorm()\\n cs_ft_toplot = np.abs(self.components_shifted_ft[ii, jj])\\n cs_ft_toplot[cs_ft_toplot <= 0] = np.nan\\n plt.imshow(cs_ft_toplot, norm=LogNorm(), extent=extent_upsampled)\\n plt.scatter(0, 0, edgecolor='r', facecolor='none')\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 1:\\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n elif jj == 2:\\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n if jj == 0:\\n plt.title('shifted component')\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n # ####################\\n # normalized weights\\n # ####################\\n ax = plt.subplot(grid[jj, 3])\\n\\n to_plot = self.weights[ii, jj] / self.weight_norm\\n to_plot[to_plot <= 0] = np.nan\\n im2 = plt.imshow(to_plot, norm=LogNorm(), extent=extent_upsampled)\\n im2.set_clim([1e-5, 1])\\n fig.colorbar(im2)\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 1:\\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n elif jj == 2:\\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n if jj == 0:\\n plt.title('normalized weight')\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n plt.suptitle('period=%0.3fnm at %0.3fdeg=%0.3frad, f=(%0.3f,%0.3f) 1/um\\\\n'\\n 'mod=%0.3f, min mcnr=%0.3f, wiener param=%0.2f\\\\n'\\n 'phases (deg) =%0.2f, %0.2f, %0.2f, phase diffs (deg) =%0.2f, %0.2f, %0.2f' %\\n (self.periods[ii] * 1e3, self.angles[ii] * 180 / np.pi, self.angles[ii],\\n self.frqs[ii, 0], self.frqs[ii, 1], self.mod_depths[ii, 1], np.min(self.mcnr[ii]), self.wiener_parameter,\\n self.phases[ii, 0] * 180/np.pi, self.phases[ii, 1] * 180/np.pi, self.phases[ii, 2] * 180/np.pi,\\n 0, np.mod(self.phases[ii, 1] - self.phases[ii, 0], 2*np.pi) * 180/np.pi,\\n np.mod(self.phases[ii, 2] - self.phases[ii, 0], 2*np.pi) * 180/np.pi))\\n\\n figs.append(fig)\\n fig_names.append('sim_combining_angle=%d' % (ii + 1))\\n\\n # #######################\\n # net weight\\n # #######################\\n figh = plt.figure(figsize=figsize)\\n grid = plt.GridSpec(1, 2)\\n plt.suptitle('Net weight, Wiener param = %0.2f' % self.wiener_parameter)\\n\\n ax = plt.subplot(grid[0, 0])\\n net_weight = np.sum(self.weights, axis=(0, 1)) / self.weight_norm\\n im = ax.imshow(net_weight, extent=extent_upsampled, norm=PowerNorm(gamma=0.1))\\n\\n figh.colorbar(im, ticks=[1, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 1e-2, 1e-3, 1e-4, 1e-5])\\n\\n ax.set_title(\\\"non-linear scale\\\")\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n circ2 = matplotlib.patches.Circle((0, 0), radius=2*self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ3)\\n\\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ4)\\n\\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ5)\\n\\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ6)\\n\\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ7)\\n\\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ8)\\n\\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\\n\\n ax = plt.subplot(grid[0, 1])\\n ax.set_title(\\\"linear scale\\\")\\n im = ax.imshow(net_weight, extent=extent_upsampled)\\n\\n figh.colorbar(im)\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n circ2 = matplotlib.patches.Circle((0, 0), radius=2 * self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ3)\\n\\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ4)\\n\\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ5)\\n\\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ6)\\n\\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ7)\\n\\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ8)\\n\\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\\n\\n figs.append(figh)\\n fig_names.append('net_weight')\\n\\n return figs, fig_names\",\n \"def plot(self, n_confs):\\n \\n import pandas as pd\\n import numpy as np\\n import matplotlib as mpl\\n mpl.use('Agg')\\n import matplotlib.pyplot as plt\\n import csv\\n \\n n_iter = len(self.plot_data)\\n \\n data = np.ndarray((n_iter, n_confs+1))\\n data[:,0] = [i[0] for i in self.plot_data]\\n data[:,1:] = [i[1].detach().cpu().numpy() for i in self.plot_data]\\n\\n df=pd.DataFrame(data)\\n names = ['iter']\\n for i in range(n_confs): names.append(f'c{i+1}')\\n df.columns = names\\n df.to_csv(f\\\"{self.plot_name}.tab\\\", sep=\\\"\\\\t\\\", quoting=csv.QUOTE_NONE) \\n\\n d = data[:,1:].reshape(-1)\\n d = d[~np.isnan(d)]\\n mine = d.min() - 0.01\\n for i in range(n_confs): \\n data[:,i+1] -= mine\\n \\n df=pd.DataFrame(data)\\n names = ['iter']\\n for i in range(n_confs): names.append(f'c{i+1}')\\n df.columns = names\\n \\n colors = (0,0,0)\\n area = 10\\n \\n # Plot\\n fig = plt.figure(figsize=(15, 15))\\n ax = fig.add_subplot(1,1,1)\\n for i in range(n_confs):\\n ax.plot('iter', f'c{i+1}', data=df)\\n ax.set_yscale('log')\\n\\n plt.xlabel('iter')\\n plt.ylabel('loss')\\n plt.savefig(f'{self.plot_name}.png')\",\n \"def ShowOneContourBKG(index,all_images,all_pointing,thex0,they0,all_titles,object_name,all_expo,dir_top_img,all_filt):\\n \\n figname='contourBKG_{}_{}.pdf'.format(all_filt[index],index)\\n \\n plt.figure(figsize=(15,6))\\n spec_index_min=100 # cut the left border\\n spec_index_max=1900 # cut the right border\\n star_halfwidth=70\\n \\n YMIN=-100\\n YMAX=100\\n \\n figfilename=os.path.join(dir_top_img,figname) \\n \\n #center is approximately the one on the original raw image (may be changed)\\n #x0=int(all_pointing[index][0])\\n x0=int(thex0[index])\\n \\n \\n # Extract the image \\n full_image=np.copy(all_images[index])\\n \\n # refine center in X,Y\\n star_region_X=full_image[:,x0-star_halfwidth:x0+star_halfwidth]\\n \\n profile_X=np.sum(star_region_X,axis=0)\\n profile_Y=np.sum(star_region_X,axis=1)\\n\\n NX=profile_X.shape[0]\\n NY=profile_Y.shape[0]\\n \\n X_=np.arange(NX)\\n Y_=np.arange(NY)\\n \\n avX,sigX=weighted_avg_and_std(X_,profile_X**4) # take squared on purpose (weigh must be >0)\\n avY,sigY=weighted_avg_and_std(Y_,profile_Y**4)\\n \\n x0=int(avX+x0-star_halfwidth)\\n \\n \\n # find the center in Y on the spectrum\\n yprofile=np.sum(full_image[:,spec_index_min:spec_index_max],axis=1)\\n y0=np.where(yprofile==yprofile.max())[0][0]\\n\\n # cut the image in vertical and normalise by exposition time\\n reduc_image=full_image[y0+YMIN:y0+YMAX,x0:spec_index_max]/all_expo[index] \\n reduc_image[:,0:100]=0 # erase central star\\n \\n X_Size_Pixels=np.arange(0,reduc_image.shape[1])\\n Y_Size_Pixels=np.arange(0,reduc_image.shape[0])\\n Transverse_Pixel_Size=Y_Size_Pixels-int(float(Y_Size_Pixels.shape[0])/2.)\\n \\n # calibration in wavelength\\n #grating_name=all_filt[index].replace('dia ','')\\n grating_name=get_disperser_filtname(all_filt[index])\\n \\n lambdas=Pixel_To_Lambdas(grating_name,X_Size_Pixels,all_pointing[index],True)\\n \\n #if grating_name=='Ron200':\\n # holo = Hologram('Ron400',verbose=True)\\n #else: \\n # holo = Hologram(grating_name,verbose=True)\\n #lambdas=holo.grating_pixel_to_lambda(X_Size_Pixels,all_pointing[index])\\n #if grating_name=='Ron200':\\n # lambdas=lambdas*2.\\n \\n\\n X,Y=np.meshgrid(lambdas,Transverse_Pixel_Size) \\n T=np.transpose(reduc_image)\\n \\n \\n cs=plt.contourf(X, Y, reduc_image, 100, alpha=1., cmap='jet',origin='lower')\\n #C = plt.contour(X, Y, reduc_image ,10, colors='white', linewidth=.01,origin='lower')\\n \\n cbar = plt.colorbar(cs) \\n \\n for line in LINES:\\n if line == O2 or line == HALPHA or line == HBETA or line == HGAMMA:\\n plt.plot([line['lambda'],line['lambda']],[YMIN,YMAX],'-',color='lime',lw=0.5)\\n plt.text(line['lambda'],YMAX*0.8,line['label'],verticalalignment='bottom', horizontalalignment='center',color='lime', fontweight='bold',fontsize=16)\\n \\n \\n \\n plt.axis([X.min(), X.max(), Y.min(), Y.max()]); plt.grid(True)\\n plt.title(all_titles[index])\\n plt.grid(color='white', ls='solid')\\n plt.text(200,-5.,all_filt[index],verticalalignment='bottom', horizontalalignment='center',color='yellow', fontweight='bold',fontsize=16)\\n plt.xlabel('$\\\\lambda$ (nm)')\\n plt.ylabel('pixels')\\n plt.ylim(YMIN,YMAX)\\n plt.xlim(0.,1200.)\\n plt.savefig(figfilename)\",\n \"def velocity_map(self, output='test'):\\n self.figure = figure(figsize=(10,3))\\n self.axes = self.figure.gca() \\n xWindowLim = (self.analyst.windowSize[0], self.analyst.windowSize[1])\\n yWindowLim = (self.analyst.windowSize[2], self.analyst.windowSize[3])\\n \\n # Generate contours for velocity magnitude \\n xGrid = linspace(\\\\\\n xWindowLim[0]*self.millimetersPerPixel, \\n xWindowLim[1]*self.millimetersPerPixel, self.nbins)\\n yGrid = linspace(\\\\\\n yWindowLim[0]*self.millimetersPerPixel, \\n yWindowLim[1]*self.millimetersPerPixel, self.nbins)\\n magVelGrid = griddata(self.xs, self.ys, self.magVel, xGrid, yGrid) \\n # csf = self.axes.contourf(xGrid, yGrid, magVelGrid, range(2,26,2), cmap=myColorMap)\\n csf = self.axes.contourf(xGrid, yGrid, magVelGrid, cmap=myColorMap)\\n cbar = self.figure.colorbar(csf) \\n cbar.set_label(\\\"Velocity magnitude, px/s\\\")\\n \\n # Generate arrow plot\\n # q = self.axes.quiver(self.xs, self.ys, self.us, self.vs,\\n # angles = 'xy', scale_units='xy', scale=2, pivot = 'mid')\\n # self.axes.quiverkey(q, 0.9, 1.0, 10, \\\"10 px/frame\\\", coordinates='axes') \\n \\n # Save figure \\n self.axes.set_aspect('equal')\\n self.axes.set_xlim(*xWindowLim)\\n self.axes.set_ylim(*yWindowLim)\\n self.figure.savefig(output + '_velocity_map.pdf')\",\n \"def heatmap(filename, data):\\n\\n fig, ax = ppl.subplots(1)\\n ppl.pcolormesh(fig, ax, data, vmin=-0.0016, vmax=0.0016)\\n fig.savefig(filename + \\\".png\\\")\",\n \"def plot_source_residuals_comparison(source_truth, source_model_list, name_list, \\n vmin_res=-0.5, vmax_res=-0.5, cmap='cubehelix',\\n fontsize=12):\\n n_model = len(source_model_list)\\n fig, axes = plt.subplots(1+n_model, 2, figsize=(9, (1+n_model)*3.5))\\n axes[0, 1].axis('off')\\n ax = axes[0, 0]\\n #ax.get_xaxis().set_visible(False)\\n #ax.get_yaxis().set_visible(False)\\n ax.set_title(\\\"true source\\\", fontsize=fontsize)\\n im = ax.imshow(source_truth, cmap=cmap, vmin=0)\\n lims = (len(source_truth)/4, 3*len(source_truth)/4) # zoom a bit on the image\\n #ax.set_xlim(*lims)\\n #ax.set_ylim(*lims)\\n plot_util.nice_colorbar(im, label=\\\"flux\\\", fontsize=fontsize)\\n \\n i = 1\\n for source_model, name in zip(source_model_list, name_list):\\n print(\\\"min/max for source model '{}': {}/{}\\\".format(name, source_model.min(), source_model.max()))\\n\\n residuals_source = source_model - source_truth\\n\\n ax = axes[i, 0]\\n ax.set_title(\\\"model '{}'\\\".format(name), fontsize=fontsize)\\n #ax.get_xaxis().set_visible(False)\\n #ax.get_yaxis().set_visible(False)\\n im = ax.imshow(source_model, cmap=cmap)\\n #ax.set_xlim(*lims)\\n #ax.set_ylim(*lims)\\n plot_util.nice_colorbar(im, label=\\\"flux\\\", fontsize=fontsize)\\n \\n ax = axes[i, 1]\\n #ax.get_xaxis().set_visible(False)\\n #ax.get_yaxis().set_visible(False)\\n ax.set_title(\\\"difference\\\", fontsize=fontsize)\\n #ax.set_xlim(*lims)\\n #ax.set_ylim(*lims)\\n im = ax.imshow(residuals_source, cmap='RdBu_r', vmin=vmin_res, vmax=vmax_res)\\n plot_util.nice_colorbar_residuals(im, residuals_source, vmin_res, vmax_res,\\n label=r\\\"f${}_{\\\\rm model}$ - f${}_{\\\\rm truth}$\\\", fontsize=fontsize)\\n \\n print(\\\"SDR for model '{}' = {:.3f}\\\".format(name, metrics_util.SDR(source_truth, source_model)))\\n i += 1\\n\\n return fig\",\n \"def plot_images_grid(x: torch.tensor, export_img, title: str = '', nrow=6, padding=2, normalize=False, pad_value=0, save = True, apply_transforms = False):\\n logger = logging.getLogger()\\n global global_counter\\n #if apply_transforms:\\n # #global_counter = 0\\n \\n # transform = transforms.Compose([\\n # #transforms.ToPILImage(),transforms.Lambda(lambda x: transforms.functional.adjust_brightness(x, brightness_factor = 1.1)),\\n # #transforms.Lambda(lambda x: normalize_to_zero_one_range(x)),\\n # transforms.Lambda(lambda x: tensor_to_img(x)),\\n # transforms.Lambda(lambda x: save_img_patch(x, prefix = 'original')),\\n # transforms.Lambda(lambda x: generate_NCUT_segmented_image(x)),\\n # transforms.Lambda(lambda x: save_img_patch(x, prefix = 'NCUT')),\\n # #transforms.Lambda(lambda x: draw_feature_contours(x)),\\n # transforms.ToTensor() \\n # ])\\n \\n # for i in range(x.shape[0]): \\n # try:\\n # x[i] = transform(x[i])\\n # except:\\n # logger.error(\\\"Exception occurred while appliying transform {}\\\".format( sys.exc_info()[0]))\\n # logger.error(\\\"Was processing image number {} with global counter {}\\\".format(str(i), global_counter))\\n\\n grid = make_grid(x, nrow=nrow, padding=padding, normalize=normalize, pad_value=pad_value)\\n npgrid = grid.detach().cpu().numpy()\\n\\n plt.imshow(np.transpose(npgrid, (1, 2, 0)), interpolation='nearest')\\n\\n ax = plt.gca()\\n ax.xaxis.set_visible(False)\\n ax.yaxis.set_visible(False)\\n\\n if not (title == ''):\\n plt.title(title)\\n if (save == True):\\n plt.savefig(export_img, bbox_inches='tight', pad_inches=0.1)\\n else:\\n plt.show()\\n plt.clf()\",\n \"def plot_map(priors):\\n sns.set_style(\\\"white\\\")\\n\\n cmap=sns.cubehelix_palette(8, start=.5, rot=-.75,as_cmap=True)\\n hdulists=list(map(lambda prior:postmaps.make_fits_image(prior,prior.sim), priors))\\n fig = plt.figure(figsize=(10*len(priors),10))\\n figs=[]\\n for i in range(0,len(priors)):\\n figs.append(aplpy.FITSFigure(hdulists[i][1],figure=fig,subplot=(1,len(priors),i+1)))\\n\\n for i in range(0,len(priors)):\\n vmin=np.min(priors[i].sim)\\n vmax=np.max(priors[i].sim)\\n figs[i].show_colorscale(vmin=vmin,vmax=vmax,cmap=cmap)\\n figs[i].show_markers(priors[i].sra, priors[i].sdec, edgecolor='black', facecolor='black',\\n marker='o', s=20, alpha=0.5)\\n figs[i].tick_labels.set_xformat('dd.dd')\\n figs[i].tick_labels.set_yformat('dd.dd')\\n figs[i].add_colorbar()\\n figs[i].colorbar.set_location('top')\\n return figs,fig\",\n \"def _plot_images(self):\\n # Plot sagittal (0), coronal (1) or axial (2) view\\n self._images = dict(base=list(), cursor_v=list(), cursor_h=list(),\\n bounds=list())\\n img_min = np.nanmin(self._base_data)\\n img_max = np.nanmax(self._base_data)\\n text_kwargs = dict(fontsize='medium', weight='bold', color='#66CCEE',\\n family='monospace', ha='center', va='center',\\n path_effects=[patheffects.withStroke(\\n linewidth=4, foreground=\\\"k\\\", alpha=0.75)])\\n xyz = apply_trans(self._ras_vox_t, self._ras)\\n for axis in range(3):\\n plot_x_idx, plot_y_idx = self._xy_idx[axis]\\n fig = self._figs[axis]\\n ax = fig.axes[0]\\n img_data = np.take(self._base_data, self._current_slice[axis],\\n axis=axis).T\\n self._images['base'].append(ax.imshow(\\n img_data, cmap='gray', aspect='auto', zorder=1,\\n vmin=img_min, vmax=img_max))\\n img_extent = self._img_extents[axis] # x0, x1, y0, y1\\n w, h = np.diff(np.array(img_extent).reshape(2, 2), axis=1)[:, 0]\\n self._images['bounds'].append(Rectangle(\\n img_extent[::2], w, h, edgecolor='w', facecolor='none',\\n alpha=0.25, lw=0.5, zorder=1.5))\\n ax.add_patch(self._images['bounds'][-1])\\n v_x = (xyz[plot_x_idx],) * 2\\n v_y = img_extent[2:4]\\n self._images['cursor_v'].append(ax.plot(\\n v_x, v_y, color='lime', linewidth=0.5, alpha=0.5, zorder=8)[0])\\n h_y = (xyz[plot_y_idx],) * 2\\n h_x = img_extent[0:2]\\n self._images['cursor_h'].append(ax.plot(\\n h_x, h_y, color='lime', linewidth=0.5, alpha=0.5, zorder=8)[0])\\n # label axes\\n self._figs[axis].text(0.5, 0.05, _IMG_LABELS[axis][0],\\n **text_kwargs)\\n self._figs[axis].text(0.05, 0.5, _IMG_LABELS[axis][1],\\n **text_kwargs)\\n self._figs[axis].axes[0].axis(img_extent)\\n self._figs[axis].canvas.mpl_connect(\\n 'scroll_event', self._on_scroll)\\n self._figs[axis].canvas.mpl_connect(\\n 'button_release_event', partial(self._on_click, axis=axis))\\n # add head and brain in mm (convert from m)\\n if self._head is None:\\n logger.info('Using marching cubes on CT for the '\\n '3D visualization panel')\\n rr, tris = _marching_cubes(np.where(\\n self._base_data < np.quantile(self._base_data, 0.95), 0, 1),\\n [1])[0]\\n rr = apply_trans(self._vox_ras_t, rr)\\n self._renderer.mesh(\\n *rr.T, triangles=tris, color='gray', opacity=0.2,\\n reset_camera=False, render=False)\\n else:\\n self._renderer.mesh(\\n *self._head['rr'].T * 1000, triangles=self._head['tris'],\\n color='gray', opacity=0.2, reset_camera=False, render=False)\\n if self._lh is not None and self._rh is not None:\\n self._renderer.mesh(\\n *self._lh['rr'].T * 1000, triangles=self._lh['tris'],\\n color='white', opacity=0.2, reset_camera=False, render=False)\\n self._renderer.mesh(\\n *self._rh['rr'].T * 1000, triangles=self._rh['tris'],\\n color='white', opacity=0.2, reset_camera=False, render=False)\\n self._renderer.set_camera(azimuth=90, elevation=90, distance=300,\\n focalpoint=tuple(self._ras))\\n # update plots\\n self._draw()\\n self._renderer._update()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64044726","0.63224024","0.6253856","0.61958474","0.6189722","0.60908437","0.60695","0.606345","0.6026868","0.6024125","0.5955344","0.5922822","0.5906817","0.58775115","0.58641946","0.58604985","0.5835713","0.5813257","0.5810878","0.580833","0.57819027","0.5766788","0.5760945","0.57604176","0.5756126","0.57543445","0.5740251","0.5739379","0.5737627","0.57358754","0.5709445","0.5689798","0.5689757","0.5688604","0.5687","0.56799173","0.56617576","0.56558585","0.56466645","0.5645196","0.5641833","0.5637683","0.5632807","0.5632519","0.56204003","0.56108075","0.56096894","0.560222","0.5596639","0.55953044","0.5593281","0.55890936","0.5586366","0.5584876","0.5561086","0.55545485","0.5550792","0.555014","0.55485666","0.5543171","0.55430675","0.5532661","0.55313075","0.5528594","0.55251473","0.5524672","0.5515665","0.55085385","0.55060846","0.5504462","0.55029327","0.5495471","0.54937476","0.54934084","0.5493233","0.5492019","0.5486623","0.5480352","0.5479762","0.5472831","0.547069","0.54662704","0.54646057","0.54616284","0.5456721","0.5455606","0.54508173","0.5447961","0.54430836","0.54290885","0.5426834","0.5425931","0.54234546","0.54224527","0.54221827","0.54195035","0.5418809","0.5416877","0.54148686","0.5412325"],"string":"[\n \"0.64044726\",\n \"0.63224024\",\n \"0.6253856\",\n \"0.61958474\",\n \"0.6189722\",\n \"0.60908437\",\n \"0.60695\",\n \"0.606345\",\n \"0.6026868\",\n \"0.6024125\",\n \"0.5955344\",\n \"0.5922822\",\n \"0.5906817\",\n \"0.58775115\",\n \"0.58641946\",\n \"0.58604985\",\n \"0.5835713\",\n \"0.5813257\",\n \"0.5810878\",\n \"0.580833\",\n \"0.57819027\",\n \"0.5766788\",\n \"0.5760945\",\n \"0.57604176\",\n \"0.5756126\",\n \"0.57543445\",\n \"0.5740251\",\n \"0.5739379\",\n \"0.5737627\",\n \"0.57358754\",\n \"0.5709445\",\n \"0.5689798\",\n \"0.5689757\",\n \"0.5688604\",\n \"0.5687\",\n \"0.56799173\",\n \"0.56617576\",\n \"0.56558585\",\n \"0.56466645\",\n \"0.5645196\",\n \"0.5641833\",\n \"0.5637683\",\n \"0.5632807\",\n \"0.5632519\",\n \"0.56204003\",\n \"0.56108075\",\n \"0.56096894\",\n \"0.560222\",\n \"0.5596639\",\n \"0.55953044\",\n \"0.5593281\",\n \"0.55890936\",\n \"0.5586366\",\n \"0.5584876\",\n \"0.5561086\",\n \"0.55545485\",\n \"0.5550792\",\n \"0.555014\",\n \"0.55485666\",\n \"0.5543171\",\n \"0.55430675\",\n \"0.5532661\",\n \"0.55313075\",\n \"0.5528594\",\n \"0.55251473\",\n \"0.5524672\",\n \"0.5515665\",\n \"0.55085385\",\n \"0.55060846\",\n \"0.5504462\",\n \"0.55029327\",\n \"0.5495471\",\n \"0.54937476\",\n \"0.54934084\",\n \"0.5493233\",\n \"0.5492019\",\n \"0.5486623\",\n \"0.5480352\",\n \"0.5479762\",\n \"0.5472831\",\n \"0.547069\",\n \"0.54662704\",\n \"0.54646057\",\n \"0.54616284\",\n \"0.5456721\",\n \"0.5455606\",\n \"0.54508173\",\n \"0.5447961\",\n \"0.54430836\",\n \"0.54290885\",\n \"0.5426834\",\n \"0.5425931\",\n \"0.54234546\",\n \"0.54224527\",\n \"0.54221827\",\n \"0.54195035\",\n \"0.5418809\",\n \"0.5416877\",\n \"0.54148686\",\n \"0.5412325\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.703744"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21294,"cells":{"query":{"kind":"string","value":"Use gdal/osr to get latlon point location from georeferenced array indices"},"document":{"kind":"string","value":"def ind2latlon(index, filePath):\n # Load georeferencing\n ds = gdal.Open(filePath)\n proj = ds.GetProjection()\n gt = ds.GetGeoTransform()\n srs = osr.SpatialReference()\n srs.ImportFromWkt(proj)\n\n x0 = gt[0] #top left longitude\n y0 = gt[3] #top left latitude\n dx = gt[1] #pixel width\n dy = gt[5] #pixel height\n\n # Convert row,col of array to projected coords\n row, col = index\n x = x0 + (col * dx)\n y = y0 + (row * dy)\n\n # Convert projected coords to latlon\n trs = osr.SpatialReference()\n trs.ImportFromEPSG(4326)\n ct = osr.CoordinateTransformation(srs, trs)\n\n (lon, lat, height) = ct.TransformPoint(x, y) #note could add elevation\n #gdal.DecToDMS(lat, 'Lat', 2)\n\n return lon, lat"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def find_coord_indices(lon_array, lat_array, lon_points, lat_points, proj_str):\n\n proj = Proj(proj_str)\n proj_lon, proj_lat = np.array(proj(lon_array, lat_array)) # transform to distances using specified projection\n lonlat = np.column_stack(\n (proj_lon.ravel(), proj_lat.ravel())) # Stack all coarse x, y distances for array shape (n, 2)\n ll = np.array(proj(lon_points, lat_points)).T # transform lists of fine grid x, y to match shape (n, 2)\n idx = cdist(lonlat, ll).argmin(0) # Calculate all distances and get index of minimum\n\n return np.column_stack((np.unravel_index(idx, lon_array.shape))).tolist()","def geo_idx(dd, dd_array):\r\n geo_idx = (np.abs(dd_array - np.float(dd))).argmin()\r\n return geo_idx","def ndarray_to_location(array: np.ndarray) -> carla.Location: # pylint: disable=no-member\n return carla.Location(*list(map(float, array))) # pylint: disable=no-member","def geo_idx(dd, dd_array):\n geo_idx = (np.abs(dd_array - dd)).argmin()\n return geo_idx","def find_lon_lat_of_indices(indices, dir, tile):\n \n filename_pattern = '*grid.tile{0}.nc'.format(tile)\n for f_name in os.listdir(dir):\n if fnmatch.fnmatch(f_name, filename_pattern):\n filename = f_name\n if not filename:\n message = 'No filenames matching the pattern {0} found in {1}'.format(filename_pattern,dir)\n logging.critical(message)\n raise Exception(message)\n \n nc_file = Dataset('{0}/{1}'.format(dir,filename))\n #read in supergrid longitude and latitude\n lon_super = np.array(nc_file['x']) #[lat,lon] or [y,x] #.swapaxes(0,1)\n lat_super = np.array(nc_file['y']) #[lat,lon] or [y,x] #.swapaxes(0,1)\n #get the longitude and latitude data for the grid centers by slicing the supergrid \n #and taking only odd-indexed values\n longitude = lon_super[1::2,1::2]\n latitude = lat_super[1::2,1::2]\n nc_file.close()\n \n return (longitude[indices[1],indices[0]], latitude[indices[1],indices[0]])","def getclosest_ij(lats,lons,latpt,lonpt):\n dist_lat = (lats-latpt)**2 # find squared distance of every point on grid\n dist_lon = (lons-lonpt)**2\n minindex_lat = dist_lat.argmin() # 1D index of minimum dist_sq element\n minindex_lon = dist_lon.argmin()\n return minindex_lat, minindex_lon # Get 2D index for latvals and lonvals arrays from 1D index","def getclosest_ij(lats,lons,latpt,lonpt):\n dist_lat = (lats-latpt)**2 # find squared distance of every point on grid\n dist_lon = (lons-lonpt)**2\n minindex_lat = dist_lat.argmin() # 1D index of minimum dist_sq element\n minindex_lon = dist_lon.argmin()\n return minindex_lat, minindex_lon # Get 2D index for latvals and lonvals arrays from 1D index","def geo_idx(dd, dd_array):\r\n geo_idx = (np.abs(dd_array - dd)).argmin()\r\n return geo_idx","def _raster_index_to_coords(i, j, bounds = [[-100, -100], [100, 100]],\n dx = 1, dy = 1):\n x = (j+0.5)*dx + bounds[0][0]\n y = (i+0.5)*dy + bounds[0][1]\n return x, y","def get_coordinates_geo(self):\n if not self.rotated:\n lon_arr_geo = self.lon_arr\n lat_arr_geo = self.lat_arr\n else:\n lon_arr_geo, lat_arr_geo = self.transform().get_coordinates() \n\n return lon_arr_geo, lat_arr_geo","def find_stn_idx(ref_lon, ref_lat, tlon, tlat):\n\n # compute great circle distance from location to model grid points\n dist = gc_dist(ref_lon, ref_lat, tlon, tlat)\n\n # find the indices of the two closest grid points with distinct longitudes\n work = N.take(dist,N.argmin(dist,0),0).diagonal()\n Jlist = N.argsort(work)[:2]\n del work\n\n # find the indices of the two closest grid points with distinct latitudes\n work = N.take(dist,N.argmin(dist,1),1).diagonal()\n Ilist = N.argsort(work)[:2]\n del work\n\n return Ilist, Jlist","def point_coords(geom):\n # Return a tuple with the x/y point coordinate for a GeoDataFrame geometry\n return list(geom.coords)[0] # Just get first tuple in list, since it's a point","def get_idx(lons, lats, lon, lat):\n dist = ((lons - lon) ** 2 + (lats - lat) ** 2) ** 0.5\n return np.unravel_index(dist.argmin(), dist.shape)","def get_geo_coordinates(\n index_y: int,\n index_x: int,\n tile_coordinates: tuple,\n):\n # Predefining variables for calculation\n # Setting up r, radius of world with given pixel values.\n mollweide_center_width = 72000\n mollweide_center_height = 36000\n sqrt2 = math.sqrt(2)\n r = (__GLOBE_WIDTH / 2) / 2 / sqrt2\n\n # Get actual x, y coordinates using the indices\n y_2d = index_y + (4000 * tile_coordinates[1]) - mollweide_center_height\n x_2d = index_x + (4000 * tile_coordinates[0]) - mollweide_center_width\n\n # Start Mollweide projection calculations based on indices\n theta = math.asin(y_2d / r / sqrt2)\n latitude = math.asin((2 * theta + math.sin(2 * theta)) / math.pi)\n longitude = math.pi * x_2d / 2 / r / sqrt2 / math.cos(theta)\n return latitude, longitude","def _get_voronoi_centroid_array(lsm_lat_array, lsm_lon_array, extent):\n YMin = extent[2]\n YMax = extent[3]\n XMin = extent[0]\n XMax = extent[1]\n\n ptList = []\n if (lsm_lat_array.ndim == 2) and (lsm_lon_array.ndim == 2):\n # generate point list with 2D lat lon lists\n if extent:\n # exctract subset within extent\n lsm_dx = np.max(np.absolute(np.diff(lsm_lon_array)))\n lsm_dy = np.max(np.absolute(np.diff(lsm_lat_array, axis=0)))\n\n # remove values with NaN\n lsm_lat_array = np.ma.filled(lsm_lat_array, fill_value=-9999)\n lsm_lon_array = np.ma.filled(lsm_lon_array, fill_value=-9999)\n\n lsm_lat_indices_from_lat, lsm_lon_indices_from_lat = \\\n np.where((lsm_lat_array >= (YMin - 2*lsm_dy)) &\n (lsm_lat_array <= (YMax + 2*lsm_dy)))\n lsm_lat_indices_from_lon, lsm_lon_indices_from_lon = \\\n np.where((lsm_lon_array >= (XMin - 2*lsm_dx)) &\n (lsm_lon_array <= (XMax + 2*lsm_dx)))\n\n lsm_lat_indices = np.intersect1d(lsm_lat_indices_from_lat,\n lsm_lat_indices_from_lon)\n lsm_lon_indices = np.intersect1d(lsm_lon_indices_from_lat,\n lsm_lon_indices_from_lon)\n\n lsm_lat_list = \\\n lsm_lat_array[lsm_lat_indices, :][:, lsm_lon_indices]\n lsm_lon_list = \\\n lsm_lon_array[lsm_lat_indices, :][:, lsm_lon_indices]\n # Create a list of geographic coordinate pairs\n for i in range(len(lsm_lat_indices)):\n for j in range(len(lsm_lon_indices)):\n ptList.append([lsm_lon_list[i][j], lsm_lat_list[i][j]])\n\n elif lsm_lat_array.ndim == 1 and lsm_lon_array.ndim == 1:\n # generate point list with 1D lat lon lists\n if extent:\n Ybuffer = 2 * abs(lsm_lat_array[0]-lsm_lat_array[1])\n Xbuffer = 2 * abs(lsm_lon_array[0]-lsm_lon_array[1])\n # Extract the lat and lon within buffered extent\n # (buffer with 2* interval degree)\n lsm_lat_list = lsm_lat_array[(lsm_lat_array >= (YMin - Ybuffer)) &\n (lsm_lat_array <= (YMax + Ybuffer))]\n lsm_lon_list = lsm_lon_array[(lsm_lon_array >= (XMin - Xbuffer)) &\n (lsm_lon_array <= (XMax + Xbuffer))]\n\n # Create a list of geographic coordinate pairs\n for ptX in lsm_lon_list:\n for ptY in lsm_lat_list:\n ptList.append([ptX, ptY])\n else:\n raise IndexError(\"Lat/Lon lists have invalid dimensions. \"\n \"Only 1D or 2D arrays allowed ...\")\n\n if len(ptList) <= 0:\n raise IndexError(\"The watershed is outside of the bounds of the\"\n \" land surface model grid ...\")\n\n return np.array(ptList) # set-up for input to Delaunay","def read_gdal_coordinates(dataset, mode=\"center\"):\n coordinates_pixel = _pixel_coordinates(\n dataset.RasterXSize, dataset.RasterYSize, mode\n )\n\n geotransform = dataset.GetGeoTransform()\n coordinates = _pixel_to_map(coordinates_pixel, geotransform)\n\n return coordinates","def lat_lons(self):","def geo(self):\n return vec2geo_linear_signed(self)","def nearest_lat_lon_index(point, latitudes, longitudes):\n stacked = da.stack((latitudes.flatten(), longitudes.flatten())).transpose()\n closest = get_nearest(da.array(point).reshape(-1, 1).transpose(), stacked)\n idx = np.unravel_index(closest[0], latitudes.shape)\n return idx","def build_spatial_index(vector_path):\r\n vector = gdal.OpenEx(vector_path)\r\n layer = vector.GetLayer()\r\n geom_index = rtree.index.Index()\r\n geom_list = []\r\n for index in range(layer.GetFeatureCount()):\r\n feature = layer.GetFeature(index)\r\n geom = feature.GetGeometryRef()\r\n shapely_geom = shapely.wkb.loads(geom.ExportToWkb())\r\n shapely_prep_geom = shapely.prepared.prep(shapely_geom)\r\n geom_list.append(shapely_prep_geom)\r\n geom_index.insert(index, shapely_geom.bounds)\r\n\r\n return geom_index, geom_list","def location(self):\n return np.array((self.latitude, self.longitude))","def location(self):\n return np.array((self.latitude, self.longitude))","def spatial(self):","def point_location(tri, p): \n simplex_index = tri.find_simplex(p)\n bc = []\n for id_, point in zip(simplex_index, p):\n # Calculate the two first barycentric coordinates for the relevant\n # simplex\n b = tri.transform[id_, :2].dot(point-tri.transform[id_, 2])\n bc.append(np.c_[np.atleast_2d(b), 1-b.sum()])\n # Create the full array and squeeze the shit out of it\n bc = np.array(bc).squeeze()\n return simplex_index, bc","def geofind():\n return render_template('geo_find.html')","def Indexes(self, latitudes, longitudes):\n res = self._transform.TransformPoints(\n np.column_stack((longitudes, latitudes)))\n res = list(zip(*res))\n x, y = np.array(res[0]), np.array(res[1])\n idx_col = self._inv_txf[0] + self._inv_txf[1] * x + self._inv_txf[2] * y\n idx_row = self._inv_txf[3] + self._inv_txf[4] * x + self._inv_txf[5] * y\n return idx_row.astype(int), idx_col.astype(int)","def loc(self):\n return self._gev_bijector.loc","def obs_ijpos(gridfile,lons,lats,coor):\n\n gfh= netCDF4.Dataset(gridfile)\n cartesian=0\n if (coor=='r'):\n try:\n \n latr=gfh.variables['lat_rho'][:,:]\n lonr=gfh.variables['lon_rho'][:,:]\n except:\n latr=gfh.variables['latitude'][:,:]\n lonr=gfh.variables['longitude'][:,:]\n \n\n try:\n xr=gfh.variables['xi_rho'][:]\n yr=gfh.variables['eta_rho'][:]\n except:\n try:\n xr=gfh.variables['x_rho'][:]\n yr=gfh.variables['y_rho'][:]\n except:\n print('Neither xi_rho/eta_rho or x_rho/y_rho on file.')\n print('This might slow down the calculations')\n\n\n elif (coor=='u'):\n latr=gfh.variables['lat_u'][:,:]\n lonr=gfh.variables['lon_u'][:,:]\n try:\n xr=gfh.variables['xi_u'][:]\n yr=gfh.variables['eta_u'][:]\n except:\n xr=gfh.variables['x_u'][:]\n yr=gfh.variables['y_u'][:]\n elif (coor=='v'):\n latr=gfh.variables['lat_v'][:,:]\n lonr=gfh.variables['lon_v'][:,:]\n try:\n xr=gfh.variables['xi_v'][:]\n yr=gfh.variables['eta_v'][:]\n except:\n xr=gfh.variables['x_v'][:]\n yr=gfh.variables['y_v'][:]\n\n IN = point_in_polygon(lonr, latr, lons, lats)\n ind=np.where(IN)[0]\n \n if lats.size >1: \n lons=lons[ind]; lats=lats[ind]\n # If there's no lons, lats left at this stage, return oipos, ojpos with -999 everywhere\n if not len(lons):\n return np.ones_like(IN)*-999, np.ones_like(IN)*-999\n \n try:\n try:\n mapstr=str(gfh.variables['h'].getncattr('mapping'))\n except:\n try:\n mapstr=str(gfh.variables['h'].getncattr('grid_mapping'))\n except:\n pass\n try:\n projstring=(gfh.variables[mapstr]).getncattr('proj4')\n except:\n try:\n projstring=(gfh.variables[mapstr]).getncattr('proj4string')\n except:\n pass\n try:\n projstring=(gfh.variables['grid_mapping']).getncattr('proj4')\n except:\n try:\n projstring=(gfh.variables['grid_mapping']).getncattr('proj4string')\n except:\n pass\n\n gridproj=proj.Proj(str(projstring))\n hasproj=1\n except:\n hasproj=0\n\n # Check if lat, lon spacing is uniform\n dx1=np.abs(lonr[0,1]-lonr[0,0])\n dx2=np.abs(lonr[0,-1]-lonr[0,-2])\n n=int(np.round(lonr.shape[1]/2))\n dx3=np.abs(lonr[0,n]-lonr[0,n-1])\n\n dy1=np.abs(latr[1,0]-latr[0,0])\n dy2=np.abs(latr[-1,0]-latr[-2,0])\n n=int(np.round(latr.shape[0]/2))\n dy3=np.abs(latr[n,0]-latr[n-1,0])\n\n if ( (dx1 == dx2) & (dx1==dx3) & (dx2==dx3) & (dy1 == dy2) & (dy1==dy3) & (dy2==dy3) ):\n cartesian=1\n gridproj=proj.Proj(\"+proj=latlong +datum=WGS84\")\n \n\n \n if hasproj:\n dx=xr[1]-xr[0]\n dy=yr[1]-yr[0]\n [x,y]=gridproj(lons,lats)\n ipos=(x-xr[0])/dx\n jpos=(y-yr[0])/dy\n\n elif cartesian:\n [x1,y1]=gridproj(lonr[0,0],latr[0,0])\n [x2,y2]=gridproj(lonr[0,1],latr[0,1])\n dx=x2-x1\n [x2,y2]=gridproj(lonr[1,0],latr[1,0])\n dy=y2-y1\n [x,y]=gridproj(lons,lats)\n [x0,y0]=gridproj(lonr[0,0],latr[0,0])\n\n ipos=(x-x0)/dx\n jpos=(y-y0)/dy\n\n else:\n x=np.linspace(0,lonr.shape[1]-1,lonr.shape[1])\n y=np.linspace(0,lonr.shape[0]-1,lonr.shape[0])\n xi=np.zeros_like(lonr); yi=np.zeros([lonr.shape[1],lonr.shape[0]])\n xi[:,:]=x; yi[:,:]=y; yi=np.swapaxes(yi,1,0)\n zi=scipy.interpolate.griddata((lonr.flatten(),latr.flatten()),xi.flatten(),(lons,lats))\n ipos=zi\n zi=scipy.interpolate.griddata((lonr.flatten(),latr.flatten()),yi.flatten(),(lons,lats))\n jpos=zi\n \n if 'ind' in locals():\n oipos=np.ones(IN.shape)*-999.; ojpos=np.ones(IN.shape)*-999.\n oipos[ind]=ipos; ojpos[ind]=jpos\n else:\n oipos=ipos\n ojpos=jpos\n if not IN:\n oipos = np.array([-999.])\n ojpos = np.array([-999.])\n gfh.close()\n return oipos,ojpos","def feature_coords(features):\n coords_list = []\n for feature in features:\n coord_start = feature.location.nofuzzy_start\n coord_end = feature.location.nofuzzy_end\n coord_pair = (coord_start, coord_end)\n coords_list.append(coord_pair)\n ## consider adding some info to the log\n return coords_list","def get_signif_locs(da, lat, lon): \n y = lat[np.where(da.values > 0)[0]].values\n x = lon[np.where(da.values > 0)[1]].values\n return [(x[i], y[i]) for i in range(len(x))]","def test_G_ind(self):\r\n a = array([[29, 11], [273, 191], [8, 31], [64, 64]])\r\n self.assertFloatEqual(G_ind(a)[0], 28.59642)\r\n self.assertFloatEqual(G_ind(a, True)[0], 28.31244)","def fn2lonlat(filename):\n tokens = filename.split(\"/\")[-1].rsplit(\".\", 1)[0].split(\"x\")\n return [0 - float(tokens[0]), float(tokens[1])]","def find_stn(ref_lon, ref_lat, tlon, tlat):\n\n # find the indices of the 4 model grid points around the location\n Ilist, Jlist = find_stn_idx(ref_lon, ref_lat, tlon, tlat)\n\n # get the 4 model grid points longitudes and latitudes\n lonlist = []\n latlist = []\n for i in Ilist:\n for j in Jlist:\n lonlist.append(tlon[i,j])\n latlist.append(tlat[i,j])\n\n # convert Python lists to numpy arrays\n lonlist = N.array(lonlist)\n latlist = N.array(latlist)\n\n return lonlist, latlist","def _find_coordinates(self, coords, ref):\n result = []\n temp_fastq_length = 500\n reference_seq = ''\n with open(ref) as f:\n lines = f.readlines()[1:]\n for line in lines:\n reference_seq += line.strip()\n with open('temp_index/temp_index.fasta', 'w') as fw:\n fw.write('>{}\\n{}'.format(self.read_id, self.seq))\n subprocess.run('bwa index temp_index/temp_index.fasta', shell=True, stdout=FNULL, stderr=subprocess.STDOUT)\n for coord in coords:\n with open('temp_index/coordinate_rDNA.fastq', 'w') as fw:\n fw.write('>temp\\n{}\\n+\\n{}\\n'.format(reference_seq[coord-1:coord+temp_fastq_length-1], 'J' * temp_fastq_length))\n # with -a option, multiple hits are more clearly shown\n utilities.bwa_mapping('temp_index/temp_index.fasta', 'temp_index/coordinate_rDNA.fastq', 'temp_index/temp_sam4coord.sam', multi=True)\n with open('temp_index/temp_sam4coord.sam') as samf:\n map_result = samf.readlines()[2:]\n for mapping in map_result:\n row = mapping.strip().split()\n AS = int(mapping.strip().split('AS:i:')[1].split()[0])\n flag = int(row[1])\n if utilities.easy_flag(flag, 16) != 1:\n direction = '+'\n else:\n direction = '-'\n mapped_coord = int(row[3])\n if AS > 0.3 * temp_fastq_length:\n result.append([coord, mapped_coord, direction])\n return result","def _get_ij_(lats, lons, lat, lon):\n _ij_ = (np.argmin(np.abs(lats-lat)), np.argmin(np.abs(lons-lon)))\n return _ij_","def test_coords():\n x = np.array([8, 67, 79, 10, 52, 53, 98, 34, 15, 58], dtype=float)\n y = np.array([24, 87, 48, 94, 98, 66, 14, 24, 60, 16], dtype=float)\n\n return x, y","def getCoords(geom):\n geomDict = eval(geom.ExportToJson())\n coords = geomDict['coordinates']\n if geomDict['type'] == 'Polygon':\n coordsArray = numpy.array(coords[0])\n elif geomDict['type'] == 'MultiPoint':\n coordsArray = numpy.array(coords)\n else:\n coordsArray = None\n return coordsArray","def get_ecmwf_lat_lon(nc_file):\n from netCDF4 import Dataset\n \n fh = Dataset(nc_file, mode='r')\n\n latitude_ecmwf = fh.variables['latitude_ecmwf'][:]\n longitude_ecmwf = fh.variables['longitude_ecmwf'][:]\n\n lonmesh_ecmwf,latmesh_ecmwf = np.meshgrid(longitude_ecmwf,latitude_ecmwf)\n\n print('latitude_ecmwf: ', latitude_ecmwf.shape)\n print('longitude_ecmwf: ', longitude_ecmwf.shape)\n \n return latitude_ecmwf, longitude_ecmwf, latmesh_ecmwf, lonmesh_ecmwf;","def pixelloc_to_geoloc(row, col, loff, coff):\n row = np.atleast_1d(row)\n col = np.atleast_1d(col)\n\n assert row.shape == col.shape\n\n lat, lon = _nav.pixelloc_to_geoloc(row, col, loff, coff)\n\n if lat.size == lon.size == 1:\n # Return scalars\n return lat[0], lon[0]\n else:\n return lat, lon","def project(self, latitude, longitude):\n longitude = longitude if longitude > 0 else 360 + longitude\n\n lon_array = self.ecmwf_data.longitude\n lat_array = self.ecmwf_data.latitude\n\n # Find in the lon_array / lat_array the index interval\n # Including lon_ul and lat_ul\n a_lon = np.where((lon_array < longitude))[0][-1]\n if longitude > lon_array.max():\n # lon is between 359.6 and 0 ...\n b_lon = 0\n else:\n b_lon = np.where((lon_array >= longitude))[0][0]\n\n a_lat = np.where((lat_array < latitude))[0][0]\n b_lat = np.where((lat_array >= latitude))[0][-1]\n\n # Compute geo extent around the point :\n # => extent definition : LR,LL,UL,UR\n extent = [lon_array[a_lon], lat_array[a_lat],\n lon_array[b_lon], lat_array[a_lat],\n lon_array[b_lon], lat_array[b_lat],\n lon_array[a_lon], lat_array[b_lat]]\n\n extent_index = [a_lon, a_lat,\n b_lon, a_lat,\n b_lon, b_lat,\n a_lon, b_lat]\n\n log.info(' - Selected vertex : ')\n log.info('LL (px,ln) / (lon,lat) : (%s, %s) / (%s dd , %s dd)' % (\n str(extent_index[0]), str(extent_index[1]), str(extent[0]), str(extent[1])))\n log.info('LR (px,ln) / (lon,lat) : (%s, %s) / (%s dd , %s dd)' % (\n str(extent_index[2]), str(extent_index[3]), str(extent[2]), str(extent[3])))\n log.info('UR (px,ln) / (lon,lat) : (%s, %s) / (%s dd , %s dd)' % (\n str(extent_index[4]), str(extent_index[5]), str(extent[4]), str(extent[5])))\n log.info('UL (px,ln) / (lon,lat) : (%s, %s) / (%s dd , %s dd)' % (\n str(extent_index[6]), str(extent_index[7]), str(extent[6]), str(extent[7])))\n\n # TIE Point grid defined - compute linear transformation\n # to estimate value at the lat/lon location\n # origin : extent_ul[0], extent_ul[1]\n delta_lon = 0.4 # extent[4] - extent[6] # UR - UL\n delta_lat = -0.4 # extent[1] - extent[7] # LL - UL\n\n lambda_lat = latitude - extent[7]\n lambda_lon = longitude - extent[6]\n\n beta_longitude = lambda_lon / delta_lon\n beta_latitude = lambda_lat / delta_lat\n\n # Processing of all keys\n for key in self.ecmwf_data.mandatory_attributes:\n M = getattr(self.ecmwf_data, key)\n v = self.linear_estimate(M,\n beta_latitude,\n beta_longitude,\n extent_index)\n setattr(self, key, v)","def shot_geolocations(self) -> geopandas.array.GeometryArray:\n geolocations = np.array(\n [shapely.geometry.Point(lon, lat) for lon, lat in self.shot_lon_lat],\n dtype=shapely.geometry.Point,\n )\n\n return geopandas.array.GeometryArray(geolocations, crs=WGS84)","def get_coords(data, id):\n return data[id]['lat'], data[id]['lon']","def geotiff_read(ifile,metaData):\r\n\r\n file = gdal.Open(ifile, GA_ReadOnly)\r\n\r\n projection = file.GetProjection()\r\n src = osr.SpatialReference()\r\n src.ImportFromWkt(projection)\r\n proj = src.ExportToWkt()\r\n\r\n Nx = file.RasterXSize\r\n Ny = file.RasterYSize\r\n\r\n trans = file.GetGeoTransform()\r\n\r\n dx = trans[1]\r\n dy = trans[5]\r\n\r\n if metaData == \"A\":\r\n\r\n xp = np.arange(Nx)\r\n yp = np.arange(Ny)\r\n\r\n (Xp, Yp) = np.meshgrid(xp,yp)\r\n\r\n X = trans[0] + (Xp+0.5)*trans[1] + (Yp+0.5)*trans[2] #FIXME: bottleneck!\r\n Y = trans[3] + (Xp+0.5)*trans[4] + (Yp+0.5)*trans[5]\r\n\r\n if metaData == \"P\":\r\n\r\n xp = np.arange(Nx)\r\n yp = np.arange(Ny)\r\n\r\n (Xp, Yp) = np.meshgrid(xp,yp)\r\n\r\n X = trans[0] + Xp*trans[1] + Yp*trans[2] #FIXME: bottleneck!\r\n Y = trans[3] + Xp*trans[4] + Yp*trans[5]\r\n\r\n band = file.GetRasterBand(1)\r\n\r\n Z = band.ReadAsArray()\r\n\r\n dx = np.abs(dx)\r\n dy = np.abs(dy)\r\n\r\n return X, Y, Z, dx, dy, proj","def get_location(self):\n ret = _pal.Mat4x4()\n _pal.lib.geometry_get_location(self._geometry, ret)\n return [x for x in ret]","def getSearchSpaceCoords(self):","def fix_location(r):\n \n # all is fine: just change zipcode datatype to str\n if not np.isnan(r['zip']) and not np.isnan(r['lat']):\n return [str(int(r['zip'])), r['lng'], r['lat']]\n \n # try to locate within zipcode polygons\n if not np.isnan(r['lat']):\n query = \"\"\"\n SELECT t.geoid as zip, {} as lng, {} as lat\n FROM us_zcta5 t JOIN usps_zcta5 z ON t.geoid = z.zip\n WHERE ST_Contains(t.shape, ST_GeomFromText('POINT({} {})', 2))\n \"\"\"\n res = pd.read_sql(query.format(r['lng'], r['lat'], r['lng'], r['lat']), con = con)\n if len(res) == 1:\n return res.values[0].tolist()\n\n # use zipcode center as location proxy: geocoding is prefered in this case, but might be quite expensive\n if not np.isnan(r['zip']):\n res = zipcodes[zipcodes['zip'] == str(int(r['zip']))]\n if len(res) == 1:\n return res.values[0].tolist()[:3]\n\n return [None, None, None]","def convertView2Geo(self, x, y):\n\n # x_pix is from left map edge, y_pix from top map edge\n x_pix = x + self.view_offset_x\n y_pix = y + self.view_offset_y\n\n lon = self.map_llon + x_pix/self.ppd_x\n lat = self.map_tlat - y_pix/self.ppd_y\n\n return (lon, lat)","def morton_idx(pts):\n lib = _initlib()\n p = require(pts, dtype=float64, requirements=['C']) \n inv_cell_width = 1.0/8192\n npts = len(p)\n out = empty(npts, dtype=int64)\n lib.get_morton_idx(p, npts, inv_cell_width, out)\n return out","def _get_clip_loc_in_array(self):\r\n\r\n # coordinates of upperleft and lowerright points of binding box\r\n box_ulx, box_uly, box_lrx, box_lry = self.clip_box[0][0], self.clip_box[0][1], \\\r\n self.clip_box[1][0], self.clip_box[1][1]\r\n\r\n # Get the offsets that correspond to the bounding box corner coordinates.\r\n offsets_ul = gdal.ApplyGeoTransform(self.inv_gt, box_ulx, box_uly)\r\n offsets_lr = gdal.ApplyGeoTransform(self.inv_gt, box_lrx, box_lry)\r\n\r\n # The offsets are returned as floating point, but we need integers.\r\n self.off_ulx, self.off_uly = map(int, offsets_ul)\r\n self.off_lrx, self.off_lry = map(int, offsets_lr)\r\n\r\n # Compute the numbers of rows and columns to extract, based on the offsets.\r\n self.row = self.off_lry - self.off_uly\r\n self.column = self.off_lrx - self.off_ulx","def get_xyz_coord(path):\r\n\tlabels = loadmat(path)\r\n\tanno_xyz = []\r\n\tfor index in range(0, 1500):\r\n\t\tanno_xyz.append([])\r\n\t\tfor i in range(0, 21):\r\n\t\t\tx = labels['handPara'][0][i][index]\r\n\t\t\ty = labels['handPara'][1][i][index]\r\n\t\t\tz = labels['handPara'][2][i][index]\r\n\t\t\tanno_xyz[-1].append([x, y, z])\r\n\tanno_xyz = np.array(anno_xyz)\r\n\t# anno_xyz = np.reshape(labels['handPara'], (1500, 21, 3))\r\n\treturn anno_xyz","def nearlonlat_zl(lon,lat,lonp,latp): # needed for the next function get_FVCOM_bottom_temp \r\n # approximation for small distance \r\n cp=np.cos(latp*np.pi/180.) \r\n dx=(lon-lonp)*cp\r\n dy=lat-latp \r\n xi=np.argmin(abs(dx)) \r\n yi=np.argmin(abs(dy))\r\n min_dist=111*np.sqrt(dx[xi]**2+dy[yi]**2)\r\n return xi,yi,min_dist","def array_coords(shape=(1, 1)):\n indexes = np.arange(np.product(shape))\n coords = [indexes % shape[1], indexes // shape[1]]\n return np.transpose(coords).astype('float64')","def vector(self):\n return np.array([self.lat, self.lng])","def get_idx_from_latlon(self, latitudes, longitudes, unique=False):\n try:\n lat_idx = [np.argmin(np.abs(self.lat - lat)) for lat in latitudes]\n lon_idx = [np.argmin(np.abs(self.lon - lon)) for lon in longitudes]\n if unique:\n ijdx = np.vstack({(i, j) for i, j in zip(lat_idx, lon_idx)})\n lat_idx = ijdx[:, 0].tolist()\n lon_idx = ijdx[:, 1].tolist()\n except TypeError:\n lat_idx = np.argmin(np.abs(self.lat - latitudes))\n lon_idx = np.argmin(np.abs(self.lon - longitudes))\n\n return lat_idx, lon_idx","def _initialize_geospatial_data(self):\n driver = ogr.GetDriverByName(\"ESRI Shapefile\")\n\n bnd_src = driver.Open(self._spatial_filename, 0)\n bnd_lyr = bnd_src.GetLayer()\n (self.spatial_index,\n self.spatial_feats,\n self.bison_spatial_fields\n ) = self._create_spatial_index(bnd_lyr)","def get_zone_pixels(feat, input_zone_polygon, input_value_raster, band, coords=[]): #, raster_band\n \n \n \n # Open data\n raster = gdal.Open(input_value_raster)\n shp = ogr.Open(input_zone_polygon)\n lyr = shp.GetLayer()\n \n # Get raster georeference info\n transform = raster.GetGeoTransform()\n xOrigin = transform[0]\n yOrigin = transform[3]\n pixelWidth = transform[1]\n pixelHeight = transform[5]\n \n sizeX = raster.RasterXSize\n sizeY = raster.RasterYSize\n lrx = xOrigin + (sizeX * pixelWidth)\n lry = yOrigin + (sizeY * pixelHeight)\n \n \n \n # Reproject vector geometry to same projection as raster\n #sourceSR = lyr.GetSpatialRef()\n #targetSR = osr.SpatialReference()\n #targetSR.ImportFromWkt(raster.GetProjectionRef())\n #coordTrans = osr.CoordinateTransformation(sourceSR,targetSR)\n #feat = lyr.GetNextFeature()\n #geom = feat.GetGeometryRef()\n #geom.Transform(coordTrans)\n \n # Get extent of feat\n geom = feat.GetGeometryRef()\n if (geom.GetGeometryName() == 'MULTIPOLYGON'):\n count = 0\n pointsX = []; pointsY = []\n for polygon in geom:\n geomInner = geom.GetGeometryRef(count)\n ring = geomInner.GetGeometryRef(0)\n numpoints = ring.GetPointCount()\n for p in range(numpoints):\n lon, lat, z = ring.GetPoint(p)\n pointsX.append(lon)\n pointsY.append(lat)\n count += 1\n elif (geom.GetGeometryName() == 'POLYGON'):\n ring = geom.GetGeometryRef(0)\n numpoints = ring.GetPointCount()\n pointsX = []; pointsY = []\n for p in range(numpoints):\n lon, lat, z = ring.GetPoint(p)\n pointsX.append(lon)\n pointsY.append(lat)\n\n else:\n sys.exit(\"ERROR: Geometry needs to be either Polygon or Multipolygon\")\n\n #xmin = min(pointsX) \n #xmax = max(pointsX)\n #ymin = min(pointsY)\n #ymax = max(pointsY)\n \n \n if len(coords) == 0: \n xmin = xOrigin if (min(pointsX) < xOrigin) else min(pointsX)\n xmax = lrx if (max(pointsX) > lrx) else max(pointsX)\n ymin = lry if (min(pointsY) < lry) else min(pointsY)\n ymax = yOrigin if (max(pointsY) > yOrigin) else max(pointsY)\n else:\n xmin = coords[0] if (min(pointsX) < coords[0]) else min(pointsX)\n xmax = coords[1] if (max(pointsX) > coords[1]) else max(pointsX)\n ymin = coords[2] if (min(pointsY) < coords[2]) else min(pointsY)\n ymax = coords[3] if (max(pointsY) > coords[3]) else max(pointsY)\n \n # Specify offset and rows and columns to read\n xoff = int((xmin - xOrigin)/pixelWidth)\n yoff = int((yOrigin - ymax)/pixelWidth)\n xcount = int((xmax - xmin)/pixelWidth) #+1 !!!!!!!!!!!!!!!!!!!!! This adds a pixel to the right side\n ycount = int((ymax - ymin)/pixelWidth) #+1 !!!!!!!!!!!!!!!!!!!!! This adds a pixel to the bottom side\n \n #print(xoff, yoff, xcount, ycount)\n \n # Create memory target raster\n target_ds = gdal.GetDriverByName('MEM').Create('', xcount, ycount, 1, gdal.GDT_Byte)\n target_ds.SetGeoTransform((\n xmin, pixelWidth, 0,\n ymax, 0, pixelHeight,\n ))\n\n # Create for target raster the same projection as for the value raster\n raster_srs = osr.SpatialReference()\n raster_srs.ImportFromWkt(raster.GetProjectionRef())\n target_ds.SetProjection(raster_srs.ExportToWkt())\n\n # Rasterize zone polygon to raster\n gdal.RasterizeLayer(target_ds, [1], lyr, burn_values=[1])\n\n # Read raster as arrays\n dataBandRaster = raster.GetRasterBand(band)\n data = dataBandRaster.ReadAsArray(xoff, yoff, xcount, ycount).astype(np.float)\n bandmask = target_ds.GetRasterBand(1)\n datamask = bandmask.ReadAsArray(0, 0, xcount, ycount).astype(np.float)\n\n # data zone of raster\n dataZone = np.ma.masked_array(data, np.logical_not(datamask))\n\n raster_srs = None\n raster = None\n shp = None\n lyr = None\n return [dataZone, [xmin,xmax,ymin,ymax]]","def get_lat_lon():\r\n\r\n # Columns: dt,AverageTemperature,AverageTemperatureUncertainty,City,Country,Latitude,Longitude\r\n temperatures = pd.read_csv(\"GlobalLandTemperatures/GlobalLandTemperaturesByCity.csv\")\r\n\r\n Latitude = temperatures['Latitude']\r\n Longitude = temperatures['Longitude']\r\n City = temperatures['City']\r\n Country = temperatures['Country']\r\n\r\n lat_array = []\r\n long_array = []\r\n cities_array = []\r\n countries_array = []\r\n tuples = []\r\n for i, j, city, country in zip(Latitude, Longitude, City, Country):\r\n if (i, j) not in tuples:\r\n tuples.append((i, j))\r\n lat_array.append(float(i[:-1]))\r\n long_array.append(float(j[:-1]))\r\n cities_array.append(city)\r\n countries_array.append(country)\r\n\r\n return lat_array, long_array, cities_array, countries_array","def get_coordinates(geotags) -> Tuple[float, float]:\n lat = get_decimal_from_dms(\n geotags['GPSLatitude'],\n geotags['GPSLatitudeRef'],\n )\n lon = get_decimal_from_dms(\n geotags['GPSLongitude'],\n geotags['GPSLongitudeRef'],\n )\n\n return lat, lon","def extract_loc_vec(ref_lon, ref_lat, tlon, tlat, indata):\n\n # find the indices of the 4 model grid points around the location\n Ilist, Jlist = find_stn_idx(ref_lon, ref_lat, tlon, tlat)\n\n # compute great circle distance from location to model grid points\n dist = gc_dist(ref_lon, ref_lat, tlon, tlat)\n dist[dist==0] = 1.e-15 # avoid division by zero\n\n ibeg, iend = Ilist.min(), Ilist.max()\n jbeg, jend = Jlist.min(), Jlist.max()\n work = indata[...,ibeg:iend+1,jbeg:jend+1]\n dist = dist[...,ibeg:iend+1,jbeg:jend+1]\n wghts = 1./N.resize(dist,work.shape)\n wavg = MA.average(work.reshape(work.shape[:-2]+(-1,)),\n weights=wghts.reshape(work.shape[:-2]+(-1,)),axis=-1)\n\n return wavg","def _get_point_source_location(element):\n pos = element.find('%s/%s/%s' %\n (NRML04_POINT_GEOMETRY, gml.GML_POINT, gml.GML_POS))\n pos = pos.text.split()\n\n return float(pos[0]), float(pos[1])","def global_coords(self) -> GlobalCoordsABC:","def find_coordinates(self):\n\n raise NotImplementedError","def find_coordinates(self):\n\n raise NotImplementedError","def latlons(self):\n\t\t\n\t\t# First check we have a grid feature type\n\t\tif self.featuretype in ['Grid', 'GridSeries']:\n\n\t\t\tlatvar = self.latitude_variable\n\t\t\tlonvar = self.longitude_variable\n\n\t\t\tlatdims = self.coordinates_mapping['latitude']['map']\n\t\t\tlondims = self.coordinates_mapping['longitude']['map']\n\n\t\t\t# Create latitude and longitude subset slices from the field subset slices\n\t\t\tlat_subset = []\n\t\t\tfor dim in latdims:\n\t\t\t\tlat_subset.append(self._subset[dim])\n\t\t\t\n\t\t\tlon_subset = []\n\t\t\tfor dim in londims:\n\t\t\t\tlon_subset.append(self._subset[dim])\n\n\t\t\t# Then check if latitude and longitude variables are 1D\n\t\t\tif len(latvar.shape) == 1 and len(lonvar.shape) == 1:\n\t\t\t\tlatvar_2d = latvar[lat_subset].reshape((-1,1)).repeat(lonvar.shape[0], axis=1)\n\t\t\t\tlonvar_2d = lonvar[lon_subset].reshape((-1,1)).transpose().repeat(latvar.shape[0], axis=0)\n\t\t\t\treturn (latvar_2d, lonvar_2d)\n\t\t\t\n\t\t\t# for 2D variables its easy, just return the variable data\n\t\t\telif len(latvar.shape) >= 2 and len(lonvar.shape) >= 2:\n\t\t\t\t\n\t\t\t\t# Handle the WRF case where lat/lon variables are 3D with time as first dimension\n\t\t\t\tif len(latvar.shape) == 3 and len(lonvar.shape) == 3:\n\t\t\t\t\treturn (latvar[0,lat_subset], lonvar[0,lon_subset])\n\t\t\t\telse:\n\t\t\t\t\treturn (latvar[lat_subset], lonvar[lon_subset])\n\t\t\t\n\t\t\t# otherwise, we can't do it!\n\t\t\telse:\n\t\t\t\treturn (None, None)\n\t\t\n\t\telif self.featuretype == 'PointSeries':\n\t\t\treturn (self.latitude_variable[:], self.longitude_variable[:])","def CreateTargetGeoMap(latS, latN, lonW, lonE, latlen, lonlen):\n\n lat_grid = np.linspace(latS, latN, latlen)\n lon_grid = np.linspace(lonW, lonE, lonlen)\n\n return lat_grid,lon_grid","def _dense_point_array(self, geoms, distance, index):\n # interpolate lines to represent them as points for Voronoi\n points = []\n ids = []\n\n if pygeos.get_type_id(geoms[0]) not in [1, 2, 5]:\n lines = pygeos.boundary(geoms)\n else:\n lines = geoms\n lengths = pygeos.length(lines)\n for ix, line, length in zip(index, lines, lengths):\n if length > distance: # some polygons might have collapsed\n pts = pygeos.line_interpolate_point(\n line,\n np.linspace(0.1, length - 0.1, num=int((length - 0.1) // distance)),\n ) # .1 offset to keep a gap between two segments\n points.append(pygeos.get_coordinates(pts))\n ids += [ix] * len(pts)\n\n points = np.vstack(points)\n\n return points, ids\n\n # here we might also want to append original coordinates of each line\n # to get a higher precision on the corners","def retrieve_pixel_value(lon, lat, data_source):\n dataset = gdal.Open(data_source)\n\n gt = dataset.GetGeoTransform()\n the_band = dataset.GetRasterBand(1)\n px = int((lon - gt[0]) / gt[1]) # x pixel\n py = int((lat - gt[3]) / gt[5]) # y pixel\n\n buf = the_band.ReadRaster(px, py, 1, 1, buf_type=gdal.GDT_Int16)\n elev = struct.unpack(\"h\", buf)\n\n return elev[0]","def geoloc_to_pixelloc(lat, lon, loff, coff):\n lat = np.atleast_1d(lat)\n lon = np.atleast_1d(lon)\n\n assert lat.shape == lon.shape\n\n row, col = _nav.geoloc_to_pixelloc(lat, lon, loff, coff)\n\n if row.size == col.size == 1:\n # Return scalars\n return row[0], col[0]\n else:\n return row, col","def get_exif_location(self, exif_data, lonlat):\n\n if lonlat=='lonlat':\n lat = ''\n lon = ''\n gps_latitude = self._get_if_exist(exif_data, 'GPS GPSLatitude')\n gps_latitude_ref = self._get_if_exist(exif_data, 'GPS GPSLatitudeRef')\n gps_longitude = self._get_if_exist(exif_data, 'GPS GPSLongitude')\n gps_longitude_ref = self._get_if_exist(exif_data, 'GPS GPSLongitudeRef')\n\n if gps_latitude and gps_latitude_ref and gps_longitude and gps_longitude_ref:\n lat = self._convert_to_degress(gps_latitude)\n if gps_latitude_ref.values[0] != 'N':\n lat = 0 - lat\n\n lon = self._convert_to_degress(gps_longitude)\n if gps_longitude_ref.values[0] != 'E':\n lon = 0 - lon\n\n return lat, lon","def map_to_local(self, idxs):\n return F.zerocopy_from_dgl_ndarray(\n _CAPI_DGLNDArrayPartitionMapToLocal(\n self._partition, F.zerocopy_to_dgl_ndarray(idxs)\n )\n )","def read_coordinates(self, channel=\"1\"):\n\n sdsidx = {\"VNIR\": (0, 1), \"SWIR\": (6, 7), \"TIR\": (14, 15)}\n\n latstr = \":\".join(\n (\n \"HDF4_SDS\",\n \"UNKNOWN\",\n f\"{self.filename}\",\n f\"{sdsidx[self.channel2sensor[channel]][0]}\",\n )\n )\n lat = gdal.Open(latstr)\n lat = geocentric2geodetic(lat.ReadAsArray().astype(\"float\"))\n\n lonstr = \":\".join(\n (\n \"HDF4_SDS\",\n \"UNKNOWN\",\n f\"{self.filename}\",\n f\"{sdsidx[self.channel2sensor[channel]][1]}\",\n )\n )\n lon = gdal.Open(lonstr)\n lon = lon.ReadAsArray().astype(\"float\")\n\n return lat, lon","def extract_raw_simple_coordinates (raw_location):\n pattern = re.compile('(\\d+).(\\d+)?')\n x_result = pattern.match(str(raw_location[0]))\n y_result = pattern.match(str(raw_location[1]))\n return int(x_result[1]), int(y_result[1])","def get_location(self):\n # h = b'\\r\\nAT-MSGEO\\r\\r\\n-MSGEO: -3936,3464,-3612,7402d50c\\r\\n\\r\\n'\n # an example of the string returned from the AT-MSGEO used for testing.\n h = self.acquire_response(b'AT-MSGEO')\n if isinstance(h, bytes):\n h = h.decode('utf-8')\n h = h.strip()\n h = h.split(':')\n h = h[1].split(',')\n x = int(h[0])*1000 # Convert coordinates to meters.\n y = int(h[1])*1000\n z = int(h[2])*1000\n else:\n print('Location not available')\n\n # 'geocent' refers to the geo-centered frame that the co-ordinates are returned in\n inProj = Proj(proj='geocent', ellps='WGS84', datum='WGS84')\n\n # 'latlong' is the frame to be converted to\n outProj = Proj(proj='latlong', ellps='WGS84', datum='WGS84')\n\n # Convert X, Y, Z to latitude, longitude and altitude\n long, lat, alt = transform(inProj, outProj, x, y, z, radians=False)\n # l = [str(long), str(lat), str(alt)]\n return long, lat, alt","def get_lat(idx, header, randomize=False):\n lat = header[Y_CORNER] + header[N_ROWS] - idx - 0.5\n if randomize:\n lat += np.random.normal(-0.5, 1, size=lat.shape)\n return lat","def _get_grid_cell_indexes(proj, xs, ys, bounding_box):\n # Unpack values from the projection\n eq_rad = proj.semi_major_axis\n polar_rad = proj.semi_minor_axis\n h = proj.perspective_point_height + eq_rad\n lon0 = proj.longitude_of_projection_origin\n \n # Unpack values from the area we want to grab the data\n min_lat, min_lon = bounding_box.sw_corner()\n max_lat, max_lon = bounding_box.ne_corner()\n \n with np.errstate(invalid='ignore'):\n # Calculate the lat and lon grids\n xs, ys = np.meshgrid(xs, ys)\n a_vals = np.power(np.sin(xs), 2.0) + \\\n np.power(np.cos(xs), 2.0) * (np.power(np.cos(ys), 2.0) + \\\n eq_rad * eq_rad / polar_rad / polar_rad * np.power(np.sin(ys), 2.0))\n b_vals = -2 * h * np.cos(xs) * np.cos(ys)\n c_val = h * h - eq_rad * eq_rad\n \n rs = (-b_vals - np.sqrt(np.power(b_vals, 2.0) - 4 * a_vals * c_val)) / (2 * a_vals)\n \n sx = rs * np.cos(xs) * np.cos(ys)\n sy = -rs * np.sin(xs)\n sz = rs * np.cos(xs) * np.sin(ys)\n \n lats = np.arctan((eq_rad *eq_rad * sz) \\\n / (polar_rad * polar_rad * np.sqrt(np.power(h - sx, 2.0) + np.power(sy, 2.0))))\n lats = np.degrees(lats)\n \n lons = np.radians(lon0) - np.arctan(sy / (h - sx))\n lons = np.degrees(lons)\n \n # Flatten the arrays so we get a 1D list of indexes\n lats = lats.flatten()\n lons = lons.flatten()\n \n # Filter out values not in our bounding box\n lats = np.where(np.logical_and(lats >= min_lat, lats <= max_lat))[0]\n lons = np.where(np.logical_and(lons >= min_lon, lons <= max_lon))[0]\n idxs = list(set(lons).intersection(set(lats)))\n \n return idxs","def _generate_coords(self):\n coords = np.dstack([self.X.ravel(), self.Y.ravel()])[0]\n return coords, spatial.cKDTree(coords)","def best_coords(self):\n lat, lon = None, None\n for term in self.terms:\n # print(term)\n # print(term['weight'])\n geo = term.get(\"geo\")\n if geo:\n osm = geo['osm']\n gm = geo['gm']\n geo_data = None\n if osm:\n geo_data = osm\n elif gm:\n geo_data = gm\n if geo_data:\n g = geo_data[0]\n lat, lon = g['latitude'], g['longitude']\n break\n return lat, lon, self.region","def latlonsel(array, lat, lon, latname='lat', lonname='lon'):\n assert latname in array.coords, f\"Coord. {latname} not present in array\"\n assert lonname in array.coords, f\"Coord. {lonname} not present in array\"\n\n if isinstance(lat, slice):\n lat1 = lat.start\n lat2 = lat.stop\n elif isinstance(lat, list):\n lat1 = lat[0]\n lat2 = lat[-1]\n if isinstance(lon, slice):\n lon1 = lon.start\n lon2 = lon.stop\n elif isinstance(lon, list):\n lon1 = lon[0]\n lon2 = lon[-1]\n\n lonmask = (array[lonname] < lon2) & (array[lonname] > lon1)\n latmask = (array[latname] < lat2) & (array[latname] > lat1)\n array = array.where(lonmask, drop=True).where(latmask, drop=True)\n return array","def get_latlon():\n\t\n iss.compute() # Get the lat/long values from ephem\n long_value = [float(i) for i in str(iss.sublong).split(\":\")]\n if long_value[0] < 0:\n long_value[0] = abs(long_value[0])\n cam.exif_tags['GPS.GPSLongitudeRef'] = \"W\"\n else:\n cam.exif_tags['GPS.GPSLongitudeRef'] = \"E\"\n cam.exif_tags['GPS.GPSLongitude'] = '%d/1,%d/1,%d/10' % (long_value[0], long_value[1], long_value[2]*10)\n lat_value = [float(i) for i in str(iss.sublat).split(\":\")]\n if lat_value[0] < 0:\n lat_value[0] = abs(lat_value[0])\n cam.exif_tags['GPS.GPSLatitudeRef'] = \"S\"\n else:\n cam.exif_tags['GPS.GPSLatitudeRef'] = \"N\"\n cam.exif_tags['GPS.GPSLatitude'] = '%d/1,%d/1,%d/10' % (lat_value[0], lat_value[1], lat_value[2]*10)\n return (iss.sublat / degree, iss.sublong / degree)","def find_coordinates(self):\n\n raise AttributeError(\n \"Cannot get available coordinates for OGR datasources. \"\n \"The source data is a vector-based shapefile without native coordinates.\"\n )","def _getCoords(self):\n\n if self._coords is not None:\n return self._coords[self._acsi]","def geo(self):\n return self.query.geo","def test_access(geometry):\n geometry.print_list_of_geos()\n geometry.print_list_of_geos_children()\n\n logger.info('TOP GEO:')\n top_geo = geometry.get_top_geo()\n top_geo.print_geo_children()\n\n logger.info('INTERMEDIATE GEO (QUAD):')\n geo = geometry.get_geo('QUAD:V1', 0)\n #geo = geometry.get_top_geo()\n geo.print_geo_children()\n\n t0_sec = time()\n X,Y,Z = geo.get_pixel_coords(do_tilt=True)\n #X,Y = geo.get_2d_pixel_coords()\n s = 'X: %s' % str(X)\n s+= '\\n Consumed time to get 3d pixel coordinates = %7.3f sec' % (time()-t0_sec)\n s+= '\\n Geometry object: %s:%d X.shape:%s' % (geo.oname, geo.oindex, str(X.shape))\n logger.info(s)\n\n logger.info('Test of print_pixel_coords() for quad:')\n geometry.print_pixel_coords('QUAD:V1', 1)\n logger.info('Test of print_pixel_coords() for CSPAD:')\n geometry.print_pixel_coords()\n\n s = 'Test of get_pixel_areas() for QUAD:'\n A = geo.get_pixel_areas()\n s+= '\\n Geometry object: %s:%d A.shape:%s' % (geo.oname, geo.oindex, str(A.shape))\n s+= '\\n A[0,0:5,190:198]:\\n' + str(A[0,0:5,190:198])\n logger.info(s)\n\n s = 'Test of get_pixel_areas() for CSPAD:'\n A = top_geo.get_pixel_areas()\n s+= '\\n Geometry object: %s:%d A.shape:%s' % (geo.oname, geo.oindex, str(A.shape))\n s+= '\\n A[0,0,0:5,190:198]:\\n' + str(A[0,0,0:5,190:198])\n logger.info(s)\n\n s = 'Test of get_size_geo_array()'\n s+= '\\n for QUAD: %d' % geo.get_size_geo_array()\n s+= '\\n for CSPAD: %d' % top_geo.get_size_geo_array()\n logger.info(s)\n\n s = 'Test of get_pixel_scale_size()'\n s+= '\\n for QUAD : %8.2f' % geo.get_pixel_scale_size()\n s+= '\\n for CSPAD : %8.2f' % top_geo.get_pixel_scale_size()\n s+= '\\n for geometry: %8.2f' % geometry.get_pixel_scale_size()\n logger.info(s)\n\n s = 'Test of get_dict_of_comments():'\n d = geometry.get_dict_of_comments()\n s+= '\\n d[0] = %s' % str(d[0])\n logger.info(s)","def get_coordinates(addresses, boroughs):\n latitude = []\n longitude = []\n for address, borough in zip(addresses, boroughs):\n try:\n g = geocoder.osm('{}, {}, New York'.format(address, borough)).json\n latitude.append(g['lat'])\n longitude.append(g['lng'])\n except:\n latitude.append(None)\n longitude.append(None)\n\n return np.array(latitude).T, np.array(longitude).T","def test_rasters_and_arrays(self):\n\n # Create test data\n lon_ul = 100 # Longitude of upper left corner\n lat_ul = 10 # Latitude of upper left corner\n numlon = 8 # Number of longitudes\n numlat = 5 # Number of latitudes\n dlon = 1\n dlat = -1\n\n # Define array where latitudes are rows and longitude columns\n A1 = numpy.zeros((numlat, numlon))\n\n # Establish coordinates for lower left corner\n lat_ll = lat_ul - numlat\n lon_ll = lon_ul\n\n # Define pixel centers along each direction\n lon = numpy.linspace(lon_ll + 0.5, lon_ll + numlon - 0.5, numlon)\n lat = numpy.linspace(lat_ll + 0.5, lat_ll + numlat - 0.5, numlat)\n\n # Define raster with latitudes going bottom-up (south to north).\n # Longitudes go left-right (west to east)\n for i in range(numlat):\n for j in range(numlon):\n A1[numlat - 1 - i, j] = linear_function(lon[j], lat[i])\n\n # Throw in a nodata element\n A1[2, 6] = numpy.nan\n\n # Upper left corner\n assert A1[0, 0] == 105.25\n assert A1[0, 0] == linear_function(lon[0], lat[4])\n\n # Lower left corner\n assert A1[4, 0] == 103.25\n assert A1[4, 0] == linear_function(lon[0], lat[0])\n\n # Upper right corner\n assert A1[0, 7] == 112.25\n assert A1[0, 7] == linear_function(lon[7], lat[4])\n\n # Lower right corner\n assert A1[4, 7] == 110.25\n assert A1[4, 7] == linear_function(lon[7], lat[0])\n\n # Generate raster object and write\n projection = ('GEOGCS[\"WGS 84\",'\n 'DATUM[\"WGS_1984\",'\n 'SPHEROID[\"WGS 84\",6378137,298.2572235630016,'\n 'AUTHORITY[\"EPSG\",\"7030\"]],'\n 'AUTHORITY[\"EPSG\",\"6326\"]],'\n 'PRIMEM[\"Greenwich\",0],'\n 'UNIT[\"degree\",0.0174532925199433],'\n 'AUTHORITY[\"EPSG\",\"4326\"]]')\n geotransform = (lon_ul, dlon, 0, lat_ul, 0, dlat)\n R1 = Raster(A1, projection, geotransform,\n keywords={'testkwd': 'testval', 'size': 'small'})\n\n # Check string representation of raster class\n assert str(R1).startswith('Raster data')\n assert str(R1.rows) in str(R1)\n assert str(R1.columns) in str(R1)\n\n # Test conversion between geotransform and\n # geometry (longitudes and latitudes)\n longitudes, latitudes = R1.get_geometry()\n msg = 'Longitudes not as expected: %s' % str(longitudes)\n assert numpy.allclose(longitudes, [100.5, 101.5, 102.5, 103.5, 104.5,\n 105.5, 106.5, 107.5]), msg\n\n msg = 'Latitudes not as expected: %s' % str(latitudes)\n assert numpy.allclose(latitudes, [5.5, 6.5, 7.5, 8.5, 9.5]), msg\n\n gt = raster_geometry2geotransform(longitudes, latitudes)\n msg = ('Conversion from coordinates to geotransform failed: %s'\n % str(gt))\n assert numpy.allclose(gt, geotransform,\n rtol=1.0e-12, atol=1.0e-12), msg\n\n msg = ('Dimensions of raster array do not match those of '\n 'raster object')\n assert numlat == R1.rows, msg\n assert numlon == R1.columns, msg\n\n # Write back to new (tif) file\n out_filename = unique_filename(suffix='.tif')\n R1.write_to_file(out_filename)\n assert R1.filename == out_filename\n\n # Check nodata in original layer\n assert numpy.isnan(R1.get_nodata_value())\n\n # Read again and check consistency\n R2 = read_layer(out_filename)\n assert R2.filename == out_filename\n\n # Check nodata in read layer\n assert numpy.isnan(R2.get_nodata_value())\n\n msg = ('Dimensions of written raster array do not match those '\n 'of input raster file\\n')\n msg += (' Dimensions of input file '\n '%s: (%s, %s)\\n' % (R1.filename, numlat, numlon))\n msg += (' Dimensions of output file %s: '\n '(%s, %s)' % (R2.filename, R2.rows, R2.columns))\n\n assert numlat == R2.rows, msg\n assert numlon == R2.columns, msg\n\n A2 = R2.get_data()\n\n assert numpy.allclose(numpy.nanmin(A1), numpy.nanmin(A2))\n assert numpy.allclose(numpy.nanmax(A1), numpy.nanmax(A2))\n\n msg = 'Array values of written raster array were not as expected'\n assert nanallclose(A1, A2), msg\n\n msg = 'Geotransforms were different'\n assert R1.get_geotransform() == R2.get_geotransform(), msg\n\n p1 = R1.get_projection(proj4=True)\n p2 = R2.get_projection(proj4=True)\n msg = 'Projections were different: %s != %s' % (p1, p2)\n assert p1 == p1, msg\n\n # Exercise projection __eq__ method\n assert R1.projection == R2.projection\n\n # Check that equality raises exception when type is wrong\n try:\n R1.projection == 234\n except TypeError:\n pass\n else:\n msg = 'Should have raised TypeError'\n raise Exception(msg)\n\n # Check keywords\n assert R1.keywords == R2.keywords\n\n # Check override of ==\n assert R1 == R2","def GeoGrid_by_ncref(nc_varstring, nc_timeindex=0):\n try:\n ds = gdal.Open(nc_varstring, gdalconst.GA_ReadOnly)\n assert ds is not None\n except AssertionError:\n raise ValueError('could not open netCDF file: {}'.format(nc_varstring))\n\n nc_string, nc_fname, nc_fieldname = nc_varstring.split(':')\n\n # Field name is specifiec as the nc_fname\n # Each slice of the 2D array is a single Raster here\n # ...\n dataset_array = ds.ReadAsArray()\n if len(dataset_array.shape) == 3:\n assert nc_timeindex < ds.RasterCount\n dataset_array = dataset_array[nc_timeindex]\n\n assert len(dataset_array.shape) == 2\n\n ydim, xdim = dataset_array.shape\n\n # Sample geotransform values:\n # (-3850000.0, 25000.0, 0.0, 5850000.0, 0.0, -25000.0)\n ds_geotransform = ds.GetGeoTransform()\n try:\n assert ds_geotransform[2] == 0\n assert ds_geotransform[4] == 0\n except AssertionError:\n raise ValueError('only 1D x,y values are supported')\n\n x = np.linspace(\n ds_geotransform[0] + 0.5 * ds_geotransform[1],\n ds_geotransform[0] + (xdim - 0.5) * ds_geotransform[1],\n xdim)\n y = np.linspace(\n ds_geotransform[3] + 0.5 * ds_geotransform[5],\n ds_geotransform[3] + (ydim - 0.5) * ds_geotransform[5],\n ydim)\n\n return GeoGrid(dataset_array, x, y, ds.GetProjection())","def make_xarray_coords(y, x, crs):\n if crs.is_geographic:\n y_attrs, x_attrs = COORD_DEFS['latitude'], COORD_DEFS['longitude']\n elif crs.is_projected:\n crs_osr = crs2osr(crs)\n units = crs_osr.GetLinearUnitsName()\n y_attrs, x_attrs = COORD_DEFS['y'], COORD_DEFS['x']\n y_attrs['units'], x_attrs['units'] = units, units\n\n y = xr.Variable(('y', ), y, attrs=y_attrs)\n x = xr.Variable(('x', ), x, attrs=x_attrs)\n\n return y, x","def pndindex(*args):\r\n return np.ndindex(*args)","def find_closest_pt(ref_lon, ref_lat, tlon, tlat):\n\n # compute great circle distance from location to model grid points\n dist = gc_dist(ref_lon, ref_lat, tlon, tlat)\n\n # find j index of closest grid point\n work = N.take(dist,N.argmin(dist,0),0).diagonal()\n jj = N.argsort(work)[0]\n\n # find i index of closest grid point\n work = N.take(dist,N.argmin(dist,1),1).diagonal()\n ii = N.argsort(work)[0]\n\n return ii, jj","def proj(self,lon,lat):\n x, y = self(np.atleast_1d(lon),np.atleast_1d(lat))\n x[x > 1e29] = None\n y[y > 1e29] = None\n #return np.ma.array(x,mask=x>1e2),np.ma.array(y,mask=y>1e2)\n return x, y","def get_lat_long(self, postcodes):\n # Fix evil postcodes\n postcodes = clean_postcodes(postcodes)\n\n postcode_df = self.postcode_df\n postcode_df = postcode_df.fillna('np.nan')\n postcode_df = postcode_df.set_index('Postcode')\n index_data = postcode_df.loc[postcodes]\n lat = np.array(index_data['Latitude']).T\n lng = np.array(index_data['Longitude']).T\n\n return np.vstack((lat, lng)).transpose()","def spatial(self):\n return self.spatial_x, self.spatial_y, self.spatial_data","def indices ( self, *r):\n \n if len(r) == 3: # only 3 values given -> use x,y,radius method\n xpos = self.gpos\n xis = []\n yis = []\n dr2 = (xpos[0, :]-r[0])**2 + (xpos[1, :]-r[1])**2\n # array with true/false entries\n inds = dr2 <= r[2]**2 \n for np in arange(self.size)[inds]: # np -- points in x2-circle\n xi, yi = self.index(xpos[0, np], xpos[1, np])\n xis += [xi]\n yis += [yi]\n if not (xis and yis): # if no points in circle, take nearest one\n return self.index(r[0], r[1])\n else:\n return array(xis), array(yis)\n elif len(r) == 4: # rectangular subdomain - old functionality\n xi1, yi1 = self.index(min(r[0], r[2]), min(r[1], r[3]))\n xi2, yi2 = self.index(max(r[0], r[2]), max(r[1], r[3]))\n return s_[xi1:xi2+1], s_[yi1:yi2+1]\n else: # use enveloping polygon\n xpos = self.gpos\n xis = []\n yis = []\n #replaced matplotlib Path by numpy\n #p = Path(array(r).reshape(-1,2))\n #inds = p.contains_points()\n #inds = in_poly(xpos[:2,:].T,array(r).reshape(-1,2))\n poly = Polygon(array(r).reshape(-1,2)[:,0],array(r).reshape(-1,2)[:,1])\n dists = poly.is_inside(xpos[0,:],xpos[1,:]) \n inds = dists >= 0\n for np in arange(self.size)[inds]: # np -- points in x2-circle\n xi, yi = self.index(xpos[0, np], xpos[1, np])\n xis += [xi]\n yis += [yi]\n if not (xis and yis): # if no points inside, take nearest to center\n center = array(r).reshape(-1,2).mean(0)\n return self.index(center[0], center[1])\n else:\n return array(xis), array(yis)\n #return arange(self.size)[inds]","def indices ( self, *r):\n \n if len(r) == 3: # only 3 values given -> use x,y,radius method\n xpos = self.gpos\n xis = []\n yis = []\n dr2 = (xpos[0, :]-r[0])**2 + (xpos[1, :]-r[1])**2\n # array with true/false entries\n inds = dr2 <= r[2]**2 \n for np in arange(self.size)[inds]: # np -- points in x2-circle\n xi, yi = self.index(xpos[0, np], xpos[1, np])\n xis += [xi]\n yis += [yi]\n if not (xis and yis): # if no points in circle, take nearest one\n return self.index(r[0], r[1])\n else:\n return array(xis), array(yis)\n elif len(r) == 4: # rectangular subdomain - old functionality\n xi1, yi1 = self.index(min(r[0], r[2]), min(r[1], r[3]))\n xi2, yi2 = self.index(max(r[0], r[2]), max(r[1], r[3]))\n return s_[xi1:xi2+1], s_[yi1:yi2+1]\n else: # use enveloping polygon\n xpos = self.gpos\n xis = []\n yis = []\n #replaced matplotlib Path by numpy\n #p = Path(array(r).reshape(-1,2))\n #inds = p.contains_points()\n #inds = in_poly(xpos[:2,:].T,array(r).reshape(-1,2))\n poly = Polygon(array(r).reshape(-1,2)[:,0],array(r).reshape(-1,2)[:,1])\n dists = poly.is_inside(xpos[0,:],xpos[1,:]) \n inds = dists >= 0\n for np in arange(self.size)[inds]: # np -- points in x2-circle\n xi, yi = self.index(xpos[0, np], xpos[1, np])\n xis += [xi]\n yis += [yi]\n if not (xis and yis): # if no points inside, take nearest to center\n center = array(r).reshape(-1,2).mean(0)\n return self.index(center[0], center[1])\n else:\n return array(xis), array(yis)\n #return arange(self.size)[inds]","def getCoords(self): # real signature unknown; restored from __doc__\r\n pass","def get_min_max_indices(latitudes_ref, longitudes_ref,\n minlat=None, maxlat=None,\n minlon=None, maxlon=None):\n\n latitudes = latitudes_ref[:]\n longitudes = longitudes_ref[:]\n\n latitudes = ensure_numeric(latitudes)\n longitudes = ensure_numeric(longitudes)\n\n assert num.allclose(num.sort(longitudes), longitudes)\n\n #print latitudes[0],longitudes[0]\n #print len(latitudes),len(longitudes)\n #print latitudes[len(latitudes)-1],longitudes[len(longitudes)-1]\n\n lat_ascending = True\n if not num.allclose(num.sort(latitudes), latitudes):\n lat_ascending = False\n # reverse order of lat, so it's in ascending order\n latitudes = latitudes[::-1]\n assert num.allclose(num.sort(latitudes), latitudes)\n\n largest_lat_index = len(latitudes)-1\n\n #Cut out a smaller extent.\n if minlat is None:\n lat_min_index = 0\n else:\n lat_min_index = num.searchsorted(latitudes, minlat)-1\n if lat_min_index < 0:\n lat_min_index = 0\n\n if maxlat is None:\n lat_max_index = largest_lat_index #len(latitudes)\n else:\n lat_max_index = num.searchsorted(latitudes, maxlat)\n if lat_max_index > largest_lat_index:\n lat_max_index = largest_lat_index\n\n if minlon is None:\n lon_min_index = 0\n else:\n lon_min_index = num.searchsorted(longitudes, minlon)-1\n if lon_min_index < 0:\n lon_min_index = 0\n\n if maxlon is None:\n lon_max_index = len(longitudes)\n else:\n lon_max_index = num.searchsorted(longitudes, maxlon)\n\n # Reversing the indexes, if the lat array is decending\n if lat_ascending is False:\n lat_min_index, lat_max_index = largest_lat_index - lat_max_index, \\\n largest_lat_index - lat_min_index\n lat_max_index = lat_max_index + 1 # taking into account how slicing works\n lon_max_index = lon_max_index + 1 # taking into account how slicing works\n\n return lat_min_index, lat_max_index, lon_min_index, lon_max_index","def _staticneighs_get_corestored_by_inds_slice(self, inds):\n inds = [inds] if type(inds) == int else inds\n idxs = self.idxs\n if self.sp_relative_pos is not None:\n sp_relative_pos = [self.sp_relative_pos[i] for i in inds]\n else:\n sp_relative_pos = None\n return idxs, sp_relative_pos","def XCAFDoc_ShapeTool_GetLocation(*args):\n return _XCAFDoc.XCAFDoc_ShapeTool_GetLocation(*args)","def linear_interpolation_of_x_y(georeferenced_array, extent_minimum,\n extent_maximum):\n # Extracts axis 1 (columns) from the input array.\n # This represents the longitude.\n if extent_minimum == x0:\n inn = georeferenced_array[0, :]\n\n # Extracts axis 0 (rows) from the input array.\n # This represents the latitude.\n elif extent_minimum == y0:\n inn = georeferenced_array[:, 0]\n\n #\n linear_interpolation = [((i-0)*(extent_maximum-extent_minimum)/(\n (len(inn)-1)-0)+extent_minimum) for i, r in enumerate(inn)]\n\n # Claculates the difference between the value in front and the value\n # behind in the list\n difference = [y - x for x, y in zip(linear_interpolation,\n linear_interpolation[1:])]\n\n # Calculates the size of each array so to compare it to the size of the\n # input array.\n array_length = [np.size(np.arange(\n extent_minimum, extent_maximum, i)) for i in difference]\n\n # Select values that only match the longitude/latitude length then return\n # the first index in the list of matched values.\n # This list is a list of indexes that correspond to the index in the\n # variable difference.\n index_of_correct_value = [i for i, v in enumerate(\n array_length) if v == len(inn)][0]\n\n #\n interpolated_coordinates = np.arange(extent_minimum,\n extent_maximum,\n difference[index_of_correct_value])\n\n return interpolated_coordinates","def find_loc_indices(loc, dir, tile):\n #returns the indices of the nearest neighbor point in the given tile, the lon/lat of the nearest neighbor, \n #and the distance (m) from the given point to the nearest neighbor grid cell\n \n filename_pattern = '*grid.tile{0}.nc'.format(tile)\n for f_name in os.listdir(dir):\n if fnmatch.fnmatch(f_name, filename_pattern):\n filename = f_name\n if not filename:\n message = 'No filenames matching the pattern {0} found in {1}'.format(filename_pattern,dir)\n logging.critical(message)\n raise Exception(message)\n \n nc_file = Dataset('{0}/{1}'.format(dir,filename))\n #read in supergrid longitude and latitude\n lon_super = np.array(nc_file['x']) #[lat,lon] or [y,x] #.swapaxes(0,1)\n lat_super = np.array(nc_file['y']) #[lat,lon] or [y,x] #.swapaxes(0,1)\n #get the longitude and latitude data for the grid centers by slicing the supergrid \n #and taking only odd-indexed values\n longitude = lon_super[1::2,1::2]\n latitude = lat_super[1::2,1::2]\n nc_file.close()\n \n adj_long = False \n #look for reversal of longitude; if found, adjust longitude so that 0-360 transition doesn't exist\n temp_loc = copy.deepcopy(loc)\n for row in longitude:\n if not (np.all(np.diff(row) >= 0) or np.all(np.diff(row) <= 0)):\n adj_long = True\n if adj_long:\n longitude[longitude < 180] += 360\n if loc[0] < 180:\n temp_loc[0] += 360\n \n #set up an array to hold the euclidean distance between the given point and every grid cell\n eucl_dist = np.zeros((longitude.shape[0],longitude.shape[1]))\n \n #get the Cartesian location of the given point\n cart_loc = np.array(sph2cart(math.radians(temp_loc[0]), math.radians(temp_loc[1]), earth_radius))\n \n for i in range(len(longitude)):\n for j in range(len(longitude[i])):\n #get the Cartesian location of all grid points\n cart_cell = np.array(sph2cart(math.radians(longitude[i,j]), math.radians(latitude[i,j]), earth_radius))\n \n #calculate the euclidean distance from the given point to the current grid cell\n eucl_dist[i,j] = np.linalg.norm(cart_loc - cart_cell)\n \n #get the indices of the grid point with the minimum euclidean distance to the given point\n i,j = np.unravel_index(eucl_dist.argmin(), eucl_dist.shape)\n \n return (i,j,longitude[i,j]%360.0, latitude[i,j], eucl_dist[i,j])"],"string":"[\n \"def find_coord_indices(lon_array, lat_array, lon_points, lat_points, proj_str):\\n\\n proj = Proj(proj_str)\\n proj_lon, proj_lat = np.array(proj(lon_array, lat_array)) # transform to distances using specified projection\\n lonlat = np.column_stack(\\n (proj_lon.ravel(), proj_lat.ravel())) # Stack all coarse x, y distances for array shape (n, 2)\\n ll = np.array(proj(lon_points, lat_points)).T # transform lists of fine grid x, y to match shape (n, 2)\\n idx = cdist(lonlat, ll).argmin(0) # Calculate all distances and get index of minimum\\n\\n return np.column_stack((np.unravel_index(idx, lon_array.shape))).tolist()\",\n \"def geo_idx(dd, dd_array):\\r\\n geo_idx = (np.abs(dd_array - np.float(dd))).argmin()\\r\\n return geo_idx\",\n \"def ndarray_to_location(array: np.ndarray) -> carla.Location: # pylint: disable=no-member\\n return carla.Location(*list(map(float, array))) # pylint: disable=no-member\",\n \"def geo_idx(dd, dd_array):\\n geo_idx = (np.abs(dd_array - dd)).argmin()\\n return geo_idx\",\n \"def find_lon_lat_of_indices(indices, dir, tile):\\n \\n filename_pattern = '*grid.tile{0}.nc'.format(tile)\\n for f_name in os.listdir(dir):\\n if fnmatch.fnmatch(f_name, filename_pattern):\\n filename = f_name\\n if not filename:\\n message = 'No filenames matching the pattern {0} found in {1}'.format(filename_pattern,dir)\\n logging.critical(message)\\n raise Exception(message)\\n \\n nc_file = Dataset('{0}/{1}'.format(dir,filename))\\n #read in supergrid longitude and latitude\\n lon_super = np.array(nc_file['x']) #[lat,lon] or [y,x] #.swapaxes(0,1)\\n lat_super = np.array(nc_file['y']) #[lat,lon] or [y,x] #.swapaxes(0,1)\\n #get the longitude and latitude data for the grid centers by slicing the supergrid \\n #and taking only odd-indexed values\\n longitude = lon_super[1::2,1::2]\\n latitude = lat_super[1::2,1::2]\\n nc_file.close()\\n \\n return (longitude[indices[1],indices[0]], latitude[indices[1],indices[0]])\",\n \"def getclosest_ij(lats,lons,latpt,lonpt):\\n dist_lat = (lats-latpt)**2 # find squared distance of every point on grid\\n dist_lon = (lons-lonpt)**2\\n minindex_lat = dist_lat.argmin() # 1D index of minimum dist_sq element\\n minindex_lon = dist_lon.argmin()\\n return minindex_lat, minindex_lon # Get 2D index for latvals and lonvals arrays from 1D index\",\n \"def getclosest_ij(lats,lons,latpt,lonpt):\\n dist_lat = (lats-latpt)**2 # find squared distance of every point on grid\\n dist_lon = (lons-lonpt)**2\\n minindex_lat = dist_lat.argmin() # 1D index of minimum dist_sq element\\n minindex_lon = dist_lon.argmin()\\n return minindex_lat, minindex_lon # Get 2D index for latvals and lonvals arrays from 1D index\",\n \"def geo_idx(dd, dd_array):\\r\\n geo_idx = (np.abs(dd_array - dd)).argmin()\\r\\n return geo_idx\",\n \"def _raster_index_to_coords(i, j, bounds = [[-100, -100], [100, 100]],\\n dx = 1, dy = 1):\\n x = (j+0.5)*dx + bounds[0][0]\\n y = (i+0.5)*dy + bounds[0][1]\\n return x, y\",\n \"def get_coordinates_geo(self):\\n if not self.rotated:\\n lon_arr_geo = self.lon_arr\\n lat_arr_geo = self.lat_arr\\n else:\\n lon_arr_geo, lat_arr_geo = self.transform().get_coordinates() \\n\\n return lon_arr_geo, lat_arr_geo\",\n \"def find_stn_idx(ref_lon, ref_lat, tlon, tlat):\\n\\n # compute great circle distance from location to model grid points\\n dist = gc_dist(ref_lon, ref_lat, tlon, tlat)\\n\\n # find the indices of the two closest grid points with distinct longitudes\\n work = N.take(dist,N.argmin(dist,0),0).diagonal()\\n Jlist = N.argsort(work)[:2]\\n del work\\n\\n # find the indices of the two closest grid points with distinct latitudes\\n work = N.take(dist,N.argmin(dist,1),1).diagonal()\\n Ilist = N.argsort(work)[:2]\\n del work\\n\\n return Ilist, Jlist\",\n \"def point_coords(geom):\\n # Return a tuple with the x/y point coordinate for a GeoDataFrame geometry\\n return list(geom.coords)[0] # Just get first tuple in list, since it's a point\",\n \"def get_idx(lons, lats, lon, lat):\\n dist = ((lons - lon) ** 2 + (lats - lat) ** 2) ** 0.5\\n return np.unravel_index(dist.argmin(), dist.shape)\",\n \"def get_geo_coordinates(\\n index_y: int,\\n index_x: int,\\n tile_coordinates: tuple,\\n):\\n # Predefining variables for calculation\\n # Setting up r, radius of world with given pixel values.\\n mollweide_center_width = 72000\\n mollweide_center_height = 36000\\n sqrt2 = math.sqrt(2)\\n r = (__GLOBE_WIDTH / 2) / 2 / sqrt2\\n\\n # Get actual x, y coordinates using the indices\\n y_2d = index_y + (4000 * tile_coordinates[1]) - mollweide_center_height\\n x_2d = index_x + (4000 * tile_coordinates[0]) - mollweide_center_width\\n\\n # Start Mollweide projection calculations based on indices\\n theta = math.asin(y_2d / r / sqrt2)\\n latitude = math.asin((2 * theta + math.sin(2 * theta)) / math.pi)\\n longitude = math.pi * x_2d / 2 / r / sqrt2 / math.cos(theta)\\n return latitude, longitude\",\n \"def _get_voronoi_centroid_array(lsm_lat_array, lsm_lon_array, extent):\\n YMin = extent[2]\\n YMax = extent[3]\\n XMin = extent[0]\\n XMax = extent[1]\\n\\n ptList = []\\n if (lsm_lat_array.ndim == 2) and (lsm_lon_array.ndim == 2):\\n # generate point list with 2D lat lon lists\\n if extent:\\n # exctract subset within extent\\n lsm_dx = np.max(np.absolute(np.diff(lsm_lon_array)))\\n lsm_dy = np.max(np.absolute(np.diff(lsm_lat_array, axis=0)))\\n\\n # remove values with NaN\\n lsm_lat_array = np.ma.filled(lsm_lat_array, fill_value=-9999)\\n lsm_lon_array = np.ma.filled(lsm_lon_array, fill_value=-9999)\\n\\n lsm_lat_indices_from_lat, lsm_lon_indices_from_lat = \\\\\\n np.where((lsm_lat_array >= (YMin - 2*lsm_dy)) &\\n (lsm_lat_array <= (YMax + 2*lsm_dy)))\\n lsm_lat_indices_from_lon, lsm_lon_indices_from_lon = \\\\\\n np.where((lsm_lon_array >= (XMin - 2*lsm_dx)) &\\n (lsm_lon_array <= (XMax + 2*lsm_dx)))\\n\\n lsm_lat_indices = np.intersect1d(lsm_lat_indices_from_lat,\\n lsm_lat_indices_from_lon)\\n lsm_lon_indices = np.intersect1d(lsm_lon_indices_from_lat,\\n lsm_lon_indices_from_lon)\\n\\n lsm_lat_list = \\\\\\n lsm_lat_array[lsm_lat_indices, :][:, lsm_lon_indices]\\n lsm_lon_list = \\\\\\n lsm_lon_array[lsm_lat_indices, :][:, lsm_lon_indices]\\n # Create a list of geographic coordinate pairs\\n for i in range(len(lsm_lat_indices)):\\n for j in range(len(lsm_lon_indices)):\\n ptList.append([lsm_lon_list[i][j], lsm_lat_list[i][j]])\\n\\n elif lsm_lat_array.ndim == 1 and lsm_lon_array.ndim == 1:\\n # generate point list with 1D lat lon lists\\n if extent:\\n Ybuffer = 2 * abs(lsm_lat_array[0]-lsm_lat_array[1])\\n Xbuffer = 2 * abs(lsm_lon_array[0]-lsm_lon_array[1])\\n # Extract the lat and lon within buffered extent\\n # (buffer with 2* interval degree)\\n lsm_lat_list = lsm_lat_array[(lsm_lat_array >= (YMin - Ybuffer)) &\\n (lsm_lat_array <= (YMax + Ybuffer))]\\n lsm_lon_list = lsm_lon_array[(lsm_lon_array >= (XMin - Xbuffer)) &\\n (lsm_lon_array <= (XMax + Xbuffer))]\\n\\n # Create a list of geographic coordinate pairs\\n for ptX in lsm_lon_list:\\n for ptY in lsm_lat_list:\\n ptList.append([ptX, ptY])\\n else:\\n raise IndexError(\\\"Lat/Lon lists have invalid dimensions. \\\"\\n \\\"Only 1D or 2D arrays allowed ...\\\")\\n\\n if len(ptList) <= 0:\\n raise IndexError(\\\"The watershed is outside of the bounds of the\\\"\\n \\\" land surface model grid ...\\\")\\n\\n return np.array(ptList) # set-up for input to Delaunay\",\n \"def read_gdal_coordinates(dataset, mode=\\\"center\\\"):\\n coordinates_pixel = _pixel_coordinates(\\n dataset.RasterXSize, dataset.RasterYSize, mode\\n )\\n\\n geotransform = dataset.GetGeoTransform()\\n coordinates = _pixel_to_map(coordinates_pixel, geotransform)\\n\\n return coordinates\",\n \"def lat_lons(self):\",\n \"def geo(self):\\n return vec2geo_linear_signed(self)\",\n \"def nearest_lat_lon_index(point, latitudes, longitudes):\\n stacked = da.stack((latitudes.flatten(), longitudes.flatten())).transpose()\\n closest = get_nearest(da.array(point).reshape(-1, 1).transpose(), stacked)\\n idx = np.unravel_index(closest[0], latitudes.shape)\\n return idx\",\n \"def build_spatial_index(vector_path):\\r\\n vector = gdal.OpenEx(vector_path)\\r\\n layer = vector.GetLayer()\\r\\n geom_index = rtree.index.Index()\\r\\n geom_list = []\\r\\n for index in range(layer.GetFeatureCount()):\\r\\n feature = layer.GetFeature(index)\\r\\n geom = feature.GetGeometryRef()\\r\\n shapely_geom = shapely.wkb.loads(geom.ExportToWkb())\\r\\n shapely_prep_geom = shapely.prepared.prep(shapely_geom)\\r\\n geom_list.append(shapely_prep_geom)\\r\\n geom_index.insert(index, shapely_geom.bounds)\\r\\n\\r\\n return geom_index, geom_list\",\n \"def location(self):\\n return np.array((self.latitude, self.longitude))\",\n \"def location(self):\\n return np.array((self.latitude, self.longitude))\",\n \"def spatial(self):\",\n \"def point_location(tri, p): \\n simplex_index = tri.find_simplex(p)\\n bc = []\\n for id_, point in zip(simplex_index, p):\\n # Calculate the two first barycentric coordinates for the relevant\\n # simplex\\n b = tri.transform[id_, :2].dot(point-tri.transform[id_, 2])\\n bc.append(np.c_[np.atleast_2d(b), 1-b.sum()])\\n # Create the full array and squeeze the shit out of it\\n bc = np.array(bc).squeeze()\\n return simplex_index, bc\",\n \"def geofind():\\n return render_template('geo_find.html')\",\n \"def Indexes(self, latitudes, longitudes):\\n res = self._transform.TransformPoints(\\n np.column_stack((longitudes, latitudes)))\\n res = list(zip(*res))\\n x, y = np.array(res[0]), np.array(res[1])\\n idx_col = self._inv_txf[0] + self._inv_txf[1] * x + self._inv_txf[2] * y\\n idx_row = self._inv_txf[3] + self._inv_txf[4] * x + self._inv_txf[5] * y\\n return idx_row.astype(int), idx_col.astype(int)\",\n \"def loc(self):\\n return self._gev_bijector.loc\",\n \"def obs_ijpos(gridfile,lons,lats,coor):\\n\\n gfh= netCDF4.Dataset(gridfile)\\n cartesian=0\\n if (coor=='r'):\\n try:\\n \\n latr=gfh.variables['lat_rho'][:,:]\\n lonr=gfh.variables['lon_rho'][:,:]\\n except:\\n latr=gfh.variables['latitude'][:,:]\\n lonr=gfh.variables['longitude'][:,:]\\n \\n\\n try:\\n xr=gfh.variables['xi_rho'][:]\\n yr=gfh.variables['eta_rho'][:]\\n except:\\n try:\\n xr=gfh.variables['x_rho'][:]\\n yr=gfh.variables['y_rho'][:]\\n except:\\n print('Neither xi_rho/eta_rho or x_rho/y_rho on file.')\\n print('This might slow down the calculations')\\n\\n\\n elif (coor=='u'):\\n latr=gfh.variables['lat_u'][:,:]\\n lonr=gfh.variables['lon_u'][:,:]\\n try:\\n xr=gfh.variables['xi_u'][:]\\n yr=gfh.variables['eta_u'][:]\\n except:\\n xr=gfh.variables['x_u'][:]\\n yr=gfh.variables['y_u'][:]\\n elif (coor=='v'):\\n latr=gfh.variables['lat_v'][:,:]\\n lonr=gfh.variables['lon_v'][:,:]\\n try:\\n xr=gfh.variables['xi_v'][:]\\n yr=gfh.variables['eta_v'][:]\\n except:\\n xr=gfh.variables['x_v'][:]\\n yr=gfh.variables['y_v'][:]\\n\\n IN = point_in_polygon(lonr, latr, lons, lats)\\n ind=np.where(IN)[0]\\n \\n if lats.size >1: \\n lons=lons[ind]; lats=lats[ind]\\n # If there's no lons, lats left at this stage, return oipos, ojpos with -999 everywhere\\n if not len(lons):\\n return np.ones_like(IN)*-999, np.ones_like(IN)*-999\\n \\n try:\\n try:\\n mapstr=str(gfh.variables['h'].getncattr('mapping'))\\n except:\\n try:\\n mapstr=str(gfh.variables['h'].getncattr('grid_mapping'))\\n except:\\n pass\\n try:\\n projstring=(gfh.variables[mapstr]).getncattr('proj4')\\n except:\\n try:\\n projstring=(gfh.variables[mapstr]).getncattr('proj4string')\\n except:\\n pass\\n try:\\n projstring=(gfh.variables['grid_mapping']).getncattr('proj4')\\n except:\\n try:\\n projstring=(gfh.variables['grid_mapping']).getncattr('proj4string')\\n except:\\n pass\\n\\n gridproj=proj.Proj(str(projstring))\\n hasproj=1\\n except:\\n hasproj=0\\n\\n # Check if lat, lon spacing is uniform\\n dx1=np.abs(lonr[0,1]-lonr[0,0])\\n dx2=np.abs(lonr[0,-1]-lonr[0,-2])\\n n=int(np.round(lonr.shape[1]/2))\\n dx3=np.abs(lonr[0,n]-lonr[0,n-1])\\n\\n dy1=np.abs(latr[1,0]-latr[0,0])\\n dy2=np.abs(latr[-1,0]-latr[-2,0])\\n n=int(np.round(latr.shape[0]/2))\\n dy3=np.abs(latr[n,0]-latr[n-1,0])\\n\\n if ( (dx1 == dx2) & (dx1==dx3) & (dx2==dx3) & (dy1 == dy2) & (dy1==dy3) & (dy2==dy3) ):\\n cartesian=1\\n gridproj=proj.Proj(\\\"+proj=latlong +datum=WGS84\\\")\\n \\n\\n \\n if hasproj:\\n dx=xr[1]-xr[0]\\n dy=yr[1]-yr[0]\\n [x,y]=gridproj(lons,lats)\\n ipos=(x-xr[0])/dx\\n jpos=(y-yr[0])/dy\\n\\n elif cartesian:\\n [x1,y1]=gridproj(lonr[0,0],latr[0,0])\\n [x2,y2]=gridproj(lonr[0,1],latr[0,1])\\n dx=x2-x1\\n [x2,y2]=gridproj(lonr[1,0],latr[1,0])\\n dy=y2-y1\\n [x,y]=gridproj(lons,lats)\\n [x0,y0]=gridproj(lonr[0,0],latr[0,0])\\n\\n ipos=(x-x0)/dx\\n jpos=(y-y0)/dy\\n\\n else:\\n x=np.linspace(0,lonr.shape[1]-1,lonr.shape[1])\\n y=np.linspace(0,lonr.shape[0]-1,lonr.shape[0])\\n xi=np.zeros_like(lonr); yi=np.zeros([lonr.shape[1],lonr.shape[0]])\\n xi[:,:]=x; yi[:,:]=y; yi=np.swapaxes(yi,1,0)\\n zi=scipy.interpolate.griddata((lonr.flatten(),latr.flatten()),xi.flatten(),(lons,lats))\\n ipos=zi\\n zi=scipy.interpolate.griddata((lonr.flatten(),latr.flatten()),yi.flatten(),(lons,lats))\\n jpos=zi\\n \\n if 'ind' in locals():\\n oipos=np.ones(IN.shape)*-999.; ojpos=np.ones(IN.shape)*-999.\\n oipos[ind]=ipos; ojpos[ind]=jpos\\n else:\\n oipos=ipos\\n ojpos=jpos\\n if not IN:\\n oipos = np.array([-999.])\\n ojpos = np.array([-999.])\\n gfh.close()\\n return oipos,ojpos\",\n \"def feature_coords(features):\\n coords_list = []\\n for feature in features:\\n coord_start = feature.location.nofuzzy_start\\n coord_end = feature.location.nofuzzy_end\\n coord_pair = (coord_start, coord_end)\\n coords_list.append(coord_pair)\\n ## consider adding some info to the log\\n return coords_list\",\n \"def get_signif_locs(da, lat, lon): \\n y = lat[np.where(da.values > 0)[0]].values\\n x = lon[np.where(da.values > 0)[1]].values\\n return [(x[i], y[i]) for i in range(len(x))]\",\n \"def test_G_ind(self):\\r\\n a = array([[29, 11], [273, 191], [8, 31], [64, 64]])\\r\\n self.assertFloatEqual(G_ind(a)[0], 28.59642)\\r\\n self.assertFloatEqual(G_ind(a, True)[0], 28.31244)\",\n \"def fn2lonlat(filename):\\n tokens = filename.split(\\\"/\\\")[-1].rsplit(\\\".\\\", 1)[0].split(\\\"x\\\")\\n return [0 - float(tokens[0]), float(tokens[1])]\",\n \"def find_stn(ref_lon, ref_lat, tlon, tlat):\\n\\n # find the indices of the 4 model grid points around the location\\n Ilist, Jlist = find_stn_idx(ref_lon, ref_lat, tlon, tlat)\\n\\n # get the 4 model grid points longitudes and latitudes\\n lonlist = []\\n latlist = []\\n for i in Ilist:\\n for j in Jlist:\\n lonlist.append(tlon[i,j])\\n latlist.append(tlat[i,j])\\n\\n # convert Python lists to numpy arrays\\n lonlist = N.array(lonlist)\\n latlist = N.array(latlist)\\n\\n return lonlist, latlist\",\n \"def _find_coordinates(self, coords, ref):\\n result = []\\n temp_fastq_length = 500\\n reference_seq = ''\\n with open(ref) as f:\\n lines = f.readlines()[1:]\\n for line in lines:\\n reference_seq += line.strip()\\n with open('temp_index/temp_index.fasta', 'w') as fw:\\n fw.write('>{}\\\\n{}'.format(self.read_id, self.seq))\\n subprocess.run('bwa index temp_index/temp_index.fasta', shell=True, stdout=FNULL, stderr=subprocess.STDOUT)\\n for coord in coords:\\n with open('temp_index/coordinate_rDNA.fastq', 'w') as fw:\\n fw.write('>temp\\\\n{}\\\\n+\\\\n{}\\\\n'.format(reference_seq[coord-1:coord+temp_fastq_length-1], 'J' * temp_fastq_length))\\n # with -a option, multiple hits are more clearly shown\\n utilities.bwa_mapping('temp_index/temp_index.fasta', 'temp_index/coordinate_rDNA.fastq', 'temp_index/temp_sam4coord.sam', multi=True)\\n with open('temp_index/temp_sam4coord.sam') as samf:\\n map_result = samf.readlines()[2:]\\n for mapping in map_result:\\n row = mapping.strip().split()\\n AS = int(mapping.strip().split('AS:i:')[1].split()[0])\\n flag = int(row[1])\\n if utilities.easy_flag(flag, 16) != 1:\\n direction = '+'\\n else:\\n direction = '-'\\n mapped_coord = int(row[3])\\n if AS > 0.3 * temp_fastq_length:\\n result.append([coord, mapped_coord, direction])\\n return result\",\n \"def _get_ij_(lats, lons, lat, lon):\\n _ij_ = (np.argmin(np.abs(lats-lat)), np.argmin(np.abs(lons-lon)))\\n return _ij_\",\n \"def test_coords():\\n x = np.array([8, 67, 79, 10, 52, 53, 98, 34, 15, 58], dtype=float)\\n y = np.array([24, 87, 48, 94, 98, 66, 14, 24, 60, 16], dtype=float)\\n\\n return x, y\",\n \"def getCoords(geom):\\n geomDict = eval(geom.ExportToJson())\\n coords = geomDict['coordinates']\\n if geomDict['type'] == 'Polygon':\\n coordsArray = numpy.array(coords[0])\\n elif geomDict['type'] == 'MultiPoint':\\n coordsArray = numpy.array(coords)\\n else:\\n coordsArray = None\\n return coordsArray\",\n \"def get_ecmwf_lat_lon(nc_file):\\n from netCDF4 import Dataset\\n \\n fh = Dataset(nc_file, mode='r')\\n\\n latitude_ecmwf = fh.variables['latitude_ecmwf'][:]\\n longitude_ecmwf = fh.variables['longitude_ecmwf'][:]\\n\\n lonmesh_ecmwf,latmesh_ecmwf = np.meshgrid(longitude_ecmwf,latitude_ecmwf)\\n\\n print('latitude_ecmwf: ', latitude_ecmwf.shape)\\n print('longitude_ecmwf: ', longitude_ecmwf.shape)\\n \\n return latitude_ecmwf, longitude_ecmwf, latmesh_ecmwf, lonmesh_ecmwf;\",\n \"def pixelloc_to_geoloc(row, col, loff, coff):\\n row = np.atleast_1d(row)\\n col = np.atleast_1d(col)\\n\\n assert row.shape == col.shape\\n\\n lat, lon = _nav.pixelloc_to_geoloc(row, col, loff, coff)\\n\\n if lat.size == lon.size == 1:\\n # Return scalars\\n return lat[0], lon[0]\\n else:\\n return lat, lon\",\n \"def project(self, latitude, longitude):\\n longitude = longitude if longitude > 0 else 360 + longitude\\n\\n lon_array = self.ecmwf_data.longitude\\n lat_array = self.ecmwf_data.latitude\\n\\n # Find in the lon_array / lat_array the index interval\\n # Including lon_ul and lat_ul\\n a_lon = np.where((lon_array < longitude))[0][-1]\\n if longitude > lon_array.max():\\n # lon is between 359.6 and 0 ...\\n b_lon = 0\\n else:\\n b_lon = np.where((lon_array >= longitude))[0][0]\\n\\n a_lat = np.where((lat_array < latitude))[0][0]\\n b_lat = np.where((lat_array >= latitude))[0][-1]\\n\\n # Compute geo extent around the point :\\n # => extent definition : LR,LL,UL,UR\\n extent = [lon_array[a_lon], lat_array[a_lat],\\n lon_array[b_lon], lat_array[a_lat],\\n lon_array[b_lon], lat_array[b_lat],\\n lon_array[a_lon], lat_array[b_lat]]\\n\\n extent_index = [a_lon, a_lat,\\n b_lon, a_lat,\\n b_lon, b_lat,\\n a_lon, b_lat]\\n\\n log.info(' - Selected vertex : ')\\n log.info('LL (px,ln) / (lon,lat) : (%s, %s) / (%s dd , %s dd)' % (\\n str(extent_index[0]), str(extent_index[1]), str(extent[0]), str(extent[1])))\\n log.info('LR (px,ln) / (lon,lat) : (%s, %s) / (%s dd , %s dd)' % (\\n str(extent_index[2]), str(extent_index[3]), str(extent[2]), str(extent[3])))\\n log.info('UR (px,ln) / (lon,lat) : (%s, %s) / (%s dd , %s dd)' % (\\n str(extent_index[4]), str(extent_index[5]), str(extent[4]), str(extent[5])))\\n log.info('UL (px,ln) / (lon,lat) : (%s, %s) / (%s dd , %s dd)' % (\\n str(extent_index[6]), str(extent_index[7]), str(extent[6]), str(extent[7])))\\n\\n # TIE Point grid defined - compute linear transformation\\n # to estimate value at the lat/lon location\\n # origin : extent_ul[0], extent_ul[1]\\n delta_lon = 0.4 # extent[4] - extent[6] # UR - UL\\n delta_lat = -0.4 # extent[1] - extent[7] # LL - UL\\n\\n lambda_lat = latitude - extent[7]\\n lambda_lon = longitude - extent[6]\\n\\n beta_longitude = lambda_lon / delta_lon\\n beta_latitude = lambda_lat / delta_lat\\n\\n # Processing of all keys\\n for key in self.ecmwf_data.mandatory_attributes:\\n M = getattr(self.ecmwf_data, key)\\n v = self.linear_estimate(M,\\n beta_latitude,\\n beta_longitude,\\n extent_index)\\n setattr(self, key, v)\",\n \"def shot_geolocations(self) -> geopandas.array.GeometryArray:\\n geolocations = np.array(\\n [shapely.geometry.Point(lon, lat) for lon, lat in self.shot_lon_lat],\\n dtype=shapely.geometry.Point,\\n )\\n\\n return geopandas.array.GeometryArray(geolocations, crs=WGS84)\",\n \"def get_coords(data, id):\\n return data[id]['lat'], data[id]['lon']\",\n \"def geotiff_read(ifile,metaData):\\r\\n\\r\\n file = gdal.Open(ifile, GA_ReadOnly)\\r\\n\\r\\n projection = file.GetProjection()\\r\\n src = osr.SpatialReference()\\r\\n src.ImportFromWkt(projection)\\r\\n proj = src.ExportToWkt()\\r\\n\\r\\n Nx = file.RasterXSize\\r\\n Ny = file.RasterYSize\\r\\n\\r\\n trans = file.GetGeoTransform()\\r\\n\\r\\n dx = trans[1]\\r\\n dy = trans[5]\\r\\n\\r\\n if metaData == \\\"A\\\":\\r\\n\\r\\n xp = np.arange(Nx)\\r\\n yp = np.arange(Ny)\\r\\n\\r\\n (Xp, Yp) = np.meshgrid(xp,yp)\\r\\n\\r\\n X = trans[0] + (Xp+0.5)*trans[1] + (Yp+0.5)*trans[2] #FIXME: bottleneck!\\r\\n Y = trans[3] + (Xp+0.5)*trans[4] + (Yp+0.5)*trans[5]\\r\\n\\r\\n if metaData == \\\"P\\\":\\r\\n\\r\\n xp = np.arange(Nx)\\r\\n yp = np.arange(Ny)\\r\\n\\r\\n (Xp, Yp) = np.meshgrid(xp,yp)\\r\\n\\r\\n X = trans[0] + Xp*trans[1] + Yp*trans[2] #FIXME: bottleneck!\\r\\n Y = trans[3] + Xp*trans[4] + Yp*trans[5]\\r\\n\\r\\n band = file.GetRasterBand(1)\\r\\n\\r\\n Z = band.ReadAsArray()\\r\\n\\r\\n dx = np.abs(dx)\\r\\n dy = np.abs(dy)\\r\\n\\r\\n return X, Y, Z, dx, dy, proj\",\n \"def get_location(self):\\n ret = _pal.Mat4x4()\\n _pal.lib.geometry_get_location(self._geometry, ret)\\n return [x for x in ret]\",\n \"def getSearchSpaceCoords(self):\",\n \"def fix_location(r):\\n \\n # all is fine: just change zipcode datatype to str\\n if not np.isnan(r['zip']) and not np.isnan(r['lat']):\\n return [str(int(r['zip'])), r['lng'], r['lat']]\\n \\n # try to locate within zipcode polygons\\n if not np.isnan(r['lat']):\\n query = \\\"\\\"\\\"\\n SELECT t.geoid as zip, {} as lng, {} as lat\\n FROM us_zcta5 t JOIN usps_zcta5 z ON t.geoid = z.zip\\n WHERE ST_Contains(t.shape, ST_GeomFromText('POINT({} {})', 2))\\n \\\"\\\"\\\"\\n res = pd.read_sql(query.format(r['lng'], r['lat'], r['lng'], r['lat']), con = con)\\n if len(res) == 1:\\n return res.values[0].tolist()\\n\\n # use zipcode center as location proxy: geocoding is prefered in this case, but might be quite expensive\\n if not np.isnan(r['zip']):\\n res = zipcodes[zipcodes['zip'] == str(int(r['zip']))]\\n if len(res) == 1:\\n return res.values[0].tolist()[:3]\\n\\n return [None, None, None]\",\n \"def convertView2Geo(self, x, y):\\n\\n # x_pix is from left map edge, y_pix from top map edge\\n x_pix = x + self.view_offset_x\\n y_pix = y + self.view_offset_y\\n\\n lon = self.map_llon + x_pix/self.ppd_x\\n lat = self.map_tlat - y_pix/self.ppd_y\\n\\n return (lon, lat)\",\n \"def morton_idx(pts):\\n lib = _initlib()\\n p = require(pts, dtype=float64, requirements=['C']) \\n inv_cell_width = 1.0/8192\\n npts = len(p)\\n out = empty(npts, dtype=int64)\\n lib.get_morton_idx(p, npts, inv_cell_width, out)\\n return out\",\n \"def _get_clip_loc_in_array(self):\\r\\n\\r\\n # coordinates of upperleft and lowerright points of binding box\\r\\n box_ulx, box_uly, box_lrx, box_lry = self.clip_box[0][0], self.clip_box[0][1], \\\\\\r\\n self.clip_box[1][0], self.clip_box[1][1]\\r\\n\\r\\n # Get the offsets that correspond to the bounding box corner coordinates.\\r\\n offsets_ul = gdal.ApplyGeoTransform(self.inv_gt, box_ulx, box_uly)\\r\\n offsets_lr = gdal.ApplyGeoTransform(self.inv_gt, box_lrx, box_lry)\\r\\n\\r\\n # The offsets are returned as floating point, but we need integers.\\r\\n self.off_ulx, self.off_uly = map(int, offsets_ul)\\r\\n self.off_lrx, self.off_lry = map(int, offsets_lr)\\r\\n\\r\\n # Compute the numbers of rows and columns to extract, based on the offsets.\\r\\n self.row = self.off_lry - self.off_uly\\r\\n self.column = self.off_lrx - self.off_ulx\",\n \"def get_xyz_coord(path):\\r\\n\\tlabels = loadmat(path)\\r\\n\\tanno_xyz = []\\r\\n\\tfor index in range(0, 1500):\\r\\n\\t\\tanno_xyz.append([])\\r\\n\\t\\tfor i in range(0, 21):\\r\\n\\t\\t\\tx = labels['handPara'][0][i][index]\\r\\n\\t\\t\\ty = labels['handPara'][1][i][index]\\r\\n\\t\\t\\tz = labels['handPara'][2][i][index]\\r\\n\\t\\t\\tanno_xyz[-1].append([x, y, z])\\r\\n\\tanno_xyz = np.array(anno_xyz)\\r\\n\\t# anno_xyz = np.reshape(labels['handPara'], (1500, 21, 3))\\r\\n\\treturn anno_xyz\",\n \"def nearlonlat_zl(lon,lat,lonp,latp): # needed for the next function get_FVCOM_bottom_temp \\r\\n # approximation for small distance \\r\\n cp=np.cos(latp*np.pi/180.) \\r\\n dx=(lon-lonp)*cp\\r\\n dy=lat-latp \\r\\n xi=np.argmin(abs(dx)) \\r\\n yi=np.argmin(abs(dy))\\r\\n min_dist=111*np.sqrt(dx[xi]**2+dy[yi]**2)\\r\\n return xi,yi,min_dist\",\n \"def array_coords(shape=(1, 1)):\\n indexes = np.arange(np.product(shape))\\n coords = [indexes % shape[1], indexes // shape[1]]\\n return np.transpose(coords).astype('float64')\",\n \"def vector(self):\\n return np.array([self.lat, self.lng])\",\n \"def get_idx_from_latlon(self, latitudes, longitudes, unique=False):\\n try:\\n lat_idx = [np.argmin(np.abs(self.lat - lat)) for lat in latitudes]\\n lon_idx = [np.argmin(np.abs(self.lon - lon)) for lon in longitudes]\\n if unique:\\n ijdx = np.vstack({(i, j) for i, j in zip(lat_idx, lon_idx)})\\n lat_idx = ijdx[:, 0].tolist()\\n lon_idx = ijdx[:, 1].tolist()\\n except TypeError:\\n lat_idx = np.argmin(np.abs(self.lat - latitudes))\\n lon_idx = np.argmin(np.abs(self.lon - longitudes))\\n\\n return lat_idx, lon_idx\",\n \"def _initialize_geospatial_data(self):\\n driver = ogr.GetDriverByName(\\\"ESRI Shapefile\\\")\\n\\n bnd_src = driver.Open(self._spatial_filename, 0)\\n bnd_lyr = bnd_src.GetLayer()\\n (self.spatial_index,\\n self.spatial_feats,\\n self.bison_spatial_fields\\n ) = self._create_spatial_index(bnd_lyr)\",\n \"def get_zone_pixels(feat, input_zone_polygon, input_value_raster, band, coords=[]): #, raster_band\\n \\n \\n \\n # Open data\\n raster = gdal.Open(input_value_raster)\\n shp = ogr.Open(input_zone_polygon)\\n lyr = shp.GetLayer()\\n \\n # Get raster georeference info\\n transform = raster.GetGeoTransform()\\n xOrigin = transform[0]\\n yOrigin = transform[3]\\n pixelWidth = transform[1]\\n pixelHeight = transform[5]\\n \\n sizeX = raster.RasterXSize\\n sizeY = raster.RasterYSize\\n lrx = xOrigin + (sizeX * pixelWidth)\\n lry = yOrigin + (sizeY * pixelHeight)\\n \\n \\n \\n # Reproject vector geometry to same projection as raster\\n #sourceSR = lyr.GetSpatialRef()\\n #targetSR = osr.SpatialReference()\\n #targetSR.ImportFromWkt(raster.GetProjectionRef())\\n #coordTrans = osr.CoordinateTransformation(sourceSR,targetSR)\\n #feat = lyr.GetNextFeature()\\n #geom = feat.GetGeometryRef()\\n #geom.Transform(coordTrans)\\n \\n # Get extent of feat\\n geom = feat.GetGeometryRef()\\n if (geom.GetGeometryName() == 'MULTIPOLYGON'):\\n count = 0\\n pointsX = []; pointsY = []\\n for polygon in geom:\\n geomInner = geom.GetGeometryRef(count)\\n ring = geomInner.GetGeometryRef(0)\\n numpoints = ring.GetPointCount()\\n for p in range(numpoints):\\n lon, lat, z = ring.GetPoint(p)\\n pointsX.append(lon)\\n pointsY.append(lat)\\n count += 1\\n elif (geom.GetGeometryName() == 'POLYGON'):\\n ring = geom.GetGeometryRef(0)\\n numpoints = ring.GetPointCount()\\n pointsX = []; pointsY = []\\n for p in range(numpoints):\\n lon, lat, z = ring.GetPoint(p)\\n pointsX.append(lon)\\n pointsY.append(lat)\\n\\n else:\\n sys.exit(\\\"ERROR: Geometry needs to be either Polygon or Multipolygon\\\")\\n\\n #xmin = min(pointsX) \\n #xmax = max(pointsX)\\n #ymin = min(pointsY)\\n #ymax = max(pointsY)\\n \\n \\n if len(coords) == 0: \\n xmin = xOrigin if (min(pointsX) < xOrigin) else min(pointsX)\\n xmax = lrx if (max(pointsX) > lrx) else max(pointsX)\\n ymin = lry if (min(pointsY) < lry) else min(pointsY)\\n ymax = yOrigin if (max(pointsY) > yOrigin) else max(pointsY)\\n else:\\n xmin = coords[0] if (min(pointsX) < coords[0]) else min(pointsX)\\n xmax = coords[1] if (max(pointsX) > coords[1]) else max(pointsX)\\n ymin = coords[2] if (min(pointsY) < coords[2]) else min(pointsY)\\n ymax = coords[3] if (max(pointsY) > coords[3]) else max(pointsY)\\n \\n # Specify offset and rows and columns to read\\n xoff = int((xmin - xOrigin)/pixelWidth)\\n yoff = int((yOrigin - ymax)/pixelWidth)\\n xcount = int((xmax - xmin)/pixelWidth) #+1 !!!!!!!!!!!!!!!!!!!!! This adds a pixel to the right side\\n ycount = int((ymax - ymin)/pixelWidth) #+1 !!!!!!!!!!!!!!!!!!!!! This adds a pixel to the bottom side\\n \\n #print(xoff, yoff, xcount, ycount)\\n \\n # Create memory target raster\\n target_ds = gdal.GetDriverByName('MEM').Create('', xcount, ycount, 1, gdal.GDT_Byte)\\n target_ds.SetGeoTransform((\\n xmin, pixelWidth, 0,\\n ymax, 0, pixelHeight,\\n ))\\n\\n # Create for target raster the same projection as for the value raster\\n raster_srs = osr.SpatialReference()\\n raster_srs.ImportFromWkt(raster.GetProjectionRef())\\n target_ds.SetProjection(raster_srs.ExportToWkt())\\n\\n # Rasterize zone polygon to raster\\n gdal.RasterizeLayer(target_ds, [1], lyr, burn_values=[1])\\n\\n # Read raster as arrays\\n dataBandRaster = raster.GetRasterBand(band)\\n data = dataBandRaster.ReadAsArray(xoff, yoff, xcount, ycount).astype(np.float)\\n bandmask = target_ds.GetRasterBand(1)\\n datamask = bandmask.ReadAsArray(0, 0, xcount, ycount).astype(np.float)\\n\\n # data zone of raster\\n dataZone = np.ma.masked_array(data, np.logical_not(datamask))\\n\\n raster_srs = None\\n raster = None\\n shp = None\\n lyr = None\\n return [dataZone, [xmin,xmax,ymin,ymax]]\",\n \"def get_lat_lon():\\r\\n\\r\\n # Columns: dt,AverageTemperature,AverageTemperatureUncertainty,City,Country,Latitude,Longitude\\r\\n temperatures = pd.read_csv(\\\"GlobalLandTemperatures/GlobalLandTemperaturesByCity.csv\\\")\\r\\n\\r\\n Latitude = temperatures['Latitude']\\r\\n Longitude = temperatures['Longitude']\\r\\n City = temperatures['City']\\r\\n Country = temperatures['Country']\\r\\n\\r\\n lat_array = []\\r\\n long_array = []\\r\\n cities_array = []\\r\\n countries_array = []\\r\\n tuples = []\\r\\n for i, j, city, country in zip(Latitude, Longitude, City, Country):\\r\\n if (i, j) not in tuples:\\r\\n tuples.append((i, j))\\r\\n lat_array.append(float(i[:-1]))\\r\\n long_array.append(float(j[:-1]))\\r\\n cities_array.append(city)\\r\\n countries_array.append(country)\\r\\n\\r\\n return lat_array, long_array, cities_array, countries_array\",\n \"def get_coordinates(geotags) -> Tuple[float, float]:\\n lat = get_decimal_from_dms(\\n geotags['GPSLatitude'],\\n geotags['GPSLatitudeRef'],\\n )\\n lon = get_decimal_from_dms(\\n geotags['GPSLongitude'],\\n geotags['GPSLongitudeRef'],\\n )\\n\\n return lat, lon\",\n \"def extract_loc_vec(ref_lon, ref_lat, tlon, tlat, indata):\\n\\n # find the indices of the 4 model grid points around the location\\n Ilist, Jlist = find_stn_idx(ref_lon, ref_lat, tlon, tlat)\\n\\n # compute great circle distance from location to model grid points\\n dist = gc_dist(ref_lon, ref_lat, tlon, tlat)\\n dist[dist==0] = 1.e-15 # avoid division by zero\\n\\n ibeg, iend = Ilist.min(), Ilist.max()\\n jbeg, jend = Jlist.min(), Jlist.max()\\n work = indata[...,ibeg:iend+1,jbeg:jend+1]\\n dist = dist[...,ibeg:iend+1,jbeg:jend+1]\\n wghts = 1./N.resize(dist,work.shape)\\n wavg = MA.average(work.reshape(work.shape[:-2]+(-1,)),\\n weights=wghts.reshape(work.shape[:-2]+(-1,)),axis=-1)\\n\\n return wavg\",\n \"def _get_point_source_location(element):\\n pos = element.find('%s/%s/%s' %\\n (NRML04_POINT_GEOMETRY, gml.GML_POINT, gml.GML_POS))\\n pos = pos.text.split()\\n\\n return float(pos[0]), float(pos[1])\",\n \"def global_coords(self) -> GlobalCoordsABC:\",\n \"def find_coordinates(self):\\n\\n raise NotImplementedError\",\n \"def find_coordinates(self):\\n\\n raise NotImplementedError\",\n \"def latlons(self):\\n\\t\\t\\n\\t\\t# First check we have a grid feature type\\n\\t\\tif self.featuretype in ['Grid', 'GridSeries']:\\n\\n\\t\\t\\tlatvar = self.latitude_variable\\n\\t\\t\\tlonvar = self.longitude_variable\\n\\n\\t\\t\\tlatdims = self.coordinates_mapping['latitude']['map']\\n\\t\\t\\tlondims = self.coordinates_mapping['longitude']['map']\\n\\n\\t\\t\\t# Create latitude and longitude subset slices from the field subset slices\\n\\t\\t\\tlat_subset = []\\n\\t\\t\\tfor dim in latdims:\\n\\t\\t\\t\\tlat_subset.append(self._subset[dim])\\n\\t\\t\\t\\n\\t\\t\\tlon_subset = []\\n\\t\\t\\tfor dim in londims:\\n\\t\\t\\t\\tlon_subset.append(self._subset[dim])\\n\\n\\t\\t\\t# Then check if latitude and longitude variables are 1D\\n\\t\\t\\tif len(latvar.shape) == 1 and len(lonvar.shape) == 1:\\n\\t\\t\\t\\tlatvar_2d = latvar[lat_subset].reshape((-1,1)).repeat(lonvar.shape[0], axis=1)\\n\\t\\t\\t\\tlonvar_2d = lonvar[lon_subset].reshape((-1,1)).transpose().repeat(latvar.shape[0], axis=0)\\n\\t\\t\\t\\treturn (latvar_2d, lonvar_2d)\\n\\t\\t\\t\\n\\t\\t\\t# for 2D variables its easy, just return the variable data\\n\\t\\t\\telif len(latvar.shape) >= 2 and len(lonvar.shape) >= 2:\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# Handle the WRF case where lat/lon variables are 3D with time as first dimension\\n\\t\\t\\t\\tif len(latvar.shape) == 3 and len(lonvar.shape) == 3:\\n\\t\\t\\t\\t\\treturn (latvar[0,lat_subset], lonvar[0,lon_subset])\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\treturn (latvar[lat_subset], lonvar[lon_subset])\\n\\t\\t\\t\\n\\t\\t\\t# otherwise, we can't do it!\\n\\t\\t\\telse:\\n\\t\\t\\t\\treturn (None, None)\\n\\t\\t\\n\\t\\telif self.featuretype == 'PointSeries':\\n\\t\\t\\treturn (self.latitude_variable[:], self.longitude_variable[:])\",\n \"def CreateTargetGeoMap(latS, latN, lonW, lonE, latlen, lonlen):\\n\\n lat_grid = np.linspace(latS, latN, latlen)\\n lon_grid = np.linspace(lonW, lonE, lonlen)\\n\\n return lat_grid,lon_grid\",\n \"def _dense_point_array(self, geoms, distance, index):\\n # interpolate lines to represent them as points for Voronoi\\n points = []\\n ids = []\\n\\n if pygeos.get_type_id(geoms[0]) not in [1, 2, 5]:\\n lines = pygeos.boundary(geoms)\\n else:\\n lines = geoms\\n lengths = pygeos.length(lines)\\n for ix, line, length in zip(index, lines, lengths):\\n if length > distance: # some polygons might have collapsed\\n pts = pygeos.line_interpolate_point(\\n line,\\n np.linspace(0.1, length - 0.1, num=int((length - 0.1) // distance)),\\n ) # .1 offset to keep a gap between two segments\\n points.append(pygeos.get_coordinates(pts))\\n ids += [ix] * len(pts)\\n\\n points = np.vstack(points)\\n\\n return points, ids\\n\\n # here we might also want to append original coordinates of each line\\n # to get a higher precision on the corners\",\n \"def retrieve_pixel_value(lon, lat, data_source):\\n dataset = gdal.Open(data_source)\\n\\n gt = dataset.GetGeoTransform()\\n the_band = dataset.GetRasterBand(1)\\n px = int((lon - gt[0]) / gt[1]) # x pixel\\n py = int((lat - gt[3]) / gt[5]) # y pixel\\n\\n buf = the_band.ReadRaster(px, py, 1, 1, buf_type=gdal.GDT_Int16)\\n elev = struct.unpack(\\\"h\\\", buf)\\n\\n return elev[0]\",\n \"def geoloc_to_pixelloc(lat, lon, loff, coff):\\n lat = np.atleast_1d(lat)\\n lon = np.atleast_1d(lon)\\n\\n assert lat.shape == lon.shape\\n\\n row, col = _nav.geoloc_to_pixelloc(lat, lon, loff, coff)\\n\\n if row.size == col.size == 1:\\n # Return scalars\\n return row[0], col[0]\\n else:\\n return row, col\",\n \"def get_exif_location(self, exif_data, lonlat):\\n\\n if lonlat=='lonlat':\\n lat = ''\\n lon = ''\\n gps_latitude = self._get_if_exist(exif_data, 'GPS GPSLatitude')\\n gps_latitude_ref = self._get_if_exist(exif_data, 'GPS GPSLatitudeRef')\\n gps_longitude = self._get_if_exist(exif_data, 'GPS GPSLongitude')\\n gps_longitude_ref = self._get_if_exist(exif_data, 'GPS GPSLongitudeRef')\\n\\n if gps_latitude and gps_latitude_ref and gps_longitude and gps_longitude_ref:\\n lat = self._convert_to_degress(gps_latitude)\\n if gps_latitude_ref.values[0] != 'N':\\n lat = 0 - lat\\n\\n lon = self._convert_to_degress(gps_longitude)\\n if gps_longitude_ref.values[0] != 'E':\\n lon = 0 - lon\\n\\n return lat, lon\",\n \"def map_to_local(self, idxs):\\n return F.zerocopy_from_dgl_ndarray(\\n _CAPI_DGLNDArrayPartitionMapToLocal(\\n self._partition, F.zerocopy_to_dgl_ndarray(idxs)\\n )\\n )\",\n \"def read_coordinates(self, channel=\\\"1\\\"):\\n\\n sdsidx = {\\\"VNIR\\\": (0, 1), \\\"SWIR\\\": (6, 7), \\\"TIR\\\": (14, 15)}\\n\\n latstr = \\\":\\\".join(\\n (\\n \\\"HDF4_SDS\\\",\\n \\\"UNKNOWN\\\",\\n f\\\"{self.filename}\\\",\\n f\\\"{sdsidx[self.channel2sensor[channel]][0]}\\\",\\n )\\n )\\n lat = gdal.Open(latstr)\\n lat = geocentric2geodetic(lat.ReadAsArray().astype(\\\"float\\\"))\\n\\n lonstr = \\\":\\\".join(\\n (\\n \\\"HDF4_SDS\\\",\\n \\\"UNKNOWN\\\",\\n f\\\"{self.filename}\\\",\\n f\\\"{sdsidx[self.channel2sensor[channel]][1]}\\\",\\n )\\n )\\n lon = gdal.Open(lonstr)\\n lon = lon.ReadAsArray().astype(\\\"float\\\")\\n\\n return lat, lon\",\n \"def extract_raw_simple_coordinates (raw_location):\\n pattern = re.compile('(\\\\d+).(\\\\d+)?')\\n x_result = pattern.match(str(raw_location[0]))\\n y_result = pattern.match(str(raw_location[1]))\\n return int(x_result[1]), int(y_result[1])\",\n \"def get_location(self):\\n # h = b'\\\\r\\\\nAT-MSGEO\\\\r\\\\r\\\\n-MSGEO: -3936,3464,-3612,7402d50c\\\\r\\\\n\\\\r\\\\n'\\n # an example of the string returned from the AT-MSGEO used for testing.\\n h = self.acquire_response(b'AT-MSGEO')\\n if isinstance(h, bytes):\\n h = h.decode('utf-8')\\n h = h.strip()\\n h = h.split(':')\\n h = h[1].split(',')\\n x = int(h[0])*1000 # Convert coordinates to meters.\\n y = int(h[1])*1000\\n z = int(h[2])*1000\\n else:\\n print('Location not available')\\n\\n # 'geocent' refers to the geo-centered frame that the co-ordinates are returned in\\n inProj = Proj(proj='geocent', ellps='WGS84', datum='WGS84')\\n\\n # 'latlong' is the frame to be converted to\\n outProj = Proj(proj='latlong', ellps='WGS84', datum='WGS84')\\n\\n # Convert X, Y, Z to latitude, longitude and altitude\\n long, lat, alt = transform(inProj, outProj, x, y, z, radians=False)\\n # l = [str(long), str(lat), str(alt)]\\n return long, lat, alt\",\n \"def get_lat(idx, header, randomize=False):\\n lat = header[Y_CORNER] + header[N_ROWS] - idx - 0.5\\n if randomize:\\n lat += np.random.normal(-0.5, 1, size=lat.shape)\\n return lat\",\n \"def _get_grid_cell_indexes(proj, xs, ys, bounding_box):\\n # Unpack values from the projection\\n eq_rad = proj.semi_major_axis\\n polar_rad = proj.semi_minor_axis\\n h = proj.perspective_point_height + eq_rad\\n lon0 = proj.longitude_of_projection_origin\\n \\n # Unpack values from the area we want to grab the data\\n min_lat, min_lon = bounding_box.sw_corner()\\n max_lat, max_lon = bounding_box.ne_corner()\\n \\n with np.errstate(invalid='ignore'):\\n # Calculate the lat and lon grids\\n xs, ys = np.meshgrid(xs, ys)\\n a_vals = np.power(np.sin(xs), 2.0) + \\\\\\n np.power(np.cos(xs), 2.0) * (np.power(np.cos(ys), 2.0) + \\\\\\n eq_rad * eq_rad / polar_rad / polar_rad * np.power(np.sin(ys), 2.0))\\n b_vals = -2 * h * np.cos(xs) * np.cos(ys)\\n c_val = h * h - eq_rad * eq_rad\\n \\n rs = (-b_vals - np.sqrt(np.power(b_vals, 2.0) - 4 * a_vals * c_val)) / (2 * a_vals)\\n \\n sx = rs * np.cos(xs) * np.cos(ys)\\n sy = -rs * np.sin(xs)\\n sz = rs * np.cos(xs) * np.sin(ys)\\n \\n lats = np.arctan((eq_rad *eq_rad * sz) \\\\\\n / (polar_rad * polar_rad * np.sqrt(np.power(h - sx, 2.0) + np.power(sy, 2.0))))\\n lats = np.degrees(lats)\\n \\n lons = np.radians(lon0) - np.arctan(sy / (h - sx))\\n lons = np.degrees(lons)\\n \\n # Flatten the arrays so we get a 1D list of indexes\\n lats = lats.flatten()\\n lons = lons.flatten()\\n \\n # Filter out values not in our bounding box\\n lats = np.where(np.logical_and(lats >= min_lat, lats <= max_lat))[0]\\n lons = np.where(np.logical_and(lons >= min_lon, lons <= max_lon))[0]\\n idxs = list(set(lons).intersection(set(lats)))\\n \\n return idxs\",\n \"def _generate_coords(self):\\n coords = np.dstack([self.X.ravel(), self.Y.ravel()])[0]\\n return coords, spatial.cKDTree(coords)\",\n \"def best_coords(self):\\n lat, lon = None, None\\n for term in self.terms:\\n # print(term)\\n # print(term['weight'])\\n geo = term.get(\\\"geo\\\")\\n if geo:\\n osm = geo['osm']\\n gm = geo['gm']\\n geo_data = None\\n if osm:\\n geo_data = osm\\n elif gm:\\n geo_data = gm\\n if geo_data:\\n g = geo_data[0]\\n lat, lon = g['latitude'], g['longitude']\\n break\\n return lat, lon, self.region\",\n \"def latlonsel(array, lat, lon, latname='lat', lonname='lon'):\\n assert latname in array.coords, f\\\"Coord. {latname} not present in array\\\"\\n assert lonname in array.coords, f\\\"Coord. {lonname} not present in array\\\"\\n\\n if isinstance(lat, slice):\\n lat1 = lat.start\\n lat2 = lat.stop\\n elif isinstance(lat, list):\\n lat1 = lat[0]\\n lat2 = lat[-1]\\n if isinstance(lon, slice):\\n lon1 = lon.start\\n lon2 = lon.stop\\n elif isinstance(lon, list):\\n lon1 = lon[0]\\n lon2 = lon[-1]\\n\\n lonmask = (array[lonname] < lon2) & (array[lonname] > lon1)\\n latmask = (array[latname] < lat2) & (array[latname] > lat1)\\n array = array.where(lonmask, drop=True).where(latmask, drop=True)\\n return array\",\n \"def get_latlon():\\n\\t\\n iss.compute() # Get the lat/long values from ephem\\n long_value = [float(i) for i in str(iss.sublong).split(\\\":\\\")]\\n if long_value[0] < 0:\\n long_value[0] = abs(long_value[0])\\n cam.exif_tags['GPS.GPSLongitudeRef'] = \\\"W\\\"\\n else:\\n cam.exif_tags['GPS.GPSLongitudeRef'] = \\\"E\\\"\\n cam.exif_tags['GPS.GPSLongitude'] = '%d/1,%d/1,%d/10' % (long_value[0], long_value[1], long_value[2]*10)\\n lat_value = [float(i) for i in str(iss.sublat).split(\\\":\\\")]\\n if lat_value[0] < 0:\\n lat_value[0] = abs(lat_value[0])\\n cam.exif_tags['GPS.GPSLatitudeRef'] = \\\"S\\\"\\n else:\\n cam.exif_tags['GPS.GPSLatitudeRef'] = \\\"N\\\"\\n cam.exif_tags['GPS.GPSLatitude'] = '%d/1,%d/1,%d/10' % (lat_value[0], lat_value[1], lat_value[2]*10)\\n return (iss.sublat / degree, iss.sublong / degree)\",\n \"def find_coordinates(self):\\n\\n raise AttributeError(\\n \\\"Cannot get available coordinates for OGR datasources. \\\"\\n \\\"The source data is a vector-based shapefile without native coordinates.\\\"\\n )\",\n \"def _getCoords(self):\\n\\n if self._coords is not None:\\n return self._coords[self._acsi]\",\n \"def geo(self):\\n return self.query.geo\",\n \"def test_access(geometry):\\n geometry.print_list_of_geos()\\n geometry.print_list_of_geos_children()\\n\\n logger.info('TOP GEO:')\\n top_geo = geometry.get_top_geo()\\n top_geo.print_geo_children()\\n\\n logger.info('INTERMEDIATE GEO (QUAD):')\\n geo = geometry.get_geo('QUAD:V1', 0)\\n #geo = geometry.get_top_geo()\\n geo.print_geo_children()\\n\\n t0_sec = time()\\n X,Y,Z = geo.get_pixel_coords(do_tilt=True)\\n #X,Y = geo.get_2d_pixel_coords()\\n s = 'X: %s' % str(X)\\n s+= '\\\\n Consumed time to get 3d pixel coordinates = %7.3f sec' % (time()-t0_sec)\\n s+= '\\\\n Geometry object: %s:%d X.shape:%s' % (geo.oname, geo.oindex, str(X.shape))\\n logger.info(s)\\n\\n logger.info('Test of print_pixel_coords() for quad:')\\n geometry.print_pixel_coords('QUAD:V1', 1)\\n logger.info('Test of print_pixel_coords() for CSPAD:')\\n geometry.print_pixel_coords()\\n\\n s = 'Test of get_pixel_areas() for QUAD:'\\n A = geo.get_pixel_areas()\\n s+= '\\\\n Geometry object: %s:%d A.shape:%s' % (geo.oname, geo.oindex, str(A.shape))\\n s+= '\\\\n A[0,0:5,190:198]:\\\\n' + str(A[0,0:5,190:198])\\n logger.info(s)\\n\\n s = 'Test of get_pixel_areas() for CSPAD:'\\n A = top_geo.get_pixel_areas()\\n s+= '\\\\n Geometry object: %s:%d A.shape:%s' % (geo.oname, geo.oindex, str(A.shape))\\n s+= '\\\\n A[0,0,0:5,190:198]:\\\\n' + str(A[0,0,0:5,190:198])\\n logger.info(s)\\n\\n s = 'Test of get_size_geo_array()'\\n s+= '\\\\n for QUAD: %d' % geo.get_size_geo_array()\\n s+= '\\\\n for CSPAD: %d' % top_geo.get_size_geo_array()\\n logger.info(s)\\n\\n s = 'Test of get_pixel_scale_size()'\\n s+= '\\\\n for QUAD : %8.2f' % geo.get_pixel_scale_size()\\n s+= '\\\\n for CSPAD : %8.2f' % top_geo.get_pixel_scale_size()\\n s+= '\\\\n for geometry: %8.2f' % geometry.get_pixel_scale_size()\\n logger.info(s)\\n\\n s = 'Test of get_dict_of_comments():'\\n d = geometry.get_dict_of_comments()\\n s+= '\\\\n d[0] = %s' % str(d[0])\\n logger.info(s)\",\n \"def get_coordinates(addresses, boroughs):\\n latitude = []\\n longitude = []\\n for address, borough in zip(addresses, boroughs):\\n try:\\n g = geocoder.osm('{}, {}, New York'.format(address, borough)).json\\n latitude.append(g['lat'])\\n longitude.append(g['lng'])\\n except:\\n latitude.append(None)\\n longitude.append(None)\\n\\n return np.array(latitude).T, np.array(longitude).T\",\n \"def test_rasters_and_arrays(self):\\n\\n # Create test data\\n lon_ul = 100 # Longitude of upper left corner\\n lat_ul = 10 # Latitude of upper left corner\\n numlon = 8 # Number of longitudes\\n numlat = 5 # Number of latitudes\\n dlon = 1\\n dlat = -1\\n\\n # Define array where latitudes are rows and longitude columns\\n A1 = numpy.zeros((numlat, numlon))\\n\\n # Establish coordinates for lower left corner\\n lat_ll = lat_ul - numlat\\n lon_ll = lon_ul\\n\\n # Define pixel centers along each direction\\n lon = numpy.linspace(lon_ll + 0.5, lon_ll + numlon - 0.5, numlon)\\n lat = numpy.linspace(lat_ll + 0.5, lat_ll + numlat - 0.5, numlat)\\n\\n # Define raster with latitudes going bottom-up (south to north).\\n # Longitudes go left-right (west to east)\\n for i in range(numlat):\\n for j in range(numlon):\\n A1[numlat - 1 - i, j] = linear_function(lon[j], lat[i])\\n\\n # Throw in a nodata element\\n A1[2, 6] = numpy.nan\\n\\n # Upper left corner\\n assert A1[0, 0] == 105.25\\n assert A1[0, 0] == linear_function(lon[0], lat[4])\\n\\n # Lower left corner\\n assert A1[4, 0] == 103.25\\n assert A1[4, 0] == linear_function(lon[0], lat[0])\\n\\n # Upper right corner\\n assert A1[0, 7] == 112.25\\n assert A1[0, 7] == linear_function(lon[7], lat[4])\\n\\n # Lower right corner\\n assert A1[4, 7] == 110.25\\n assert A1[4, 7] == linear_function(lon[7], lat[0])\\n\\n # Generate raster object and write\\n projection = ('GEOGCS[\\\"WGS 84\\\",'\\n 'DATUM[\\\"WGS_1984\\\",'\\n 'SPHEROID[\\\"WGS 84\\\",6378137,298.2572235630016,'\\n 'AUTHORITY[\\\"EPSG\\\",\\\"7030\\\"]],'\\n 'AUTHORITY[\\\"EPSG\\\",\\\"6326\\\"]],'\\n 'PRIMEM[\\\"Greenwich\\\",0],'\\n 'UNIT[\\\"degree\\\",0.0174532925199433],'\\n 'AUTHORITY[\\\"EPSG\\\",\\\"4326\\\"]]')\\n geotransform = (lon_ul, dlon, 0, lat_ul, 0, dlat)\\n R1 = Raster(A1, projection, geotransform,\\n keywords={'testkwd': 'testval', 'size': 'small'})\\n\\n # Check string representation of raster class\\n assert str(R1).startswith('Raster data')\\n assert str(R1.rows) in str(R1)\\n assert str(R1.columns) in str(R1)\\n\\n # Test conversion between geotransform and\\n # geometry (longitudes and latitudes)\\n longitudes, latitudes = R1.get_geometry()\\n msg = 'Longitudes not as expected: %s' % str(longitudes)\\n assert numpy.allclose(longitudes, [100.5, 101.5, 102.5, 103.5, 104.5,\\n 105.5, 106.5, 107.5]), msg\\n\\n msg = 'Latitudes not as expected: %s' % str(latitudes)\\n assert numpy.allclose(latitudes, [5.5, 6.5, 7.5, 8.5, 9.5]), msg\\n\\n gt = raster_geometry2geotransform(longitudes, latitudes)\\n msg = ('Conversion from coordinates to geotransform failed: %s'\\n % str(gt))\\n assert numpy.allclose(gt, geotransform,\\n rtol=1.0e-12, atol=1.0e-12), msg\\n\\n msg = ('Dimensions of raster array do not match those of '\\n 'raster object')\\n assert numlat == R1.rows, msg\\n assert numlon == R1.columns, msg\\n\\n # Write back to new (tif) file\\n out_filename = unique_filename(suffix='.tif')\\n R1.write_to_file(out_filename)\\n assert R1.filename == out_filename\\n\\n # Check nodata in original layer\\n assert numpy.isnan(R1.get_nodata_value())\\n\\n # Read again and check consistency\\n R2 = read_layer(out_filename)\\n assert R2.filename == out_filename\\n\\n # Check nodata in read layer\\n assert numpy.isnan(R2.get_nodata_value())\\n\\n msg = ('Dimensions of written raster array do not match those '\\n 'of input raster file\\\\n')\\n msg += (' Dimensions of input file '\\n '%s: (%s, %s)\\\\n' % (R1.filename, numlat, numlon))\\n msg += (' Dimensions of output file %s: '\\n '(%s, %s)' % (R2.filename, R2.rows, R2.columns))\\n\\n assert numlat == R2.rows, msg\\n assert numlon == R2.columns, msg\\n\\n A2 = R2.get_data()\\n\\n assert numpy.allclose(numpy.nanmin(A1), numpy.nanmin(A2))\\n assert numpy.allclose(numpy.nanmax(A1), numpy.nanmax(A2))\\n\\n msg = 'Array values of written raster array were not as expected'\\n assert nanallclose(A1, A2), msg\\n\\n msg = 'Geotransforms were different'\\n assert R1.get_geotransform() == R2.get_geotransform(), msg\\n\\n p1 = R1.get_projection(proj4=True)\\n p2 = R2.get_projection(proj4=True)\\n msg = 'Projections were different: %s != %s' % (p1, p2)\\n assert p1 == p1, msg\\n\\n # Exercise projection __eq__ method\\n assert R1.projection == R2.projection\\n\\n # Check that equality raises exception when type is wrong\\n try:\\n R1.projection == 234\\n except TypeError:\\n pass\\n else:\\n msg = 'Should have raised TypeError'\\n raise Exception(msg)\\n\\n # Check keywords\\n assert R1.keywords == R2.keywords\\n\\n # Check override of ==\\n assert R1 == R2\",\n \"def GeoGrid_by_ncref(nc_varstring, nc_timeindex=0):\\n try:\\n ds = gdal.Open(nc_varstring, gdalconst.GA_ReadOnly)\\n assert ds is not None\\n except AssertionError:\\n raise ValueError('could not open netCDF file: {}'.format(nc_varstring))\\n\\n nc_string, nc_fname, nc_fieldname = nc_varstring.split(':')\\n\\n # Field name is specifiec as the nc_fname\\n # Each slice of the 2D array is a single Raster here\\n # ...\\n dataset_array = ds.ReadAsArray()\\n if len(dataset_array.shape) == 3:\\n assert nc_timeindex < ds.RasterCount\\n dataset_array = dataset_array[nc_timeindex]\\n\\n assert len(dataset_array.shape) == 2\\n\\n ydim, xdim = dataset_array.shape\\n\\n # Sample geotransform values:\\n # (-3850000.0, 25000.0, 0.0, 5850000.0, 0.0, -25000.0)\\n ds_geotransform = ds.GetGeoTransform()\\n try:\\n assert ds_geotransform[2] == 0\\n assert ds_geotransform[4] == 0\\n except AssertionError:\\n raise ValueError('only 1D x,y values are supported')\\n\\n x = np.linspace(\\n ds_geotransform[0] + 0.5 * ds_geotransform[1],\\n ds_geotransform[0] + (xdim - 0.5) * ds_geotransform[1],\\n xdim)\\n y = np.linspace(\\n ds_geotransform[3] + 0.5 * ds_geotransform[5],\\n ds_geotransform[3] + (ydim - 0.5) * ds_geotransform[5],\\n ydim)\\n\\n return GeoGrid(dataset_array, x, y, ds.GetProjection())\",\n \"def make_xarray_coords(y, x, crs):\\n if crs.is_geographic:\\n y_attrs, x_attrs = COORD_DEFS['latitude'], COORD_DEFS['longitude']\\n elif crs.is_projected:\\n crs_osr = crs2osr(crs)\\n units = crs_osr.GetLinearUnitsName()\\n y_attrs, x_attrs = COORD_DEFS['y'], COORD_DEFS['x']\\n y_attrs['units'], x_attrs['units'] = units, units\\n\\n y = xr.Variable(('y', ), y, attrs=y_attrs)\\n x = xr.Variable(('x', ), x, attrs=x_attrs)\\n\\n return y, x\",\n \"def pndindex(*args):\\r\\n return np.ndindex(*args)\",\n \"def find_closest_pt(ref_lon, ref_lat, tlon, tlat):\\n\\n # compute great circle distance from location to model grid points\\n dist = gc_dist(ref_lon, ref_lat, tlon, tlat)\\n\\n # find j index of closest grid point\\n work = N.take(dist,N.argmin(dist,0),0).diagonal()\\n jj = N.argsort(work)[0]\\n\\n # find i index of closest grid point\\n work = N.take(dist,N.argmin(dist,1),1).diagonal()\\n ii = N.argsort(work)[0]\\n\\n return ii, jj\",\n \"def proj(self,lon,lat):\\n x, y = self(np.atleast_1d(lon),np.atleast_1d(lat))\\n x[x > 1e29] = None\\n y[y > 1e29] = None\\n #return np.ma.array(x,mask=x>1e2),np.ma.array(y,mask=y>1e2)\\n return x, y\",\n \"def get_lat_long(self, postcodes):\\n # Fix evil postcodes\\n postcodes = clean_postcodes(postcodes)\\n\\n postcode_df = self.postcode_df\\n postcode_df = postcode_df.fillna('np.nan')\\n postcode_df = postcode_df.set_index('Postcode')\\n index_data = postcode_df.loc[postcodes]\\n lat = np.array(index_data['Latitude']).T\\n lng = np.array(index_data['Longitude']).T\\n\\n return np.vstack((lat, lng)).transpose()\",\n \"def spatial(self):\\n return self.spatial_x, self.spatial_y, self.spatial_data\",\n \"def indices ( self, *r):\\n \\n if len(r) == 3: # only 3 values given -> use x,y,radius method\\n xpos = self.gpos\\n xis = []\\n yis = []\\n dr2 = (xpos[0, :]-r[0])**2 + (xpos[1, :]-r[1])**2\\n # array with true/false entries\\n inds = dr2 <= r[2]**2 \\n for np in arange(self.size)[inds]: # np -- points in x2-circle\\n xi, yi = self.index(xpos[0, np], xpos[1, np])\\n xis += [xi]\\n yis += [yi]\\n if not (xis and yis): # if no points in circle, take nearest one\\n return self.index(r[0], r[1])\\n else:\\n return array(xis), array(yis)\\n elif len(r) == 4: # rectangular subdomain - old functionality\\n xi1, yi1 = self.index(min(r[0], r[2]), min(r[1], r[3]))\\n xi2, yi2 = self.index(max(r[0], r[2]), max(r[1], r[3]))\\n return s_[xi1:xi2+1], s_[yi1:yi2+1]\\n else: # use enveloping polygon\\n xpos = self.gpos\\n xis = []\\n yis = []\\n #replaced matplotlib Path by numpy\\n #p = Path(array(r).reshape(-1,2))\\n #inds = p.contains_points()\\n #inds = in_poly(xpos[:2,:].T,array(r).reshape(-1,2))\\n poly = Polygon(array(r).reshape(-1,2)[:,0],array(r).reshape(-1,2)[:,1])\\n dists = poly.is_inside(xpos[0,:],xpos[1,:]) \\n inds = dists >= 0\\n for np in arange(self.size)[inds]: # np -- points in x2-circle\\n xi, yi = self.index(xpos[0, np], xpos[1, np])\\n xis += [xi]\\n yis += [yi]\\n if not (xis and yis): # if no points inside, take nearest to center\\n center = array(r).reshape(-1,2).mean(0)\\n return self.index(center[0], center[1])\\n else:\\n return array(xis), array(yis)\\n #return arange(self.size)[inds]\",\n \"def indices ( self, *r):\\n \\n if len(r) == 3: # only 3 values given -> use x,y,radius method\\n xpos = self.gpos\\n xis = []\\n yis = []\\n dr2 = (xpos[0, :]-r[0])**2 + (xpos[1, :]-r[1])**2\\n # array with true/false entries\\n inds = dr2 <= r[2]**2 \\n for np in arange(self.size)[inds]: # np -- points in x2-circle\\n xi, yi = self.index(xpos[0, np], xpos[1, np])\\n xis += [xi]\\n yis += [yi]\\n if not (xis and yis): # if no points in circle, take nearest one\\n return self.index(r[0], r[1])\\n else:\\n return array(xis), array(yis)\\n elif len(r) == 4: # rectangular subdomain - old functionality\\n xi1, yi1 = self.index(min(r[0], r[2]), min(r[1], r[3]))\\n xi2, yi2 = self.index(max(r[0], r[2]), max(r[1], r[3]))\\n return s_[xi1:xi2+1], s_[yi1:yi2+1]\\n else: # use enveloping polygon\\n xpos = self.gpos\\n xis = []\\n yis = []\\n #replaced matplotlib Path by numpy\\n #p = Path(array(r).reshape(-1,2))\\n #inds = p.contains_points()\\n #inds = in_poly(xpos[:2,:].T,array(r).reshape(-1,2))\\n poly = Polygon(array(r).reshape(-1,2)[:,0],array(r).reshape(-1,2)[:,1])\\n dists = poly.is_inside(xpos[0,:],xpos[1,:]) \\n inds = dists >= 0\\n for np in arange(self.size)[inds]: # np -- points in x2-circle\\n xi, yi = self.index(xpos[0, np], xpos[1, np])\\n xis += [xi]\\n yis += [yi]\\n if not (xis and yis): # if no points inside, take nearest to center\\n center = array(r).reshape(-1,2).mean(0)\\n return self.index(center[0], center[1])\\n else:\\n return array(xis), array(yis)\\n #return arange(self.size)[inds]\",\n \"def getCoords(self): # real signature unknown; restored from __doc__\\r\\n pass\",\n \"def get_min_max_indices(latitudes_ref, longitudes_ref,\\n minlat=None, maxlat=None,\\n minlon=None, maxlon=None):\\n\\n latitudes = latitudes_ref[:]\\n longitudes = longitudes_ref[:]\\n\\n latitudes = ensure_numeric(latitudes)\\n longitudes = ensure_numeric(longitudes)\\n\\n assert num.allclose(num.sort(longitudes), longitudes)\\n\\n #print latitudes[0],longitudes[0]\\n #print len(latitudes),len(longitudes)\\n #print latitudes[len(latitudes)-1],longitudes[len(longitudes)-1]\\n\\n lat_ascending = True\\n if not num.allclose(num.sort(latitudes), latitudes):\\n lat_ascending = False\\n # reverse order of lat, so it's in ascending order\\n latitudes = latitudes[::-1]\\n assert num.allclose(num.sort(latitudes), latitudes)\\n\\n largest_lat_index = len(latitudes)-1\\n\\n #Cut out a smaller extent.\\n if minlat is None:\\n lat_min_index = 0\\n else:\\n lat_min_index = num.searchsorted(latitudes, minlat)-1\\n if lat_min_index < 0:\\n lat_min_index = 0\\n\\n if maxlat is None:\\n lat_max_index = largest_lat_index #len(latitudes)\\n else:\\n lat_max_index = num.searchsorted(latitudes, maxlat)\\n if lat_max_index > largest_lat_index:\\n lat_max_index = largest_lat_index\\n\\n if minlon is None:\\n lon_min_index = 0\\n else:\\n lon_min_index = num.searchsorted(longitudes, minlon)-1\\n if lon_min_index < 0:\\n lon_min_index = 0\\n\\n if maxlon is None:\\n lon_max_index = len(longitudes)\\n else:\\n lon_max_index = num.searchsorted(longitudes, maxlon)\\n\\n # Reversing the indexes, if the lat array is decending\\n if lat_ascending is False:\\n lat_min_index, lat_max_index = largest_lat_index - lat_max_index, \\\\\\n largest_lat_index - lat_min_index\\n lat_max_index = lat_max_index + 1 # taking into account how slicing works\\n lon_max_index = lon_max_index + 1 # taking into account how slicing works\\n\\n return lat_min_index, lat_max_index, lon_min_index, lon_max_index\",\n \"def _staticneighs_get_corestored_by_inds_slice(self, inds):\\n inds = [inds] if type(inds) == int else inds\\n idxs = self.idxs\\n if self.sp_relative_pos is not None:\\n sp_relative_pos = [self.sp_relative_pos[i] for i in inds]\\n else:\\n sp_relative_pos = None\\n return idxs, sp_relative_pos\",\n \"def XCAFDoc_ShapeTool_GetLocation(*args):\\n return _XCAFDoc.XCAFDoc_ShapeTool_GetLocation(*args)\",\n \"def linear_interpolation_of_x_y(georeferenced_array, extent_minimum,\\n extent_maximum):\\n # Extracts axis 1 (columns) from the input array.\\n # This represents the longitude.\\n if extent_minimum == x0:\\n inn = georeferenced_array[0, :]\\n\\n # Extracts axis 0 (rows) from the input array.\\n # This represents the latitude.\\n elif extent_minimum == y0:\\n inn = georeferenced_array[:, 0]\\n\\n #\\n linear_interpolation = [((i-0)*(extent_maximum-extent_minimum)/(\\n (len(inn)-1)-0)+extent_minimum) for i, r in enumerate(inn)]\\n\\n # Claculates the difference between the value in front and the value\\n # behind in the list\\n difference = [y - x for x, y in zip(linear_interpolation,\\n linear_interpolation[1:])]\\n\\n # Calculates the size of each array so to compare it to the size of the\\n # input array.\\n array_length = [np.size(np.arange(\\n extent_minimum, extent_maximum, i)) for i in difference]\\n\\n # Select values that only match the longitude/latitude length then return\\n # the first index in the list of matched values.\\n # This list is a list of indexes that correspond to the index in the\\n # variable difference.\\n index_of_correct_value = [i for i, v in enumerate(\\n array_length) if v == len(inn)][0]\\n\\n #\\n interpolated_coordinates = np.arange(extent_minimum,\\n extent_maximum,\\n difference[index_of_correct_value])\\n\\n return interpolated_coordinates\",\n \"def find_loc_indices(loc, dir, tile):\\n #returns the indices of the nearest neighbor point in the given tile, the lon/lat of the nearest neighbor, \\n #and the distance (m) from the given point to the nearest neighbor grid cell\\n \\n filename_pattern = '*grid.tile{0}.nc'.format(tile)\\n for f_name in os.listdir(dir):\\n if fnmatch.fnmatch(f_name, filename_pattern):\\n filename = f_name\\n if not filename:\\n message = 'No filenames matching the pattern {0} found in {1}'.format(filename_pattern,dir)\\n logging.critical(message)\\n raise Exception(message)\\n \\n nc_file = Dataset('{0}/{1}'.format(dir,filename))\\n #read in supergrid longitude and latitude\\n lon_super = np.array(nc_file['x']) #[lat,lon] or [y,x] #.swapaxes(0,1)\\n lat_super = np.array(nc_file['y']) #[lat,lon] or [y,x] #.swapaxes(0,1)\\n #get the longitude and latitude data for the grid centers by slicing the supergrid \\n #and taking only odd-indexed values\\n longitude = lon_super[1::2,1::2]\\n latitude = lat_super[1::2,1::2]\\n nc_file.close()\\n \\n adj_long = False \\n #look for reversal of longitude; if found, adjust longitude so that 0-360 transition doesn't exist\\n temp_loc = copy.deepcopy(loc)\\n for row in longitude:\\n if not (np.all(np.diff(row) >= 0) or np.all(np.diff(row) <= 0)):\\n adj_long = True\\n if adj_long:\\n longitude[longitude < 180] += 360\\n if loc[0] < 180:\\n temp_loc[0] += 360\\n \\n #set up an array to hold the euclidean distance between the given point and every grid cell\\n eucl_dist = np.zeros((longitude.shape[0],longitude.shape[1]))\\n \\n #get the Cartesian location of the given point\\n cart_loc = np.array(sph2cart(math.radians(temp_loc[0]), math.radians(temp_loc[1]), earth_radius))\\n \\n for i in range(len(longitude)):\\n for j in range(len(longitude[i])):\\n #get the Cartesian location of all grid points\\n cart_cell = np.array(sph2cart(math.radians(longitude[i,j]), math.radians(latitude[i,j]), earth_radius))\\n \\n #calculate the euclidean distance from the given point to the current grid cell\\n eucl_dist[i,j] = np.linalg.norm(cart_loc - cart_cell)\\n \\n #get the indices of the grid point with the minimum euclidean distance to the given point\\n i,j = np.unravel_index(eucl_dist.argmin(), eucl_dist.shape)\\n \\n return (i,j,longitude[i,j]%360.0, latitude[i,j], eucl_dist[i,j])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64533174","0.62730485","0.6266516","0.6246362","0.6216341","0.6202899","0.6187555","0.6148967","0.6142526","0.6036951","0.5968435","0.59425825","0.59397787","0.5923113","0.5836684","0.5829554","0.58170235","0.58012676","0.5789401","0.5754598","0.5750754","0.5750754","0.57456744","0.57349545","0.57268816","0.57253015","0.56754977","0.5673673","0.5631847","0.5627104","0.5610564","0.5609479","0.56093705","0.5584122","0.55805445","0.5577563","0.5575583","0.5572738","0.5571851","0.557077","0.5568236","0.553912","0.55337423","0.5525489","0.5523424","0.55232066","0.5523036","0.55206734","0.55111015","0.55092174","0.5506088","0.55050355","0.55002844","0.5497976","0.5489435","0.54880315","0.5485697","0.54848784","0.54829526","0.5473262","0.54655635","0.54650956","0.54650956","0.5465092","0.54614323","0.5452942","0.54472536","0.54430056","0.54401696","0.543529","0.54326135","0.54301697","0.54210824","0.5419399","0.54143065","0.5407736","0.5403664","0.540037","0.53949004","0.53892446","0.53887904","0.5381636","0.5380383","0.53782517","0.5376626","0.5371825","0.53710216","0.5361185","0.53577834","0.5357545","0.53551805","0.5353637","0.53532755","0.53532755","0.5350231","0.5345147","0.5345117","0.5343597","0.5342515","0.53321"],"string":"[\n \"0.64533174\",\n \"0.62730485\",\n \"0.6266516\",\n \"0.6246362\",\n \"0.6216341\",\n \"0.6202899\",\n \"0.6187555\",\n \"0.6148967\",\n \"0.6142526\",\n \"0.6036951\",\n \"0.5968435\",\n \"0.59425825\",\n \"0.59397787\",\n \"0.5923113\",\n \"0.5836684\",\n \"0.5829554\",\n \"0.58170235\",\n \"0.58012676\",\n \"0.5789401\",\n \"0.5754598\",\n \"0.5750754\",\n \"0.5750754\",\n \"0.57456744\",\n \"0.57349545\",\n \"0.57268816\",\n \"0.57253015\",\n \"0.56754977\",\n \"0.5673673\",\n \"0.5631847\",\n \"0.5627104\",\n \"0.5610564\",\n \"0.5609479\",\n \"0.56093705\",\n \"0.5584122\",\n \"0.55805445\",\n \"0.5577563\",\n \"0.5575583\",\n \"0.5572738\",\n \"0.5571851\",\n \"0.557077\",\n \"0.5568236\",\n \"0.553912\",\n \"0.55337423\",\n \"0.5525489\",\n \"0.5523424\",\n \"0.55232066\",\n \"0.5523036\",\n \"0.55206734\",\n \"0.55111015\",\n \"0.55092174\",\n \"0.5506088\",\n \"0.55050355\",\n \"0.55002844\",\n \"0.5497976\",\n \"0.5489435\",\n \"0.54880315\",\n \"0.5485697\",\n \"0.54848784\",\n \"0.54829526\",\n \"0.5473262\",\n \"0.54655635\",\n \"0.54650956\",\n \"0.54650956\",\n \"0.5465092\",\n \"0.54614323\",\n \"0.5452942\",\n \"0.54472536\",\n \"0.54430056\",\n \"0.54401696\",\n \"0.543529\",\n \"0.54326135\",\n \"0.54301697\",\n \"0.54210824\",\n \"0.5419399\",\n \"0.54143065\",\n \"0.5407736\",\n \"0.5403664\",\n \"0.540037\",\n \"0.53949004\",\n \"0.53892446\",\n \"0.53887904\",\n \"0.5381636\",\n \"0.5380383\",\n \"0.53782517\",\n \"0.5376626\",\n \"0.5371825\",\n \"0.53710216\",\n \"0.5361185\",\n \"0.53577834\",\n \"0.5357545\",\n \"0.53551805\",\n \"0.5353637\",\n \"0.53532755\",\n \"0.53532755\",\n \"0.5350231\",\n \"0.5345147\",\n \"0.5345117\",\n \"0.5343597\",\n \"0.5342515\",\n \"0.53321\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72259116"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21295,"cells":{"query":{"kind":"string","value":"Plot transparent fem result on highres srt hillshade with summit and stations, etc comp=0,1,2,3 > ux, uy, uz, ur"},"document":{"kind":"string","value":"def uturuncu_map(surfaceFile,dem,comp=2):\n fig = plt.figure()\n ax = fig.add_subplot(111)\n\n #print(datadir)\n #print(dem)\n geosurface = pu.surface2geotiff(dem,surfaceFile,outname=None,comp=comp,nanval=-9999)\n\n #load georeferenced fem output from pu.surface2geotiff\n #geosurface = '/home/scott/research/models/pylith/scripts/geo_fem_Uz.tif'\n data,geotrans,proj = pu.load_gdal(geosurface)\n data = data*100 # N-up, units=m\n nLat, nLon = data.shape\n\n\n #NOTE: are basmap ll and ur corner or center pixel locations??\n bmap = bm.Basemap(projection='tmerc', #NOTE: if changing to 'merc' have to use latlon=True\n resolution='i',\n lon_0=-67.18,\n lat_0=-22.27,\n width=200000.0,\n height=200000.0,\n suppress_ticks=True, #set to true if using drawmeridians\n ax=ax)\n\n # Set map background\n #dem = '/home/scott/data/dems/cgiar/uturuncu_1000_1000.tif'\n # full res\n dem = os.path.join(datadir,'dems/cgiar/srtm_23_17.tif')\n bmap.background(style='srtm', file=dem, zscale=1.5)\n\n # Annotate\n bmap.drawcountries(linewidth=1,color='k')\n bmap.drawcoastlines(linewidth=1,color='k')\n meridians = np.arange(-68,-65,1)\n md = bmap.drawmeridians(meridians, labels=[0,0,0,1])\n parallels = np.arange(-24,-20,1)\n pl = bmap.drawparallels(parallels, labels=[1,0,0,0])\n\n # Overlay FEM result\n compdict = {0:'Ux',1:'Uy',2:'Uz',3:'Ur'}\n im = bmap.imshow(data, origin='upper', alpha=0.7) #alternatively flipud(data)\n cb = bmap.colorbar(im)\n cb.set_label('{} [cm]'.format(compdict[comp]))\n\n # Uturunu Summit\n bmap.plot(-67.18, -22.27, 'r^', latlon=True,label='Uturuncu')\n\n # Location of maximum uplift\n # NOTE: multiple coordinate transforms needed here\n maxval = np.nanmax(data)\n indflat = np.nanargmax(data)\n ind = np.unravel_index(indflat, data.shape) #NOTE row,col --> (y,x)\n lon,lat = ind2latlon(ind, geosurface)\n bmap.plot(lon,lat,'y*',latlon=True,label='Uz_max')\n print('Maximum={} at ({:.2f},{:.2f})\\n'.format(maxval, lon, lat))\n\n # PLUTONS seismometers\n path = os.path.join(datadir,'vector/uturuncu_plutons_seis')\n sm = bmap.readshapefile(path,'seis',drawbounds=False)\n x,y = np.hsplit(np.array(bmap.seis),2)\n bmap.plot(x,y,'wv', mec='k', markersize=10, mew=2, label='3T')\n\n # Continuous GPS\n path = os.path.join(datadir,'vector/uturuncu_contGPS')\n bmap.readshapefile(path,'cGPS',drawbounds=False)\n x,y = np.hsplit(np.array(bmap.cGPS),2)\n bmap.plot(x,y,'go', mec='k', markersize=10, mew=2, label='cGPS')\n\n # Scalebar\n length = 50 #km\n # Scale in lower left\n lon = bmap.llcrnrlon + (length/2.0/100) + (bmap.lonmax - bmap.lonmin)*0.05 #pad by 5% of length, also add 1/2 length of scale length\n lat = bmap.llcrnrlat + (bmap.latmax - bmap.latmin)*0.05\n # Upper Right (todo)\n scale = bmap.drawmapscale(lon, lat, bmap.projparams['lon_0'],bmap.projparams['lon_0'],\n length, #50km\n barstyle='fancy',\n #barstyle='simple',\n fontsize=14)\n\n # More Annotations\n plt.legend(loc='upper right',numpoints=1)\n plt.title('FEM Model Output')\n #plt.savefig('map_fem.png',bbox_inches='tight')\n plt.show()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def plot_Ae_HDR10_exr_nl_out_vari_prj_white(graph_name=\"./img/out.png\"):\n width = 1920\n\n fname_list = [\n \"./AfterEffects/Comp 1/prj_w_W-none _00000.exr\",\n \"./AfterEffects/Comp 1/prj_w_W-100 _00000.exr\",\n \"./AfterEffects/Comp 1/prj_w_W-203 _00000.exr\",\n \"./AfterEffects/Comp 1/prj_w_W-10000 _00000.exr\",\n ]\n profile_list = [\n \"Rec.2100 PQ\",\n \"Rec.2100 PQ W100\",\n \"Rec.2100 PQ W203\",\n \"Rec.2100 PQ W10000\"\n ]\n\n def get_linear(fname):\n img = read_image(fname)\n x_ae = img[0, :, 1] # extract Green line data\n ae_luminance = tf.eotf_to_luminance(x_ae, tf.ST2084)\n return ae_luminance\n\n chara_list = [get_linear(fname) for fname in fname_list]\n\n x = np.linspace(0, 1, width)\n ref_luminance = tf.eotf_to_luminance(x, tf.ST2084)\n\n fig, ax1 = pu.plot_1_graph(\n fontsize=20,\n figsize=(10, 8),\n bg_color=(0.96, 0.96, 0.96),\n graph_title=\"Transfer characteristics of the working color space\",\n graph_title_size=None,\n xlabel=\"Input Luminance [cd/m2]\",\n ylabel=\"Output LUminance [cd/m2]\",\n axis_label_size=None,\n legend_size=17,\n xlim=[0.009, 15000],\n ylim=[0.009, 15000],\n xtick=None,\n ytick=None,\n xtick_size=None, ytick_size=None,\n linewidth=3,\n minor_xtick_num=None,\n minor_ytick_num=None)\n pu.log_scale_settings(ax1=ax1)\n for idx, y in enumerate(chara_list):\n ax1.plot(ref_luminance, y, label=profile_list[idx])\n pu.show_and_save(\n fig=fig, legend_loc='upper left', save_fname=graph_name,\n show=False)","def plotblackbody(_zband, _yband, _jband, _hband, _kband, _parallax, _perr):\n # Set pyplot style to be consistent within the program\n plt.style.use('seaborn-whitegrid')\n # Import raw data to plot Hertzsprung-Russell diagram\n _hrdata = inithr('hr.dat')\n # Determine distance in parsecs\n _distance = 1 / np.tan(_parallax * 10**-3)\n _derr = (_perr * 10**-3) / ((_parallax * 10**-3)**2)\n # Create single data array with all bands\n _bands = [_zband, _yband, _jband, _hband, _kband]\n _lambda = [0.9, 1.02, 1.22, 1.63, 2.2]\n # Set up empty arrays for each star\n _largestar = np.zeros((1, 2))\n _smallstar = np.zeros((1, 2))\n\n # Determine the spectral flux density from the large star\n i = 0\n while i < 5:\n # Determine the maximum and minimum values of the observed band\n _max, _min = lightcurve.maxminvals(_bands[i])\n # The large star uses the maximum flux value (smallest magnitude)\n _largestar = np.append(_largestar, np.array([_lambda[i], (magtoflux(_min, i))], ndmin=2), axis=0)\n i += 1\n # Delete first empty row of the array\n _largestar = np.delete(_largestar, 0, axis=0)\n\n # Determine the spectral flux density from the small star\n i = 0\n while i < 5:\n # Determine the maximum and minimum values of the observed band\n _max, _min = lightcurve.maxminvals(_bands[i])\n # Smaller star flux value is combined value minus the large star\n _smallstar = np.append(_smallstar, np.array([_lambda[i], (magtoflux(_max, i) -\n magtoflux(_min, i))], ndmin=2), axis=0)\n i += 1\n # Delete the first empty row of the array\n _smallstar = np.delete(_smallstar, 0, axis=0)\n\n # Determine the luminosity and effective temperature of each star\n _luma, _lumaerr, _wiena = getwientemp(_largestar, _distance, _derr, 1)\n _lumb, _lumberr, _wienb = getwientemp(_smallstar, _distance, _derr, 2)\n\n # Calculate luminosities in solar units\n _solluma = _luma / (3.828*10**26)\n _sollumb = _lumb / (3.828*10**26)\n _lumaerr = _lumaerr / (3.828*10**26)\n _lumberr = _lumberr / (3.828*10**26)\n\n # Calculate masses using the mass/luminosity relation in solar mass units\n # N.B. only works as an approximation for main sequence stars, giants and dwarfs are not sutiable for this\n # approximation\n _solmassa = np.power(_solluma, 1/3.5)\n _solmassaerr = ((_solmassa * (1/3.5) * _lumaerr) / _solluma)**2\n _solmassb = np.power(_sollumb, 1/3.5)\n _solmassberr = ((_solmassb * (1 / 3.5) * _lumberr) / _sollumb) ** 2\n\n # Calculate stellar radius in solar radii using the relationship between luminosity, surface area and temperature\n _solrada = np.sqrt(_solluma / np.power(_wiena / 5778, 4))\n _solradb = np.sqrt(_sollumb / np.power(_wienb / 5778, 4))\n _solradaerr = ((_solrada * 0.5 * _lumaerr) / _solluma)**2\n _solradberr = ((_solradb * 0.5 * _lumberr) / _sollumb)**2\n\n # Output determined values to the screen and write to file\n print('Values for the large star:')\n print('Effective temperature: ' + str(round_sig(_wiena)))\n print('Solar luminosities: ' + str(round_sig(_solluma)) + ', error: ' + str(round_sig(_lumaerr)))\n print('Solar radii: ' + str(round_sig(_solrada)) + ', error: ' + str(round_sig(_solradaerr)))\n print('Solar masses: ' + str(round_sig(_solmassa)) + ', error: ' + str(round_sig(_solmassaerr)))\n print('-----------------------------------------------------')\n print('Values for the small star:')\n print('Effective temperature: ' + str(round_sig(_wienb)))\n print('Solar luminosities: ' + str(round_sig(_sollumb)) + ', error: ' + str(round_sig(_lumberr)))\n print('Solar radii: ' + str(round_sig(_solradb)) + ', error: ' + str(round_sig(_solradberr)))\n print('Solar masses: ' + str(round_sig(_solmassb)) + ', error: ' + str(round_sig(_solmassberr)))\n\n # Convert from luminosity to magnitude in solar units\n _luma = -2.5 * np.log10(_luma / (3.0128 * 10**28))\n _lumb = -2.5 * np.log10(_lumb / (3.0128 * 10**28))\n\n # Plot Hertzsprung-Russell diagram using provided array\n plt.scatter(_hrdata[:, 1], _hrdata[:, 0], s=0.5)\n # Plot determined values for each star\n plt.scatter(_wiena, _luma, s=16, c='red', label='Larger Star')\n plt.scatter(_wienb, _lumb, s=16, c='green', label='Smaller Star')\n # Set the x and y axis limits to sensible values\n plt.legend()\n plt.xlim(3000, 10000)\n plt.ylim(-10, 20)\n # Invert both axes as convention\n plt.gca().invert_xaxis()\n plt.gca().invert_yaxis()\n # Save figure to current folder\n plt.savefig('hr.png')\n # Display to screen\n plt.show()","def dem_jpeg(dem_file):\n out_file = dem_file+'.jpeg'\n rsc_file = out_file+'.rsc'\n shutil.copy2(dem_file+'.rsc', rsc_file)\n # read data\n dem = readfile.read(dem_file)[0]\n print('dem.shape:',dem.shape)\n # figure size\n ds_shape = tuple(reversed(dem.shape))\n fig_dpi = 300\n fig_size = [i / fig_dpi for i in ds_shape]\n print('fig_size:',fig_size)\n # color range\n disp_min = np.nanmin(dem) - 4000\n disp_max = np.nanmax(dem) + 2000\n # prepare shaded relief\n ls = LightSource(azdeg=315, altdeg=45)\n dem_shade = ls.shade(dem, vert_exag=0.3, cmap=plt.get_cmap('gray'), vmin=disp_min, vmax=disp_max)\n dem_shade[np.isnan(dem_shade[:, :, 0])] = np.nan\n print('dem_shade.shape:',dem_shade.shape)\n # plot\n fig, ax = plt.subplots(figsize=fig_size)\n ax.imshow(dem_shade, interpolation='spline16', origin='upper')\n # get rid of whitespace on the side\n ax.axis('off')\n ax.get_xaxis().set_ticks([])\n ax.get_yaxis().set_ticks([])\n fig.subplots_adjust(left=0,right=1,bottom=0,top=1)\n # output\n print('save figure to file {}'.format(out_file))\n plt.savefig(out_file, transparent=True, dpi=300, pad_inches=0.0)\n \n #resize to desired size(FA 8/19, unclear why size is wrong)\n im = Image.open(out_file)\n im_out = im.resize(dem.shape, Image.NEAREST)\n im_out.save(out_file)\n \n #plt.show()","def get_ptf10iuv(colorplt = False):\n z = 0.0251485\n ebv = 0.0371 # SFD\n D = cosmo.luminosity_distance([z])[0].value * 1e+6 # in pc\n dis_mod = 5*np.log10(D / 10)\n print (\"adopt g band t_max estimated by myself\")\n t_max = 55357.387 \n tb = pd.read_csv('../data/otherSN/Kasliwal2012/PTF10iuv', sep='\\t')\n tb = tb.drop(columns=[\"Unnamed: 4\"])\n tb = tb.rename(columns={'Filter' : 'filter',\n 'MJD': 'mjd'})\n tb = tb[~np.array([x[0]=='>' for x in tb['Mag'].values])]\n tb['mag'] = np.array([float(x.split(\" +or-\")[0]) for x in tb['Mag'].values])\n tb['emag'] = np.array([float(x.split(\" +or-\")[1]) for x in tb['Mag'].values])\n tb = tb.drop(columns=[\"Mag\"])\n \n ixg = tb['filter'].values == \"g\"\n ixr = tb['filter'].values == \"r\"\n ixi = tb['filter'].values == \"i\"\n ixz = tb['filter'].values == \"z\"\n ixB = tb['filter'].values == \"B\"\n tb['wave'] = np.zeros(len(tb))\n tb['wave'].values[ixB] = 4359\n tb['wave'].values[ixg] = 4814\n tb['wave'].values[ixr] = 6422\n tb['wave'].values[ixi] = 7883\n tb['wave'].values[ixz] = 9670\n \n tb['mag0'] = tb['mag'] - extinction.ccm89(tb['wave'].values, 3.1*ebv, 3.1)\n tb['mag0_abs'] = tb['mag0'] - dis_mod\n tb['tmax_rf'] = (tb['mjd'] - t_max) / (1+z)\n tb = tb.sort_values(by = \"mjd\")\n if colorplt==False:\n return tb\n \n else:\n tb = add_datecol(tb)\n ix = np.in1d(tb[\"filter\"].values, np.array(['g', 'r', 'i']))\n tb = tb[ix]\n tb = tb[tb.mjd > 55352.5]\n tb = tb[tb.mjd < 55593.5]\n \n dates = get_date_span(tb)\n datesave = []\n for i in range(len(dates)):\n x = dates[i]\n ix = tb[\"date\"].values == x\n tbsub = tb[ix]\n if len(tbsub)!=0:\n flts = tbsub['filter'].values\n if \"r\" in flts and np.sum(np.unique(flts))!=1:\n datesave.append(x)\n datesave = np.array(datesave)\n \n mcolor = []\n mcolor_unc = []\n mjds = []\n colorname = []\n for i in range(len(datesave)):\n x = datesave[i]\n ix = tb[\"date\"].values == x\n tbsub = tb[ix]\n gtb = tbsub[tbsub[\"filter\"].values==\"g\"]\n rtb = tbsub[tbsub[\"filter\"].values==\"r\"]\n itb = tbsub[tbsub[\"filter\"].values==\"i\"]\n if len(gtb)!=0:\n gmjds = gtb[\"mjd\"].values\n gmags = gtb[\"mag0\"].values\n gemags = gtb[\"emag\"].values\n gwtgs = 1/gemags**2\n gmag = np.sum(gmags * gwtgs) / np.sum(gwtgs)\n gmjd = np.sum(gmjds * gwtgs) / np.sum(gwtgs)\n gemag = 1/ np.sqrt(np.sum(gwtgs))\n if len(rtb)!=0:\n rmjds = rtb[\"mjd\"].values\n rmags = rtb[\"mag0\"].values\n remags = rtb[\"emag\"].values\n rwtgs = 1/remags**2\n rmag = np.sum(rmags * rwtgs) / np.sum(rwtgs)\n rmjd = np.sum(rmjds * rwtgs) / np.sum(rwtgs)\n remag = 1/ np.sqrt(np.sum(rwtgs))\n if len(itb)!=0:\n imjds = itb[\"mjd\"].values\n imags = itb[\"mag0\"].values\n iemags = itb[\"emag\"].values\n iwtgs = 1/iemags**2\n imag = np.sum(imags * iwtgs) / np.sum(iwtgs)\n imjd = np.sum(imjds * iwtgs) / np.sum(iwtgs)\n iemag = 1/ np.sqrt(np.sum(iwtgs))\n if len(gtb)!=0 and len(rtb)!=0:\n mcolor.append(gmag - rmag)\n mjds.append( 0.5 * (gmjd + rmjd) )\n mcolor_unc.append( np.sqrt(gemag**2 + remag**2) )\n colorname.append(\"gmr\")\n if len(rtb)!=0 and len(itb)!=0:\n mcolor.append(rmag - imag)\n mjds.append( 0.5 * (rmjd + imjd) )\n mcolor_unc.append( np.sqrt(remag**2 + iemag**2) )\n colorname.append(\"rmi\")\n \n ctb = Table(data = [mjds, mcolor, mcolor_unc, colorname],\n names = [\"mjd\", \"c\", \"ec\", \"cname\"])\n \n ctb['tmax_rf'] = (ctb['mjd'] - t_max) / (1+z)\n ctb = ctb.to_pandas()\n return ctb","def visualize(z_in, azimuth=25., elevation=30.,\n thresholds=[0.95, .9, .75, .5, .25, .125], opacities=[1, .9, .7, .5, .2, .1],\n# thresholds=[0.94, .89, .75, .5, .25, .1], opacities=[.9, .8, .7, .5, .2, .1],\n# thresholds=[0.94, .89, .75], opacities=[.99, .7, .2],\n# thresholds=[0.7, .5, .2], opacities=[.95, .5, .2],\n fourier_label = {'f_x':'f_x', 'f_y':'f_y', 'f_t':'f_t'},\n filename=None, do_axis=True, do_grids=False, draw_projections=True,\n colorbar=False, f_N=2., f_tN=2., figsize=figsize, dpi=300, figpath=figpath, **kwargs):\n z = z_in.copy()\n N_X, N_Y, N_frame = z.shape\n fx, fy, ft = get_grids(N_X, N_Y, N_frame)\n\n # Normalize the amplitude.\n z /= z.max()\n\n from vispy import app, scene, use\n try:\n AffineTransform = scene.transforms.AffineTransform\n except:\n AffineTransform = scene.transforms.MatrixTransform\n\n use(app='pyglet', gl='pyopengl2')\n #from vispy.util.transforms import perspective, translate, rotate\n from vispy.color import Color\n transparent = Color(color='black', alpha=0.)\n import colorsys\n canvas = scene.SceneCanvas(size=figsize, bgcolor='white', dpi=dpi)\n view = canvas.central_widget.add_view()\n\n vol_data = np.rollaxis(np.rollaxis(z, 1), 2)\n# volume = scene.visuals.Volume(vol_data, parent=view.scene)#frame)\n center = scene.transforms.STTransform(translate=( -N_X/2, -N_Y/2, -N_frame/2))\n# volume.transform = center\n# volume.cmap = 'blues'\n\n if draw_projections:\n from vispy.color import Colormap\n cm = Colormap([(1.0, 1.0, 1.0, 1.0), 'k'])\n opts = {'parent':view.scene, 'cmap':cm, 'clim':(0., 1.)}\n\n energy_xy = np.rot90(np.max(z, axis=2)[:, ::-1], 3)#[:, ::-1]\n fourier_xy = scene.visuals.Image(np.rot90(energy_xy), **opts)\n tr_xy = AffineTransform()\n tr_xy.rotate(90, (0, 0, 1))\n tr_xy.translate((N_X/2, -N_Y/2, -N_frame/2))\n fourier_xy.transform = tr_xy\n\n energy_xt = np.rot90(np.max(z, axis=1)[:, ::-1], 3)[::-1, ::-1]\n fourier_xt = scene.visuals.Image(energy_xt, **opts)\n tr_xt = AffineTransform()\n tr_xt.rotate(90, (1, 0, 0))\n tr_xt.translate((-N_X/2, N_Y/2, -N_frame/2))\n fourier_xt.transform = tr_xt\n\n energy_yt = np.max(z, axis=0)[:, ::-1]\n fourier_yt = scene.visuals.Image(energy_yt, **opts)\n tr_yt = AffineTransform()\n tr_yt.rotate(90, (0, 1, 0))\n tr_yt.translate((-N_X/2, -N_Y/2, N_frame/2))\n fourier_yt.transform = tr_yt\n\n # Generate iso-surfaces at different energy levels\n surfaces = []\n for i_, (threshold, opacity) in enumerate(zip(thresholds, opacities)):\n surfaces.append(scene.visuals.Isosurface(z, level=threshold,\n# color=Color(np.array(colorsys.hsv_to_rgb(1.*i_/len(thresholds), 1., 1.)), alpha=opacity),\n color=Color(np.array(colorsys.hsv_to_rgb(.66, 1., 1.)), alpha=opacity),\n shading='smooth', parent=view.scene)\n )\n surfaces[-1].transform = center\n\n # Draw a sphere at the origin\n axis = scene.visuals.XYZAxis(parent=view.scene)\n for p in ([1, 1, 1, -1, 1, 1], [1, 1, -1, -1, 1, -1], [1, -1, 1, -1, -1, 1],[1, -1, -1, -1, -1, -1],\n [1, 1, 1, 1, -1, 1], [-1, 1, 1, -1, -1, 1], [1, 1, -1, 1, -1, -1], [-1, 1, -1, -1, -1, -1],\n [1, 1, 1, 1, 1, -1], [-1, 1, 1, -1, 1, -1], [1, -1, 1, 1, -1, -1], [-1, -1, 1, -1, -1, -1]):\n line = scene.visuals.Line(pos=np.array([[p[0]*N_X/2, p[1]*N_Y/2, p[2]*N_frame/2], [p[3]*N_X/2, p[4]*N_Y/2, p[5]*N_frame/2]]), color='black', parent=view.scene)\n\n axisX = scene.visuals.Line(pos=np.array([[0, -N_Y/2, 0], [0, N_Y/2, 0]]), color='red', parent=view.scene)\n axisY = scene.visuals.Line(pos=np.array([[-N_X/2, 0, 0], [N_X/2, 0, 0]]), color='green', parent=view.scene)\n axisZ = scene.visuals.Line(pos=np.array([[0, 0, -N_frame/2], [0, 0, N_frame/2]]), color='blue', parent=view.scene)\n\n if do_axis:\n t = {}\n for text in ['f_x', 'f_y', 'f_t']:\n t[text] = scene.visuals.Text(fourier_label[text], parent=canvas.scene, face='Helvetica', color='black')\n t[text].font_size = 8\n t['f_x'].pos = canvas.size[0] // 3, canvas.size[1] - canvas.size[1] // 8\n t['f_y'].pos = canvas.size[0] - canvas.size[0] // 8, canvas.size[1] - canvas.size[1] // 6\n t['f_t'].pos = canvas.size[0] // 8, canvas.size[1] // 2\n\n cam = scene.TurntableCamera(elevation=elevation, azimuth=azimuth, up='z')\n cam.fov = 48\n cam.scale_factor = N_X * 1.8\n if do_axis: margin = 1.35\n else: margin = 1\n cam.set_range((-N_X/2*margin, N_X/2/margin), (-N_Y/2*margin, N_Y/2/margin), (-N_frame/2*margin, N_frame/2/margin))\n view.camera = cam\n\n render_im = canvas.render()\n app.quit()\n if not(filename is None):\n import vispy.io as io\n io.write_png(filename, render_im)\n else:\n return render_im","def plot_uwrz_field(f=False,ax=False, oro='h500a7', vm=[-2,2],tinst=18,var='QVrz',ik=0,jk=0):\n\n tinst = int(tinst)\n \n # in case f is not passed, f and ax are created\n if not f:\n f,ax=plt.subplots()\n\n # Name the axes \n decorate_ax(ax,'',daytime(tinst),'')\n \n\n # specify full path of the data\n\n iensmean = 1\n \n if iensmean:\n srcpath = BASE3D + oro + '/' + sm +'/' + CIRCMEAN\n print srcpath\n else: # 1 single ensemble member first day\n srcpath = BASE3D + oro + '/' + sm +'/'\n seedname= filter(lambda x: x.startswith('circmean_seed'), os.listdir(srcpath))[0]\n srcpath +=seedname\n\n # Open the data in netcdf format and read it only \n ncfl = Dataset(srcpath,'r')\n \n # Load the fields of interest\n # COSMO fields dimensions are (time, z,rlat,rlon)\n #\n # Field dimensions in the following are (time,z,r)\n #\n # By specifing '::-1' the second timension is inverted\n urz = ncfl.variables['Urz'][tinst,::-1,:] # U component of wind\n wrz = ncfl.variables['Wrz'][tinst,::-1,:] # W component of wind\n\n speedrz = ncfl.variables['Speedrz'][tinst,::-1,:] # wind speed\n rhorz = ncfl.variables['RHOrz'][:,::-1,:] # density in rz coordinates\n TOTP = ncfl.variables['TOT_PRECr'][:,:]/2. # half-hourly output\n \n LCLr= ncfl.variables['LCL_MLr'][tinst,:]/1000. # LCL\n LFCr = ncfl.variables['LFC_MLr'][tinst,:]/1000. # LFC\n hPBLr = ncfl.variables['HPBLr'][tinst,:]/1000. \n \n CAPEr = ncfl.variables['CAPE_MLr'][tinst,:] # CAPE\n CINr = ncfl.variables['CIN_MLr'][tinst,:] # CIN\n \n TOTPsum = np.sum(TOTP[:tinst,:],axis=0)\n TOTPsum = TOTP[tinst,:]\n \n TPthres = 0.5\n rainyr=np.where(TOTPsum>TPthres)\n\n\n if var: #select a specific humidity var\n qvrz = ncfl.variables[var][:,::-1,:] # specficif humidity\n qcrz = ncfl.variables['QCrz'][:,::-1,:]\n else: # otherwise sum it all up:\n qxrzvars = filter(lambda x: x.startswith('Q'),ncfl.variables.keys())\n \n qvrz = np.zeros(ncfl.variables['QVrz'].shape)\n for var in qxrzvars:\n print var\n qvrz+=ncfl.variables[var][:,::-1,:]\n \n tref = 12 # 06:00\n ipltdiff= 0\n if ipltdiff:\n plotvar = rhorz[tinst,:]*qvrz[tinst,:]-rhorz[tref,:]*qvrz[tref,:]\n qcrz = rhorz[tinst,:]*qcrz[tinst,:]-rhorz[tref,:]*qcrz[tref,:]\n else:\n plotvar = rhorz[tinst,:]*qvrz[tinst,:]\n \n\n rhorz = rhorz[tinst,:]\n \n \n # Load the grid in r, z coordinate\n X = ncfl.variables['X'][:]\n \n \n # nasty and temporary workaround as Z is empty in single seed data - just\n # take it from the circmean field\n srcpath2 = BASE3D + oro + '/' + sm +'/' + CIRCMEAN\n ncfl2=Dataset(srcpath2)\n Z = ncfl2.variables['Z'][::-1,:]/1000. # highest index <-> ground\n ncfl2.close() \n \n # Add mountain contour\n r=X[0,:]\n ax.plot(r,Z[0,:],color='grey',linewidth=2)\n \n# ax.plot(r,hPBLr,'k-.',linewidth=1)\n# ax.plot(r,LCLr,'k-',linewidth=1) \n \n ax.fill_between(X[0,:],Z[0,:],0,color='lightgrey')\n \n #indicate rainy region\n \n ifillrainy = False\n if ifillrainy:\n ax.fill_between(X[0,rainyr][0],Z[0,rainyr][0],color='lightblue',alpha=0.8) \n ax.plot(X[0,rainyr][0],Z[0,rainyr][0],color='lightblue',linewidth=2)\n else:\n pass#ax.plot(X[0,rainyr][0],Z[0,rainyr][0],color='blue',linewidth=2,linestyle='dashed')\n \n # Velocity vectors with speed (length) smaller than speedthres are not \n # shown\n oroorig = oro\n if oro.endswith('bell') or oro.endswith('cos2'):\n \n oro = oro[:-5]\n print oro\n \n i,j=np.where(expnames==oro)\n\n if i==[]:\n print 'HH'\n \n oro = oro.split('_')[0]\n h,a = getha(oro)\n #h,a = hrange[i],arange[j]\n print h,a\n xrang = [0,40]\n yrang = [0,10.]\n delx = xrang[1]-xrang[0]\n dely = yrang[1]-yrang[0]\n \n speedthres = 0.1# m/s\n M = speedrz[:] < speedthres\n U = ma.masked_array(urz[:,:],mask=M)\n scalefac_w = 1. #delx/dely\n W = ma.masked_array(scalefac_w*wrz[:,:],mask=M) \n \n \n \n if 0: # REMOVE\n fact_agl = -dely/delx\n sin = np.arcsin(fact_agl)\n cos = np.arccos(fact_agl)\n U=cos*U-sin*W\n W=sin*U+cos*W\n # Plot radial velocity\n urzlevs = np.linspace(vm[0],vm[1],10)\n\n\n levs = np.array([2,4,6,8,10,12,14,16])\n #levs = np.array([0.25,0.5,1,2,4,8,16,32])\n #levs = np.array([0.5,1,2,4,8,16,32])\n if ipltdiff:\n levs=levs/8. #np.linspace(0.001,0.004,11)d\n #else:\n # levs=np.array([0.001,0.0015,0.002,0.0025,0.003,0.0035,0.004])*50\n #if var.startswith('QC'): levs=np.linspace(0.1,1.5,9)/1000.\n \n #cf = ax.contourf(X,Z,plotvar*1000., levels=levs*1000.,cmap=viridis_inv,extend='both')\n \n ipltmoistening = False \n if ipltmoistening:\n cf = ax.contourf(X,Z,plotvar*1000.,cmap=viridis_inv,extend='both',\n levels=levs)\n else:\n cf = 0\n \n #cfc = ax.contourf(X,Z,qvrz*1000.,cmap='Blues',extend='both', alpha=1,\n # levels=levs/4.) \n\n iplt_thermodynvar = False\n if iplt_thermodynvar:\n for var in [LFCr]:\n print var.shape\n print X.shape\n ax.plot(var)\n \n \n qstx = 2\n qstz = 2\n Q=ax.quiver(X[::qstz,::qstx],(Z+0.02)[::qstz,::qstx],U[::qstz,::qstx],W[::qstz,::qstx],\n units='inches',scale=10,angles='xy', color='red',pivot='mid',\n headwidth=4,width=0.009)\n #Q=ax.quiverkey(Q,a/2,h/2000.,1,r'$1\\frac{m}{s}$',labelpos='N',coordinates='data')\n\n if jk==2 or oroorig.endswith('cos2'):#(ik,jk)==(1,0):\n ax.quiverkey(Q,-2,0.05,1,r'$1 \\frac{m}{s}$',labelsep=0.05,\n labelpos='N',coordinates='data')\n\n\n ax.set_xticks(np.arange(0,80,20)) \n\n ax.set_xlim(xrang)\n ax.set_ylim(yrang)\n\n if ik==2:\n ax.set_xlabel('r in km')\n if jk==0:\n ax.set_ylabel('z in km') \n \n ax.grid(True)\n\n ncfl.close()\n \n return f,ax ,cf # plot_uwrz_field","def get_iPTF16hgs(colorplt = False):\n z = 0.017\n ebv = 0\n D = cosmo.luminosity_distance([z])[0].value * 1e+6 # in pc\n dis_mod = 5*np.log10(D / 10)\n \n tb = pd.read_csv('../data/otherSN/iPTF16hgs/table1.txt', sep=\"\\t\")\n tb = tb.drop(columns=[\"Unnamed: 5\"])\n tb = tb.rename(columns={'Filter' : 'filter',\n 'MJD': 'mjd'})\n tb = tb[~np.array([x[0]=='>' for x in tb['Magnitude'].values])]\n tb['mag'] = np.array([float(x.split(\" +or-\")[0]) for x in tb['Magnitude'].values])\n tb['emag'] = np.array([float(x.split(\" +or-\")[1]) for x in tb['Magnitude'].values])\n tb = tb.drop(columns=[\"Magnitude\"])\n \n ixg = tb['filter'].values == \"g\"\n ixr = tb['filter'].values == \"r\"\n ixi = tb['filter'].values == \"i\"\n tb['wave'] = np.zeros(len(tb))\n tb['wave'].values[ixg] = 4814\n tb['wave'].values[ixr] = 6422\n tb['wave'].values[ixi] = 7883\n tb['mag0'] = tb['mag'] - extinction.ccm89(tb['wave'].values, 3.1*ebv, 3.1)\n tb['mag0_abs'] = tb['mag0'] - dis_mod\n t_max = 57691.59 # from the paper\n tb['tmax_of'] = tb['mjd'] - t_max\n tb['tmax_rf'] = (tb['mjd'] - t_max) / (1+z)\n \"\"\"\n plt.errorbar(tb[\"tmax_rf\"].values[ixg], tb[\"mag\"].values[ixg], tb[\"emag\"].values[ixg], fmt=\".g\")\n plt.errorbar(tb[\"tmax_rf\"].values[ixr], tb[\"mag\"].values[ixr], tb[\"emag\"].values[ixr], fmt=\".r\")\n plt.errorbar(tb[\"tmax_rf\"].values[ixi], tb[\"mag\"].values[ixi], tb[\"emag\"].values[ixi], fmt=\".y\")\n \"\"\"\n tb = add_datecol(tb)\n tb = add_physcol(tb)\n #tb = tb.drop(columns=[\"datetime64\"])\n if colorplt==False:\n return tb\n else:\n #tb = tb[tb.mjd > 55352.5]\n #tb = tb[tb.mjd < 55593.5]\n \n dates = get_date_span(tb)\n datesave = []\n for i in range(len(dates)):\n x = dates[i]\n ix = tb[\"date\"].values == x\n tbsub = tb[ix]\n if len(tbsub)!=0:\n flts = tbsub['filter'].values\n if \"r\" in flts and np.sum(np.unique(flts))!=1:\n datesave.append(x)\n datesave = np.array(datesave)\n \n mcolor = []\n mcolor_unc = []\n mjds = []\n colorname = []\n for i in range(len(datesave)):\n x = datesave[i]\n ix = tb[\"date\"].values == x\n tbsub = tb[ix]\n gtb = tbsub[tbsub[\"filter\"].values==\"g\"]\n rtb = tbsub[tbsub[\"filter\"].values==\"r\"]\n itb = tbsub[tbsub[\"filter\"].values==\"i\"]\n if len(gtb)!=0:\n gmjds = gtb[\"mjd\"].values\n gmags = gtb[\"mag0\"].values\n gemags = gtb[\"emag\"].values\n gwtgs = 1/gemags**2\n gmag = np.sum(gmags * gwtgs) / np.sum(gwtgs)\n gmjd = np.sum(gmjds * gwtgs) / np.sum(gwtgs)\n gemag = 1/ np.sqrt(np.sum(gwtgs))\n if len(rtb)!=0:\n rmjds = rtb[\"mjd\"].values\n rmags = rtb[\"mag0\"].values\n remags = rtb[\"emag\"].values\n rwtgs = 1/remags**2\n rmag = np.sum(rmags * rwtgs) / np.sum(rwtgs)\n rmjd = np.sum(rmjds * rwtgs) / np.sum(rwtgs)\n remag = 1/ np.sqrt(np.sum(rwtgs))\n if len(itb)!=0:\n imjds = itb[\"mjd\"].values\n imags = itb[\"mag0\"].values\n iemags = itb[\"emag\"].values\n iwtgs = 1/iemags**2\n imag = np.sum(imags * iwtgs) / np.sum(iwtgs)\n imjd = np.sum(imjds * iwtgs) / np.sum(iwtgs)\n iemag = 1/ np.sqrt(np.sum(iwtgs))\n if len(gtb)!=0 and len(rtb)!=0:\n mcolor.append(gmag - rmag)\n mjds.append( 0.5 * (gmjd + rmjd) )\n mcolor_unc.append( np.sqrt(gemag**2 + remag**2) )\n colorname.append(\"gmr\")\n if len(rtb)!=0 and len(itb)!=0:\n mcolor.append(rmag - imag)\n mjds.append( 0.5 * (rmjd + imjd) )\n mcolor_unc.append( np.sqrt(remag**2 + iemag**2) )\n colorname.append(\"rmi\")\n \n ctb = Table(data = [mjds, mcolor, mcolor_unc, colorname],\n names = [\"mjd\", \"c\", \"ec\", \"cname\"])\n \n ctb['tmax_rf'] = (ctb['mjd'] - t_max) / (1+z)\n ctb = ctb.to_pandas()\n return ctb","def flatNoiseCGH():\n #Get data\n wdir = '/home/rallured/Dropbox/AXRO/Metrology/NoiseStudy/FlatMeasurements/'\n d1,dx1 = met.read4DFits(wdir+'161205_RefFlat_Avg8_Meas1.fits')\n d2,dx2 = met.read4DFits(wdir+'161205_RefFlat_Avg8_Meas2.fits')\n p1,px1 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestPitch_Meas1.fits')\n p2,px2 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestPitch_Meas2.fits')\n p3,px3 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestRoll_Meas1.fits')\n p4,px4 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestRoll_Meas2.fits')\n\n #Construct baseline power spectra\n f1,pow1 = fourier.meanPSD(d1-d2,win=np.hanning,dx=dx1)\n f2,pow2 = fourier.meanPSD(d1-d2,win=np.hanning,dx=dx1,axis=1)\n \n #Construct parroted power spectra\n f3,pow3 = fourier.meanPSD(p1-p2,win=np.hanning,dx=dx1)\n f4,pow4 = fourier.meanPSD(p1-p2,win=np.hanning,dx=dx2,axis=1)\n f5,pow5 = fourier.meanPSD(p3-p4,win=np.hanning,dx=dx1)\n f6,pow6 = fourier.meanPSD(p3-p4,win=np.hanning,dx=dx2,axis=1)\n\n #Plot\n plt.loglog(f1,pow1/f1[0],label='Axial Baseline')\n plt.loglog(f2,pow2/f2[0],label='Azimuthal Baseline')\n plt.loglog(f3,pow3/f3[0],label='Pitch Axial')\n plt.loglog(f4,pow4/f4[0],label='Pitch Azimuthal')\n plt.loglog(f5,pow5/f5[0],label='Roll Axial')\n plt.loglog(f6,pow6/f6[0],label='Roll Azimuthal')\n plt.title('Residual Fringe Repeatability Impact')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n plt.legend(loc='lower left')\n\n return f1,pow1","def plotTI():\n min_dl = dlam[dlam != 0].min()\n S = int(0.4/min_dl)\n fig = pl.figure(figsize = (8,6))\n ax = fig.add_subplot(1,1,1)\n ax.spines['bottom'].set_position('zero')\n ax.spines['top'].set_color('none')\n ax.spines['right'].set_color('none')\n ax.xaxis.set_ticks_position('bottom')\n ax.yaxis.set_ticks_position('left')\n\n for k, spine in ax.spines.items():\n spine.set_zorder(12.2)\n\n xs, ndx, dx = [0], 0, 0.001\n colors = ['r', 'g', '#7F38EC', '#9F000F', 'b', 'y']\n min_y, max_y = 0, 0\n\n lines = tuple()\n ## lv_names2 = [r'$Coulomb$', r'$vdWaals$'] ## for the paper\n lv_names2 = []\n for j in range(n_components):\n y = ave_dhdl[:,j]\n if not (y == 0).all():\n lv_names2.append(r'$%s$' % P.lv_names[j].capitalize())\n\n for j in range(n_components):\n\n y = ave_dhdl[:,j]\n if not (y == 0).all():\n\n # Get the coordinates.\n lj = lchange[:,j]\n x = lv[:,j][lj]\n y = y[lj]/P.beta_report\n\n if 'TI' in P.methods:\n # Plot the TI integration area.\n ss = 'TI'\n for i in range(len(x)-1):\n min_y = min(y.min(), min_y)\n max_y = max(y.max(), max_y)\n #pl.plot(x,y)\n if i%2==0:\n pl.fill_between(x[i:i+2]+ndx, 0, y[i:i+2], color=colors[ndx], alpha=1.0)\n else:\n pl.fill_between(x[i:i+2]+ndx, 0, y[i:i+2], color=colors[ndx], alpha=0.5)\n xlegend = [-100*wnum for wnum in range(len(lv_names2))]\n pl.plot(xlegend, [0*wnum for wnum in xlegend], ls='-', color=colors[ndx], label=lv_names2[ndx]) ## for the paper\n\n if 'TI-CUBIC' in P.methods and not cubspl[j]==0:\n # Plot the TI-CUBIC interpolation curve.\n ss += ' and TI-CUBIC'\n xnew = numpy.arange(0, 1+dx, dx)\n ynew = cubspl[j].interpolate(y, xnew)\n min_y = min(ynew.min(), min_y)\n max_y = max(ynew.max(), max_y)\n pl.plot(xnew+ndx, ynew, color='#B6B6B4', ls ='-', solid_capstyle='round', lw=3.0)\n\n else:\n # Plot the TI-CUBIC integration area.\n ss = 'TI-CUBIC'\n for i in range(len(x)-1):\n xnew = numpy.arange(x[i], x[i+1]+dx, dx)\n ynew = cubspl[j].interpolate(y, xnew)\n ynew[0], ynew[-1] = y[i], y[i+1]\n min_y = min(ynew.min(), min_y)\n max_y = max(ynew.max(), max_y)\n if i%2==0:\n pl.fill_between(xnew+ndx, 0, ynew, color=colors[ndx], alpha=1.0)\n else:\n pl.fill_between(xnew+ndx, 0, ynew, color=colors[ndx], alpha=0.5)\n\n # Store the abscissa values and update the subplot index.\n xs += (x+ndx).tolist()[1:]\n ndx += 1\n\n # Make sure the tick labels are not overcrowded.\n xs = numpy.array(xs)\n dl_mat = numpy.array([xs-i for i in xs])\n ri = range(len(xs))\n\n def getInd(r=ri, z=[0]):\n primo = r[0]\n min_dl=ndx*0.02*2**(primo>10)\n if dl_mat[primo].max()<min_dl:\n return z\n for i in r:\n for j in range(len(xs)):\n if dl_mat[i,j]>min_dl:\n z.append(j)\n return getInd(ri[j:], z)\n\n xt = [i if (i in getInd()) else '' for i in range(K)]\n pl.xticks(xs[1:], xt[1:], fontsize=10)\n pl.yticks(fontsize=10)\n #ax = pl.gca()\n #for label in ax.get_xticklabels():\n # label.set_bbox(dict(fc='w', ec='None', alpha=0.5))\n\n # Remove the abscissa ticks and set up the axes limits.\n for tick in ax.get_xticklines():\n tick.set_visible(False)\n pl.xlim(0, ndx)\n min_y *= 1.01\n max_y *= 1.01\n pl.ylim(min_y, max_y)\n\n for i,j in zip(xs[1:], xt[1:]):\n pl.annotate(('%.2f' % (i-1.0 if i>1.0 else i) if not j=='' else ''), xy=(i, 0), xytext=(i, 0.01), size=10, rotation=90, textcoords=('data', 'axes fraction'), va='bottom', ha='center', color='#151B54')\n if ndx>1:\n lenticks = len(ax.get_ymajorticklabels()) - 1\n if min_y<0: lenticks -= 1\n if lenticks < 5:\n from matplotlib.ticker import AutoMinorLocator as AML\n ax.yaxis.set_minor_locator(AML())\n pl.grid(which='both', color='w', lw=0.25, axis='y', zorder=12)\n pl.ylabel(r'$\\mathrm{\\langle{\\frac{ \\partial U } { \\partial \\lambda }}\\rangle_{\\lambda}\\/%s}$' % P.units, fontsize=20, color='#151B54')\n pl.annotate('$\\mathit{\\lambda}$', xy=(0, 0), xytext=(0.5, -0.05), size=18, textcoords='axes fraction', va='top', ha='center', color='#151B54')\n if not P.software.title()=='Sire':\n lege = ax.legend(prop=FP(size=14), frameon=False, loc=1)\n for l in lege.legendHandles:\n l.set_linewidth(10)\n pl.savefig(os.path.join(P.output_directory, 'dhdl_TI.pdf'))\n pl.close(fig)\n return","def plot_raft_map(data, img, TITLE, OUTDIR, vmin=None, vmax=None):\n\n map = np.zeros((6, 24))\n for i, fli in enumerate(img):\n x = (fli.dev_index / 3) * 2 # [0, 2, 4]\n y = (fli.dev_index % 3) * 8 # [0, 8, 16]\n for j in range(16):\n xx = x + j / 8 # [0, 1,..., 5]\n yy = y + j % 8 # [0, 1,..., 23]\n map[xx, yy] = data[i, j]\n\n yseg = range(6)\n ylab = [\"00-07\", \"10-17\", \"00-07\", \"10-17\", \"00-07\", \"10-17\"]\n xseg = range(0, 24, 4)\n xlab = [\"0\", \"4\", \"0\", \"4\", \"0\", \"4\"]\n\n fig = plt.figure(figsize=(10, 10))\n ax1 = fig.add_subplot(111)\n im = ax1.imshow(map, interpolation='nearest', cmap='jet', aspect=4, vmin=vmin, vmax=vmax)\n plt.yticks(yseg, ylab)\n plt.xticks(xseg, xlab)\n plt.annotate('S22', xy=(0, 0), xytext=(4, -0.8), fontsize=15, ha='center', va='center')\n plt.annotate('S12', xy=(0, 0), xytext=(12, -0.8), fontsize=15, ha='center', va='center')\n plt.annotate('S02', xy=(0, 0), xytext=(20, -0.8), fontsize=15, ha='center', va='center')\n plt.annotate('S02', xy=(0, 0), xytext=(24., 0.5), fontsize=15, ha='left', va='center')\n plt.annotate('S01', xy=(0, 0), xytext=(24., 2.5), fontsize=15, ha='left', va='center')\n plt.annotate('S00', xy=(0, 0), xytext=(24., 4.5), fontsize=15, ha='left', va='center')\n ax1.vlines(7.5, -0.5, 5.5)\n ax1.vlines(15.5, -0.5, 5.5)\n ax1.hlines(1.5, -0.5, 23.5)\n ax1.hlines(3.5, -0.5, 23.5)\n plt.subplots_adjust(left=0.07, bottom=0.05, right=0.8, top=0.95, wspace=0, hspace=0)\n #cbar_ax = fig.add_axes([0.15, 0.03, 0.7, 0.05])\n #fig.colorbar(im, cax=cbar_ax, orientation=\"horizontal\")\n cbar_ax = fig.add_axes([0.87, 0.15, 0.05, 0.7])\n fig.colorbar(im, cax=cbar_ax)\n fig.suptitle(TITLE, y=0.98, size=19)\n plt.savefig(OUTDIR + TITLE + '.png')\n plt.show()\n plt.close(fig)","def one_transition_spectrum_abs(self,tr):\n \n\n ta = tr[\"ta\"] # TimeAxis\n dd = tr[\"dd\"] # transition dipole strength\n om = tr[\"om\"] # frequency - rwa\n gg = tr[\"gg\"] # natural broadening (constant or time dependent)\n fwhm = tr[\"fwhm\"] # Additional gaussian broadening of the spectra\n sgm = fwhm/(2*numpy.sqrt(2*numpy.log(2)))\n \n # CD and fluorescence can be calculated in this step\n # TODO if rotatory strength defined calculate also circular dichroism spectra\n # TOOD calculate fluorescence spectra (for fluorescence there should be a switch because it should be calculated only for the first transition) \n \n \n if self.system._has_system_bath_coupling:\n# ct = tr[\"ct\"] # correlation function\n \n # convert correlation function to lineshape function\n #gt = self._c2g(ta,ct.data)\n gt = tr[\"gt\"]\n # calculate time dependent response\n at = numpy.exp(-gt -1j*om*ta.data)\n else:\n # calculate time dependent response\n at = numpy.exp(-1j*om*ta.data) \n# plt.figure()\n# plt.title(\"Absorption\")\n# plt.plot(ta.data,numpy.real(at))\n# plt.plot(ta.data,numpy.imag(at))\n \n \n if len(gg) == 1:\n gam = gg[0]\n rt = numpy.exp(gam*ta.data)\n at *= rt\n #print(\"Constant: \", rt[20], len(at))\n else:\n rt = numpy.exp((gg)*ta.data) \n at *= rt\n #print(\"Time dependent: len = \", rt[20], len(rt))\n \n if fwhm!=0.0:\n gauss = numpy.exp(-2*(numpy.pi**2)*(sgm**2)*(ta.data**2))\n at *= gauss\n \n # Fourier transform the result\n ft = dd*numpy.fft.hfft(at)*ta.step\n ft = numpy.fft.fftshift(ft)\n # invert the order because hfft is a transform with -i\n ft = numpy.flipud(ft) \n # cut the center of the spectrum\n Nt = ta.length #len(ta.data) \n return ft[Nt//2:Nt+Nt//2]","def main():\n\t#--------------------------------------------------------------------------#\n\t#\t\t\t\t\t\t Generate Polar Coordinates\t\t\t\t \t #\n\t#--------------------------------------------------------------------------#\n\t#Mask - read in the fisheye mask center coordinates and radius\n\tmask = fits.open(p.mask,uint=False)[0].header\n\txc, yc, r0 = int(mask['CENTERX']), int(mask['CENTERY']), int(mask['RADIUS'])\n\tX, Y = n.meshgrid(n.arange(-r0,r0),n.arange(-r0,r0))\n\t\n\t#Polar coordinates\n\tr = n.sqrt(X**2+Y**2) / r0\n\ttheta = -n.arctan2(Y,X)\n\t\n\t#Fisheye takes r in degree\n\tr_deg = 90 * r\n\ttheta_f = theta + n.pi/2\n\t\n\t#Hammer plot requires the values to be sorted\n\tr_str = n.pi/2 - r * n.pi/2\n\tinds = n.argsort(theta[:,0])\n\ttheta_s = theta[inds,:] \n\tr_s = r_str[inds,:]\n\t\n\t\n\t#--------------------------------------------------------------------------#\n\t#\t\t\t\t\t\t Define Plot settings\t\t\t\t\t\t \t #\n\t#--------------------------------------------------------------------------#\n\t#General plot settings\n\tplt.close('all')\n\tplt.style.use('dark_background')\n\tplt.rcParams['image.cmap'] = 'NPS_mag'\n\tcmap = copy.copy(mpl.cm.get_cmap(\"NPS_mag\"))\n\tcmap.set_bad(color='black')\n\t\n\t#Fisheye plot setting\n\tfig0 = plt.figure('fisheye') \n\tax0 = fig0.add_subplot(111, projection='polar')\n\tax0.set_rlim(0,90)\n\tax0.set_yticklabels([])\n\tax0.tick_params(colors='darkgray')\n\tax0.set_theta_zero_location('N') \n\t\n\t#Hammer plot setting\n\tfig1 = plt.figure('hammer',figsize=(15,5.2))\n\tax1 = fig1.add_subplot(111, projection=\"upper_hammer\")\n\tfig1.tight_layout(rect=(0.03,-0.6,0.98,0.97))\n\t\n\t#Suppressing a MatPlotLib benign warning about pcolormesh shading\n\twarnings.filterwarnings(\"ignore\",category=UserWarning)\n\n\t#--------------------------------------------------------------------------#\n\t#\t\t\t\tPlot the image in fisheye and Hammer projections\t\t #\n\t#--------------------------------------------------------------------------#\n\tfor f in glob(p.data_cal+'*sky*.fit'):\n\t\tprint('projecting ' + f[len(p.data_cal):])\n\t\timg = fits.open(f,uint=False)[0].data[yc-r0:yc+r0,xc-r0:xc+r0]\n\t\timg_hammer = rotate(img.astype('float32'),-90,cval=n.nan)[inds,:]\n\t\t\n\t\t#plot fisheye\n\t\tax0.pcolormesh(theta_f,r_deg,img,shading='auto',vmin=14,vmax=24)\n\t\tax0.grid(True, color='gray', linestyle='dotted', linewidth=.5)\n\t\tfig0.savefig(f[:-4]+'_fisheye.png', dpi=250)\n\t\t\n\t\t#plot hammer\n\t\tax1.pcolormesh(theta_s,r_s,img_hammer,shading='auto',vmin=14,vmax=24)\n\t\tax1.grid(True)\n\t\tfig1.savefig(f[:-4]+'_hammer.png')","def P_AI_Rocky2(in_dict):\n # START\n fs = 16\n plt.rc('font', size=fs)\n fig = plt.figure(figsize=(8,12))\n ds = nc.Dataset(in_dict['fn'])\n\n # PLOT CODE\n aa = [-122.8, -122.54, 47.92, 48.22]\n # import cmocean\n # cmap = cmocean.cm.speed\n # cmap = 'RdYlBu_r'\n cmap = 'Spectral_r'\n\n from warnings import filterwarnings\n filterwarnings('ignore') # skip some warning messages\n \n # plot Code\n \n # calculate speed\n uu = ds['u'][0, -1, :, :]\n vv = ds['v'][0, -1, :, :]\n u = zfun.fillit(uu)\n v = zfun.fillit(vv)\n u[np.isnan(u)] = 0\n v[np.isnan(v)] = 0\n # interpolate to the clipped rho grid\n ur = (u[1:-1,1:] + u[1:-1,:-1])/2\n vr = (v[1:,1:-1] + v[:-1,1:-1])/2\n spd = np.sqrt(ur**2 + vr**2)\n spd[spd==0] = np.nan\n \n G = zrfun.get_basic_info(in_dict['fn'], only_G=True)\n \n # panel 1\n ax = fig.add_subplot(111)\n cs = plt.pcolormesh(G['lon_psi'], G['lat_psi'], spd, cmap=cmap,\n vmin=0, vmax=1.5)\n tstr = (r'Admiralty Inlet Surface Speed ($m\\ s^{-1}$)')\n #pfun.add_bathy_contours(ax, ds, txt=True)\n pfun.add_coast(ax)\n ax.axis(aa)\n pfun.dar(ax)\n ax.set_xlabel('Longitude')\n ax.set_ylabel('Latitude')\n ax.set_title(tstr)\n pfun.add_info(ax, in_dict['fn'])\n ax.set_xticks([-122.8, -122.7, -122.6])\n ax.set_yticks([48, 48.1, 48.2])\n \n # Inset colorbar\n from mpl_toolkits.axes_grid1.inset_locator import inset_axes\n cbaxes = inset_axes(ax, width=\"4%\", height=\"30%\", loc='upper right', borderpad=3)\n fig.colorbar(cs, cax=cbaxes, orientation='vertical')\n \n #pfun.add_bathy_contours(ax, ds)\n pfun.add_coast(ax)\n ax.axis(aa)\n pfun.dar(ax)\n ax.set_xlabel('Longitude')\n ax.set_title(tstr)\n \n pfun.add_velocity_vectors(ax, ds, in_dict['fn'], v_scl=100, v_leglen=1,\n nngrid=80, zlev='top', center=(.1,.05))\n \n fig.tight_layout()\n # FINISH\n ds.close()\n if len(in_dict['fn_out']) > 0:\n plt.savefig(in_dict['fn_out'])\n plt.close()\n else:\n plt.show()\n plt.rcdefaults()","def get_sn2005ek(colorplt=False):\n z = 0.016551\n ebv = 0.210\n D = cosmo.luminosity_distance([z])[0].value * 1e+6 # in pc\n dis_mod = 5*np.log10(D / 10)\n t_max = 53639.9\n print (\"adopt r band t_max from Drout+13\")\n \n # tb = pd.read_csv('/Users/yuhanyao/Desktop/ZTF18abfcmjw/data/Drout2013/table1', sep='\\t')\n # tb = tb.drop(columns=[\"Unnamed: 6\"])\n \n mjds = np.array([53639.3, 53640.3, 53641.3, 53642.2, 53643.2, 53645.3,\n 53646.5, 53648.0, 53649.2, 53650.4, 53651.3, 53652.5,\n 53654.2, 53655.2, 53656.2, 53657.2])\n \n Bmags = np.array([18.25, 18.38, 18.65, np.nan, 19.10, 19.71,\n 20.07, np.nan, 20.67, 20.90, 21.05, np.nan,\n 21.74, np.nan, np.nan, np.nan])\n \n Bmag_uncs = np.array([0.02, 0.03, 0.02, np.nan, 0.05, 0.07, \n 0.07, np.nan, 0.04, 0.04, 0.04, np.nan,\n 0.12, np.nan, np.nan, np.nan])\n \n Vmags = np.array([17.83, 18.03, 17.92, np.nan, 18.24, 18.66,\n 18.93, 19.48, 19.63, 19.86, 19.98, 20.35,\n 20.60, 20.74, 20.88, 21.22])\n \n Vmag_uncs = np.array([0.02, 0.03, 0.01, np.nan, 0.02, 0.02,\n 0.02, 0.06, 0.03, 0.03, 0.04, 0.05, \n 0.08, 0.10, 0.08, 0.13])\n \n Rmags = np.array([17.46, 17.41, 17.60, 17.69, 17.86, 18.18, \n np.nan, 18.83, 19.03, 19.26, 19.48, 19.75,\n 20.08, np.nan, 20.47, np.nan])\n \n Rmag_uncs = np.array([0.01, 0.02, 0.01, 0.02, 0.01, 0.01,\n np.nan, 0.03, 0.02, 0.02, 0.02, 0.04,\n 0.05, np.nan, 0.08, np.nan])\n\n Imags = np.array([17.20, 17.13, 17.18, np.nan, 17.47, 17.71, \n np.nan, 18.13, 18.26, 18.51, 18.61, 18.74, \n 19.01, np.nan, 19.47, np.nan])\n \n Imag_uncs = np.array([0.02, 0.04, 0.02, np.nan, 0.03, 0.02,\n np.nan, 0.06, 0.02, 0.02, 0.02, 0.03,\n 0.05, np.nan, 0.06, np.nan])\n \n mymjds = np.hstack([mjds, mjds, mjds, mjds])\n mymags = np.hstack([Bmags, Vmags, Rmags, Imags])\n myemags = np.hstack([Bmag_uncs, Vmag_uncs, Rmag_uncs, Imag_uncs])\n myfilts = np.hstack([ np.repeat(\"B\", len(Bmags)),\n np.repeat(\"V\", len(Bmags)),\n np.repeat(\"R\", len(Rmags)),\n np.repeat(\"I\", len(Imags)) ])\n ix = ~np.isnan(mymags)\n tb = pd.DataFrame({'mjd': mymjds[ix],\n 'mag': mymags[ix],\n 'emag': myemags[ix],\n \"filter\": myfilts[ix]})\n \n ixB = tb['filter'].values==\"B\"\n ixV = tb['filter'].values==\"V\"\n ixR = tb['filter'].values==\"R\"\n ixI = tb['filter'].values==\"I\"\n \n tb['wave'] = np.zeros(len(tb))\n tb['wave'].values[ixB] = 4359\n tb['wave'].values[ixV] = 5430\n tb['wave'].values[ixR] = 6349\n tb['wave'].values[ixI] = 8797\n \n tb['mag0'] = tb['mag'] - extinction.ccm89(tb['wave'].values, 3.1*ebv, 3.1)\n tb['mag0_abs'] = tb['mag0'] - dis_mod\n tb['tmax_rf'] = (tb['mjd'] - t_max) / (1+z)\n if colorplt==False:\n return tb\n else:\n tb = add_datecol(tb)\n ix = np.in1d(tb[\"filter\"].values, np.array(['B', 'R', 'I']))\n tb = tb[ix]\n\n dates = get_date_span(tb)\n datesave = []\n for i in range(len(dates)):\n x = dates[i]\n ix = tb[\"date\"].values == x\n tbsub = tb[ix]\n if len(tbsub)!=0:\n flts = tbsub['filter'].values\n if \"R\" in flts and np.sum(np.unique(flts))!=1:\n datesave.append(x)\n datesave = np.array(datesave)\n \n mcolor = []\n mcolor_unc = []\n mjds = []\n colorname = []\n for i in range(len(datesave)):\n x = datesave[i]\n ix = tb[\"date\"].values == x\n tbsub = tb[ix]\n gtb = tbsub[tbsub[\"filter\"].values==\"B\"]\n rtb = tbsub[tbsub[\"filter\"].values==\"R\"]\n itb = tbsub[tbsub[\"filter\"].values==\"I\"]\n if len(gtb)!=0:\n gmjds = gtb[\"mjd\"].values\n gmags = gtb[\"mag0\"].values\n gemags = gtb[\"emag\"].values\n gwtgs = 1/gemags**2\n gmag = np.sum(gmags * gwtgs) / np.sum(gwtgs)\n gmjd = np.sum(gmjds * gwtgs) / np.sum(gwtgs)\n gemag = 1/ np.sqrt(np.sum(gwtgs))\n if len(rtb)!=0:\n rmjds = rtb[\"mjd\"].values\n rmags = rtb[\"mag0\"].values\n remags = rtb[\"emag\"].values\n rwtgs = 1/remags**2\n rmag = np.sum(rmags * rwtgs) / np.sum(rwtgs)\n rmjd = np.sum(rmjds * rwtgs) / np.sum(rwtgs)\n remag = 1/ np.sqrt(np.sum(rwtgs))\n if len(itb)!=0:\n imjds = itb[\"mjd\"].values\n imags = itb[\"mag0\"].values\n iemags = itb[\"emag\"].values\n iwtgs = 1/iemags**2\n imag = np.sum(imags * iwtgs) / np.sum(iwtgs)\n imjd = np.sum(imjds * iwtgs) / np.sum(iwtgs)\n iemag = 1/ np.sqrt(np.sum(iwtgs))\n if len(gtb)!=0 and len(rtb)!=0:\n mcolor.append(gmag - rmag)\n mjds.append( 0.5 * (gmjd + rmjd) )\n mcolor_unc.append( np.sqrt(gemag**2 + remag**2) )\n colorname.append(\"BmR\")\n if len(rtb)!=0 and len(itb)!=0:\n mcolor.append(rmag - imag)\n mjds.append( 0.5 * (rmjd + imjd) )\n mcolor_unc.append( np.sqrt(remag**2 + iemag**2) )\n colorname.append(\"RmI\")\n \n ctb = Table(data = [mjds, mcolor, mcolor_unc, colorname],\n names = [\"mjd\", \"c\", \"ec\", \"cname\"])\n \n ctb['tmax_rf'] = (ctb['mjd'] - t_max) / (1+z)\n ctb = ctb.to_pandas()\n return ctb","def hexapodZernikeLinearModel_hexapodcoordinate():\n Tfile='/home/jghao/research/decamFocus/psf_withseeing/finerGrid_coeff_matrix/zernike_coeff_finerGrid_training.cp'\n b=p.load(open(Tfile))\n nobs = len(b)\n x = b[:,0]\n y = b[:,1]\n z = b[:,2]\n theta = b[:,3]\n phi = b[:,4]\n fwhm = b[:,5]\n e1 = b[:,6]\n e2 = b[:,7]\n thetax = theta*np.cos(np.deg2rad(phi))\n thetay = theta*np.sin(np.deg2rad(phi))\n xh = x*1000 # convert to hexapod coordinate\n yh = -y*1000\n zh = -z*1000\n xtilth = - thetay\n ytilth = - thetax\n\n M22realTrefoil2 = b[:,37] # for x decenter\n M22imagTrefoil1 = b[:,54] \n M22TrefoilXshift = 0.5*(M22realTrefoil2+M22imagTrefoil1)\n\n M22realTrefoil1 = b[:,34] # for y decenter\n M22imagTrefoil2 = b[:,57] \n M22TrefoilYshift = 0.5*(M22realTrefoil1 - M22imagTrefoil2)\n\n M20defocus = b[:,12] # for defocus\n\n M22realComa2 = b[:,36] # for x-tilt\n M22imagComa1 = b[:,55]\n M22ComaXtilt = 0.5*(M22realComa2+M22imagComa1)\n\n M22realComa1 = b[:,35] # for y-tilt\n M22imagComa2 = b[:,56]\n M22ComaYtilt = 0.5*(M22realComa1 - M22imagComa2)\n \n pl.figure(figsize=(21,12))\n pl.subplot(2,3,1)\n t=bp.bin_scatter(M22TrefoilXshift,xh,nbins=20,fmt='bo',scatter=True)\n res = linefit(M22TrefoilXshift,xh)\n pl.plot(M22TrefoilXshift,M22TrefoilXshift*res[1]+res[0],'r,')\n pl.ylabel('x-decenter [micron]')\n pl.xlabel('(M22realTrefoil2+M22imagTrefoil1)/2')\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\n pl.grid()\n pl.subplot(2,3,2)\n t=bp.bin_scatter(M22TrefoilYshift,yh,nbins=20,fmt='bo',scatter=True)\n res = linefit(M22TrefoilYshift,yh)\n pl.plot(M22TrefoilYshift,M22TrefoilYshift*res[1]+res[0],'r,')\n pl.ylabel('y-decenter [micron]')\n pl.xlabel('(M22realTrefoil1 - M22imagTrefoil2)/2')\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\n pl.grid()\n pl.subplot(2,3,3)\n t=bp.bin_scatter(M20defocus,zh,nbins=20,fmt='bo',scatter=True)\n res = linefit(M20defocus,zh)\n pl.plot(M20defocus,M20defocus*res[1]+res[0],'r,')\n pl.ylabel('z-defocus [micron]')\n pl.xlabel('M20defocus')\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\n pl.grid()\n pl.subplot(2,3,4)\n t=bp.bin_scatter(M22ComaXtilt,ytilth,nbins=20,fmt='bo',scatter=True)\n res = linefit(M22ComaXtilt,ytilth)\n pl.plot(M22ComaXtilt,M22ComaXtilt*res[1]+res[0],'r,')\n pl.ylabel('y-tilt [arcsec]') # in hexapod coordiate, xtilt and y tilt is switched from the CRAY coordiante\n pl.xlabel('(M22realComa2+M22imagComa1)/2')\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\n pl.grid()\n pl.subplot(2,3,5)\n t=bp.bin_scatter(M22ComaYtilt,xtilth,nbins=20,fmt='bo',scatter=True)\n res = linefit(M22ComaYtilt,xtilth)\n pl.plot(M22ComaYtilt,M22ComaYtilt*res[1]+res[0],'r,')\n pl.ylabel('x-tilt [arcsec]')\n pl.xlabel('(M22realComa1 - M22imagComa2)/2')\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\n pl.grid()\n pl.savefig('linearModel_hexapod_coordinate.png')\n pl.close()","def test_plot_color(self):\n lname = os.path.join(self.datadir,\n 'monol_testA_nustar_fpma_E_10-5_over_5-3') + \\\n HEN_FILE_EXTENSION\n cname = os.path.join(self.datadir,\n 'monol_testA_nustar_fpma_E_10-5_over_5-3') + \\\n HEN_FILE_EXTENSION\n hen.plot.main([cname, lname, '--noplot', '--xlog', '--ylog', '--CCD',\n '-o', 'dummy.qdp'])","def show(im,fig= None): #X\n im = im.copy()\n if len(im.shape)==1 or im.shape[1]==1:\n im = X2patch(im)\n im[im<=DEAD]=-0.5\n if fig is None:\n plt.figure()\n fig = plt.imshow(hsv_to_rgb(im+0.5))\n fig.set_data(hsv_to_rgb(im+0.5))\n plt.draw()\n plt.pause(0.001)\n return fig","def fiducial_evolution():\n \n # fiducial model\n wangle = 180*u.deg\n pk = pickle.load(open('../data/gd1_fiducial.pkl', 'rb'))\n x = pk['x'].to(u.kpc)\n xorig = x[:2]\n \n plt.close()\n fig, ax = plt.subplots(1,1,figsize=(6,6))\n \n plt.sca(ax)\n \n Nsnap = 8\n times = np.linspace(0,0.5,Nsnap)[::-1]\n angles = np.linspace(0,322,Nsnap)[::-1]*u.deg\n\n for e, t in enumerate(times):\n c = mpl.cm.Blues(0.05+0.85*(Nsnap-e)/Nsnap)\n #a = 0.5 + 0.5*(Nsnap-e)/Nsnap\n \n pk = pickle.load(open('../data/gd1_fiducial_t{:.4f}.pkl'.format(t), 'rb'))\n x = pk['x'].to(u.kpc)\n x_, y_ = x[0], x[1]\n \n plt.plot(x_[120:-120], y_[120:-120], '.', color=c, ms=10, zorder=Nsnap-e, rasterized=False)\n \n xt = 24*np.cos(angles[e]+90*u.deg)\n yt = 24*np.sin(angles[e]+90*u.deg)\n if e<Nsnap-1:\n txt = plt.text(xt, yt, '+ {:.2f} Gyr'.format(t), va='center', ha='center', fontsize='small', color='0.2', rotation=(angles[e]).value, zorder=10)\n txt.set_bbox(dict(facecolor='w', alpha=0.7, ec='none'))\n \n plt.text(0, 24, 'Flyby', va='center', ha='center', fontsize='small', color='0.2')\n\n lim = 27\n plt.xlim(-lim,lim)\n plt.ylim(-lim,lim)\n plt.gca().set_aspect('equal')\n \n plt.xlabel('x [kpc]')\n plt.ylabel('y [kpc]')\n \n plt.tight_layout()\n plt.savefig('../plots/loop_evolution.pdf')","def one_transition_spectrum_fluor(self,tr):\n \n\n ta = tr[\"ta\"] # TimeAxis\n dd = tr[\"dd\"] # transition dipole strength\n om = tr[\"om\"] # frequency - rwa\n gg = tr[\"gg\"] # natural broadening (constant or time dependent)\n fwhm = tr[\"fwhm\"] # Additional gaussian broadening of the spectra\n sgm = fwhm/(2*numpy.sqrt(2*numpy.log(2)))\n \n # CD and fluorescence can be calculated in this step\n # TODO if rotatory strength defined calculate also circular dichroism spectra\n # TOOD calculate fluorescence spectra (for fluorescence there should be a switch because it should be calculated only for the first transition) \n \n \n if self.system._has_system_bath_coupling:\n# ct = tr[\"ct\"] # correlation function\n re = tr[\"re\"] # reorganisation energy\n \n # convert correlation function to lineshape function\n #gt = self._c2g(ta,ct.data)\n gt = tr[\"gt\"]\n # calculate time dependent response\n at = numpy.exp(-numpy.conjugate(gt) -1j*om*ta.data + 2j*re*ta.data)\n else:\n # calculate time dependent response\n at = numpy.exp(-1j*om*ta.data) \n# plt.figure()\n# plt.title(\"Absorption\")\n# plt.plot(ta.data,numpy.real(at))\n# plt.plot(ta.data,numpy.imag(at))\n \n \n if len(gg) == 1:\n gam = gg[0]\n rt = numpy.exp(gam*ta.data)\n at *= rt\n #print(\"Constant: \", rt[20], len(at))\n else:\n rt = numpy.exp((gg)*ta.data) \n at *= rt\n #print(\"Time dependent: len = \", rt[20], len(rt))\n \n if fwhm!=0.0:\n gauss = numpy.exp(-2*(numpy.pi**2)*(sgm**2)*(ta.data**2))\n at *= gauss\n \n # Fourier transform the result\n ft = dd*numpy.fft.hfft(at)*ta.step\n ft = numpy.fft.fftshift(ft)\n # invert the order because hfft is a transform with -i\n ft = numpy.flipud(ft) \n # cut the center of the spectrum\n Nt = ta.length #len(ta.data) \n return ft[Nt//2:Nt+Nt//2]","def plotCombinedIncludingOceanFloors(self):\n self.CombinedPlotHelper(minc=70,maxc=170,num=50)","def results_plot_fuel_reactor(self):\n \n import matplotlib.pyplot as plt \n\n # Total pressure profile\n P = []\n for z in self.MB_fuel.z:\n P.append(value(self.MB_fuel.P[z]))\n fig_P = plt.figure(1)\n plt.plot(self.MB_fuel.z, P)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Total Pressure [bar]\") \n\n # Temperature profile\n Tg = []\n Ts = []\n# Tw = []\n for z in self.MB_fuel.z:\n Tg.append(value(self.MB_fuel.Tg[z] - 273.15))\n Ts.append(value(self.MB_fuel.Ts[z] - 273.15))\n# Tw.append(value(self.MB_fuel.Tw[z]))\n fig_T = plt.figure(2)\n plt.plot(self.MB_fuel.z, Tg, label='Tg')\n plt.plot(self.MB_fuel.z, Ts, label='Ts')\n# plt.plot(self.MB_fuel.z, Tw, label='Tw')\n plt.legend(loc=0,ncol=2)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Temperature [C]\") \n \n # Superficial gas velocity and minimum fluidization velocity\n vg = []\n umf = []\n for z in self.MB_fuel.z:\n vg.append(value(self.MB_fuel.vg[z]))\n umf.append(value(self.MB_fuel.umf[z]))\n fig_vg = plt.figure(3)\n plt.plot(self.MB_fuel.z, vg, label='vg')\n plt.plot(self.MB_fuel.z, umf, label='umf')\n plt.legend(loc=0,ncol=2)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Superficial gas velocity [m/s]\")\n \n # Gas components molar flow rate\n for j in self.MB_fuel.GasList:\n F = []\n for z in self.MB_fuel.z:\n F.append(value(self.MB_fuel.F[z,j]))\n fig_F = plt.figure(4)\n plt.plot(self.MB_fuel.z, F, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Gas component molar flow rate, F [mol/s]\") \n \n # Bulk gas phase total molar flow rate\n Ftotal = []\n for z in self.MB_fuel.z:\n Ftotal.append(value(self.MB_fuel.Ftotal[z]))\n fig_Ftotal = plt.figure(5)\n plt.plot(self.MB_fuel.z, Ftotal)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Total molar gas flow rate [mol/s]\") \n\n # Solid components mass flow rate\n for j in self.MB_fuel.SolidList:\n M = []\n for z in self.MB_fuel.z:\n M.append(value(self.MB_fuel.Solid_M[z,j]))\n fig_M = plt.figure(6)\n plt.plot(self.MB_fuel.z, M, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Solid components mass flow rate [kg/s]\")\n \n # Bulk solid phase total molar flow rate\n Mtotal = []\n for z in self.MB_fuel.z:\n Mtotal.append(value(self.MB_fuel.Solid_M_total[z]))\n fig_Mtotal = plt.figure(7)\n plt.plot(self.MB_fuel.z, Mtotal)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Solid total mass flow rate [kg/s]\") \n \n # Gas phase concentrations\n for j in self.MB_fuel.GasList:\n Cg = []\n for z in self.MB_fuel.z:\n Cg.append(value(self.MB_fuel.Cg[z,j]))\n fig_Cg = plt.figure(8)\n plt.plot(self.MB_fuel.z, Cg, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Concentration [mol/m3]\") \n \n # Gas phase mole fractions\n for j in self.MB_fuel.GasList:\n y = []\n for z in self.MB_fuel.z:\n y.append(value(self.MB_fuel.y[z,j]))\n fig_y = plt.figure(9)\n plt.plot(self.MB_fuel.z, y, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"y [-]\") \n \n # Solid phase mass fractions\n for j in self.MB_fuel.SolidList:\n x = []\n for z in self.MB_fuel.z:\n x.append(value(self.MB_fuel.x[z,j]))\n fig_x = plt.figure(10)\n plt.plot(self.MB_fuel.z, x, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"x [-]\") \n\n # Total mass fraction\n xtot = []\n for z in self.MB_fuel.z:\n xtot.append(value(self.MB_fuel.xtot[z]))\n fig_xtot = plt.figure(11)\n plt.plot(self.MB_fuel.z, xtot)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Total mass fraction [-]\") \n \n # # Gas mix density\n # rhog = []\n # for z in self.MB_fuel.z:\n # rhog.append(value(self.MB_fuel.rho_vap[z]))\n # fig_rhog = plt.figure(23)\n # plt.plot(self.MB_fuel.z, rhog)\n # plt.grid()\n # plt.xlabel(\"Bed height [-]\")\n # plt.ylabel(\"Gas mix density [kg/m3]\") \n \n # Fe conversion\n X_Fe = []\n for z in self.MB_fuel.z:\n X_Fe.append(value(self.MB_fuel.X[z])*100)\n fig_X_Fe = plt.figure(13)\n plt.plot(self.MB_fuel.z, X_Fe)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Fraction of metal oxide converted [%]\")","def SH_surface_plots(n_max=6,figsize=(15,15),fs=15,saveA=True,show=False,dpi=400,vis_type='real'):\n\n N = 100j\n\n for n in range(n_max+1):\n for m in range(n+1):\n plt.close('all')\n print(\"working on Y_%s^%s\" % (n,m) )\n\n PHI,THETA = np.mgrid[0:2*np.pi:N*2, 0:np.pi:N]\n if vis_type == 'real':\n R = sp.sph_harm(m,n,PHI,THETA).real\n if vis_type == 'modulus':\n r = sp.sph_harm(m,n,PHI,THETA)\n R = r * r.conjugate()\n if vis_type == 'unit':\n R = sp.sph_harm(m,n,PHI,THETA).real + 1\n\n X = np.abs(R) * np.sin(THETA) * np.cos(PHI)\n Y = np.abs(R) * np.sin(THETA) * np.sin(PHI)\n Z = np.abs(R) * np.cos(THETA)\n\n norm = colors.Normalize()\n fig, ax = plt.subplots(subplot_kw=dict(projection='3d'), figsize=(14,10))\n sm = cm.ScalarMappable(cmap=cm.seismic)\n ax.plot_surface(X, Y, Z, rstride=1, cstride=1, facecolors=cm.seismic(norm(R)))\n ax.set_title('real$(Y^%s_%s)$' % (m,n), fontsize=fs)\n ax.set_aspect(1)\n sm.set_array(R)\n fig.colorbar(sm, shrink=0.8)\n\n if saveA:\n fig.savefig('images/%s/%s_%s.png' % (vis_type,n,m), dpi=dpi)\n if show:\n plt.show()\n\n # print(\"\\n only +m values are used.\")\n # for n in range(n_max+1):\n # for m in range(n+1):\n # plt.close('all')\n # print(\"\\n n,m = %s,%s\" % (n,m) )\n #\n # R,X,Y,Z = harmonics(m,n)\n #\n # fig = plt.figure(figsize=figsize)\n # ax = plt.subplot(projection='3d')\n # ax.set_aspect(1)\n # ax.set_title(\"n: %s m: %s\" % (n,m), fontsize=fs+2)\n # ax.plot_surface(X,Y,Z,\\\n # cmap = cm.seismic,\n # norm = colors.Normalize( vmin=np.min(R),vmax=np.max(R) )\\\n # )\n #\n # if saveA:\n # fig.savefig('images/%s_%s.png' % (n,m), dpi=dpi)\n # if show:\n # plt.show()","def _showcalibrationscreen(self, showtext=FALSE):\r\n maxX, maxY = self.START_RES\r\n bandWidth = 10\r\n blue = (0,0,255)\r\n red = (112,0,0)\r\n brightred = (255,0,0)\r\n green = (0,255,0)\r\n centerRE = (maxX/2),(maxY/2-35)/2\r\n centerLE = centerRE[0],centerRE[1]+(maxY/2 + 35)\r\n #why not fill with blue, draw red on.?\r\n #put the red on-- using avg of vals in _drawBackground()\r\n self.dscreen.fill(brightred) #2003-01-24-1101 now fill with red, the average of the two check values.\r\n #draw bands, over-under.\r\n \r\n yExtent = (maxY/2)-35\r\n #need overunder display.\r\n #draw on surface.\r\n #draw surface on screen 2x\r\n #also draw crosshairs 2x (long, narrow rects)\r\n myHorizCrossHair = pygame.Rect(0,0,maxX,1)\r\n myVertCrossHair = pygame.Rect(0,0,1,yExtent)\r\n \r\n #init rects and get them the right size. \r\n \r\n #rflist=[.04,.1,.12,.14] #reductionfactor\r\n rflist=[.04,.1,.12] #reductionfactor\r\n #colorlist=[green,red,blue,red]\r\n colorlist=[green,red,blue]\r\n \r\n def returnScaledCenteredColoredRect(reductionFactor,color): \r\n myrect = pygame.Rect(0,0,maxX*(1-reductionFactor),yExtent*(1-reductionFactor))\r\n myrect.center = centerRE\r\n return(color,myrect)\r\n \r\n rectlist = map(returnScaledCenteredColoredRect,rflist,colorlist)\r\n \r\n myHorizCrossHair.topleft = 0,yExtent/2-1\r\n myVertCrossHair.topleft = maxX/2-1,0\r\n \r\n for rect in rectlist:\r\n self.dscreen.fill(rect[0],rect[1])\r\n self.dscreen.fill((0,0,0),myHorizCrossHair)\r\n self.dscreen.fill((0,0,0),myVertCrossHair)\r\n\r\n \r\n for rect in rectlist:\r\n rect[1].center = centerLE\r\n \r\n myHorizCrossHair.topleft = 0,yExtent/2-1\r\n myHorizCrossHair.move_ip(0,maxY/2 + 35)\r\n myVertCrossHair.move_ip(0,maxY/2 + 35)\r\n\r\n for rect in rectlist:\r\n self.dscreen.fill(rect[0],rect[1])\r\n \r\n self.dscreen.fill((0,0,0),myHorizCrossHair)\r\n self.dscreen.fill((0,0,0),myVertCrossHair)\r\n\r\n\r\n if showtext:\r\n my_string = 'Adjust your position so you can see all of the blue ring and none of the red ring.\\n\\nPress [enter] to continue.' \r\n self._displayMessage(width=300,height=125,yPos=325,displayString=my_string,textColor=(216,216,216))\r\n else:\r\n pygame.display.update()\r\n \r\n pygame.event.get() #clear event queue, otherwise, was taking a long time and multiple enters could be pressed, bypassing calibration screen.\r\n while 1:\r\n event = pygame.event.wait()\r\n if (event.type == KEYDOWN) and (event.key == K_RETURN): \r\n break","def display4(*args):\n #-------------------- unpack\n twiss_func = args[0]\n cos_like = args[1]\n sin_like = args[2]\n lat_plot = args[3]\n #-------------------- beta x,y & dispersion x\n s = [twiss_func(i,'s') for i in range(twiss_func.nbpoints)] # Abszisse\n bx = [twiss_func(i,'bx') for i in range(twiss_func.nbpoints)] # beta x\n by = [twiss_func(i,'by') for i in range(twiss_func.nbpoints)] # beta y\n dx = [twiss_func(i,'dx') for i in range(twiss_func.nbpoints)] # dispersion x\n#-------------------- longitudinal trajectories\n z1= [cos_like(i,'s') for i in range(cos_like.nbpoints)]\n cz= [cos_like(i,'cz') for i in range(cos_like.nbpoints)]\n cdp= [cos_like(i,'cdp') for i in range(cos_like.nbpoints)]\n\n z2= [sin_like(i,'s') for i in range(sin_like.nbpoints)]\n sz= [sin_like(i,'sz') for i in range(sin_like.nbpoints)]\n sdp= [sin_like(i,'sdp') for i in range(sin_like.nbpoints)]\n #-------------------- lattice viseo\n vzero = [0. for i in range(lat_plot.nbpoints)] # zero line\n vis_abszisse = [lat_plot(i,'s') for i in range(lat_plot.nbpoints)]\n vis_ordinate = [lat_plot(i,'viseo') for i in range(lat_plot.nbpoints)]\n #-------------------- figure frame\n width=14; height=7.6\n # fighdr = 'lattice version = {}, input file = {}'.format(PARAMS['lattice_version'],PARAMS['input_file'])\n fig = plt.figure(num=1,figsize=(width,height),facecolor='#eaecef',tight_layout=False)\n\n #-------------------- beta functions\n splot211=plt.subplot(211)\n splot211.set_title('beta x,y')\n # mapping box\n splot211.text(0.01, 1.1, UTIL.FLAGS.get('mapping'),transform=splot211.transAxes,fontsize=8,bbox=dict(boxstyle='round',facecolor='wheat',alpha=0.5),verticalalignment='top')\n # function plots\n plt.plot(s,bx, label=r\"$\\beta$x [m]\", color='black', linestyle='-')\n plt.plot(s,by, label=r\"$\\beta$y [m]\", color='red', linestyle='-')\n plt.plot(s,dx, label=r'$\\eta_x$ [m]' , color='green', linestyle='-') # dispersion x\n vscale=splot211.axis()[3]*0.25\n viseoz = [x*vscale for x in vis_ordinate]\n plt.plot(vis_abszisse,viseoz,label='',color='black')\n plt.plot(vis_abszisse,vzero,color='green',linestyle='--')\n # zero line\n splot211.plot(vis_abszisse,vzero,color='green',linestyle='--')\n plt.legend(loc='lower right',fontsize='x-small')\n\n #-------------------- longitudinal tracks z, dP/P\n # ax_l = left abszisse\n ax_l=plt.subplot(212)\n # ax_l=plt.subplot(10,1,(7,9))\n ax_l.set_title('synchrotron oscillation')\n ax_l.set_ylabel(r\"z [mm]\")\n ax_l.tick_params(axis='y', colors='green')\n ax_l.yaxis.label.set_color('green')\n ax_l.plot(z1,cz,label='C',color='green')\n ax_l.plot(z2,sz,label='S',color='green',linestyle=':')\n plt.legend(loc='lower left',fontsize='x-small')\n # ax_r = right abszisse\n ax_r = ax_l.twinx()\n ax_r.set_ylabel(r'$\\Delta$p/p [%]')\n ax_r.tick_params(axis='y', colors='red')\n ax_r.yaxis.label.set_color('red')\n ax_r.plot(z2,cdp,label='C',color='red')\n ax_r.plot(z2,sdp,label='S',color='red',linestyle=':')\n ax_r.plot(vis_abszisse,vzero,color='red', linestyle='--')\n plt.legend(loc='lower right',fontsize='x-small')\n # lattice elements\n vscale=ax_l.axis()[3]*0.25\n viseoz = [x*vscale for x in vis_ordinate]\n ax_l.plot(vis_abszisse,viseoz,label='',color='black')\n ax_l.plot(vis_abszisse,vzero,color='green',linestyle='--')","def plot_reconstruction_diagnostics(self, figsize=(20, 10)):\n figs = []\n fig_names = []\n\n # upsampled frequency\n fx_us = tools.get_fft_frqs(2 * self.nx, 0.5 * self.dx)\n fy_us = tools.get_fft_frqs(2 * self.ny, 0.5 * self.dx)\n\n # plot different stages of inversion\n extent = tools.get_extent(self.fy, self.fx)\n extent_upsampled = tools.get_extent(fy_us, fx_us)\n\n for ii in range(self.nangles):\n fig = plt.figure(figsize=figsize)\n grid = plt.GridSpec(3, 4)\n\n for jj in range(self.nphases):\n\n # ####################\n # separated components\n # ####################\n ax = plt.subplot(grid[jj, 0])\n\n to_plot = np.abs(self.separated_components_ft[ii, jj])\n to_plot[to_plot <= 0] = np.nan\n plt.imshow(to_plot, norm=LogNorm(), extent=extent)\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 0:\n plt.title('O(f)otf(f)')\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 1:\n plt.title('m*O(f-fo)otf(f)')\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 2:\n plt.title('m*O(f+fo)otf(f)')\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n # ####################\n # deconvolved component\n # ####################\n ax = plt.subplot(grid[jj, 1])\n\n plt.imshow(np.abs(self.components_deconvolved_ft[ii, jj]), norm=LogNorm(), extent=extent)\n\n if jj == 0:\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 1:\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\n elif jj == 2:\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 0:\n plt.title('deconvolved component')\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n # ####################\n # shifted component\n # ####################\n ax = plt.subplot(grid[jj, 2])\n\n # avoid any zeros for LogNorm()\n cs_ft_toplot = np.abs(self.components_shifted_ft[ii, jj])\n cs_ft_toplot[cs_ft_toplot <= 0] = np.nan\n plt.imshow(cs_ft_toplot, norm=LogNorm(), extent=extent_upsampled)\n plt.scatter(0, 0, edgecolor='r', facecolor='none')\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 1:\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n elif jj == 2:\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n if jj == 0:\n plt.title('shifted component')\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n # ####################\n # normalized weights\n # ####################\n ax = plt.subplot(grid[jj, 3])\n\n to_plot = self.weights[ii, jj] / self.weight_norm\n to_plot[to_plot <= 0] = np.nan\n im2 = plt.imshow(to_plot, norm=LogNorm(), extent=extent_upsampled)\n im2.set_clim([1e-5, 1])\n fig.colorbar(im2)\n\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n if jj == 1:\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n elif jj == 2:\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n if jj == 0:\n plt.title('normalized weight')\n plt.setp(ax.get_xticklabels(), visible=False)\n plt.setp(ax.get_yticklabels(), visible=False)\n\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\n plt.ylim([2 * self.fmax, -2 * self.fmax])\n\n plt.suptitle('period=%0.3fnm at %0.3fdeg=%0.3frad, f=(%0.3f,%0.3f) 1/um\\n'\n 'mod=%0.3f, min mcnr=%0.3f, wiener param=%0.2f\\n'\n 'phases (deg) =%0.2f, %0.2f, %0.2f, phase diffs (deg) =%0.2f, %0.2f, %0.2f' %\n (self.periods[ii] * 1e3, self.angles[ii] * 180 / np.pi, self.angles[ii],\n self.frqs[ii, 0], self.frqs[ii, 1], self.mod_depths[ii, 1], np.min(self.mcnr[ii]), self.wiener_parameter,\n self.phases[ii, 0] * 180/np.pi, self.phases[ii, 1] * 180/np.pi, self.phases[ii, 2] * 180/np.pi,\n 0, np.mod(self.phases[ii, 1] - self.phases[ii, 0], 2*np.pi) * 180/np.pi,\n np.mod(self.phases[ii, 2] - self.phases[ii, 0], 2*np.pi) * 180/np.pi))\n\n figs.append(fig)\n fig_names.append('sim_combining_angle=%d' % (ii + 1))\n\n # #######################\n # net weight\n # #######################\n figh = plt.figure(figsize=figsize)\n grid = plt.GridSpec(1, 2)\n plt.suptitle('Net weight, Wiener param = %0.2f' % self.wiener_parameter)\n\n ax = plt.subplot(grid[0, 0])\n net_weight = np.sum(self.weights, axis=(0, 1)) / self.weight_norm\n im = ax.imshow(net_weight, extent=extent_upsampled, norm=PowerNorm(gamma=0.1))\n\n figh.colorbar(im, ticks=[1, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 1e-2, 1e-3, 1e-4, 1e-5])\n\n ax.set_title(\"non-linear scale\")\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n circ2 = matplotlib.patches.Circle((0, 0), radius=2*self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ3)\n\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ4)\n\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ5)\n\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ6)\n\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ7)\n\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ8)\n\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\n\n ax = plt.subplot(grid[0, 1])\n ax.set_title(\"linear scale\")\n im = ax.imshow(net_weight, extent=extent_upsampled)\n\n figh.colorbar(im)\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ)\n\n circ2 = matplotlib.patches.Circle((0, 0), radius=2 * self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ2)\n\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ3)\n\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ4)\n\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ5)\n\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ6)\n\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ7)\n\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ8)\n\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\n\n figs.append(figh)\n fig_names.append('net_weight')\n\n return figs, fig_names","def plot_colour_mag_diagram(params,mags, colours, local_mags, local_colours,\n target, source, blend, RC, blue_filter, red_filter,\n yaxis_filter, tol, log):\n\n def calc_colour_lightcurve(blue_lc, red_lc, y_lc):\n\n idx1 = np.where( red_lc['mag_err'] > 0.0 )[0]\n idx2 = np.where( blue_lc['mag_err'] > 0.0 )[0]\n idx3 = np.where( y_lc['mag_err'] > 0.0 )[0]\n idx = set(idx1).intersection(set(idx2))\n idx = list(idx.intersection(set(idx3)))\n\n mags = y_lc['mag'][idx]\n magerr = y_lc['mag_err'][idx]\n cols = blue_lc['mag'][idx] - red_lc['mag'][idx]\n colerr = np.sqrt(blue_lc['mag_err'][idx]**2 + red_lc['mag_err'][idx]**2)\n\n return mags, magerr, cols, colerr\n\n\n add_source_trail = False\n add_target_trail = True\n add_crosshairs = True\n add_source = True\n add_blend = True\n add_rc_centroid = True\n add_extinction_vector = True\n\n fig = plt.figure(1,(10,10))\n\n ax = plt.subplot(111)\n\n plt.rcParams.update({'font.size': 18})\n\n plt.scatter(colours,mags,\n c='#E1AE13', marker='.', s=1,\n label='Stars within ROME field')\n\n plt.scatter(local_colours,local_mags,\n c='#8c6931', marker='*', s=4,\n label='Stars < '+str(round(tol,1))+'arcmin of target')\n\n col_key = blue_filter+red_filter\n\n if getattr(source,blue_filter) != None and getattr(source,red_filter) != None\\\n and add_source:\n\n plt.errorbar(getattr(source,col_key), getattr(source,yaxis_filter),\n yerr = getattr(source,'sig_'+yaxis_filter),\n xerr = getattr(source,'sig_'+col_key), color='m',\n marker='d',markersize=10, label='Source crosshairs')\n\n if add_crosshairs:\n plot_crosshairs(fig,getattr(source,col_key),getattr(source,yaxis_filter),'m')\n\n if add_source_trail:\n red_lc = source.lightcurves[red_filter]\n blue_lc = source.lightcurves[blue_filter]\n y_lc = source.lightcurves[yaxis_filter]\n\n (smags, smagerr, scols, scolerr) = calc_colour_lightcurve(blue_lc, red_lc, y_lc)\n\n plt.errorbar(scols, smags, yerr = smagerr, xerr = scolerr,\n color='m', marker='d',markersize=10, label='Source')\n\n if getattr(blend,blue_filter) != None and getattr(blend,red_filter) != None \\\n and add_blend:\n\n plt.errorbar(getattr(blend,col_key), getattr(blend,yaxis_filter),\n yerr = getattr(blend,'sig_'+yaxis_filter),\n xerr = getattr(blend,'sig_'+col_key), color='b',\n marker='v',markersize=10, label='Blend')\n\n if getattr(target,blue_filter) != None and getattr(target,red_filter) != None \\\n and add_target_trail:\n\n plt.errorbar(getattr(target,col_key), getattr(target,yaxis_filter),\n yerr = getattr(target,'sig_'+yaxis_filter),\n xerr = getattr(target,'sig_'+col_key), color='k',\n marker='x',markersize=10)\n\n red_lc = target.lightcurves[red_filter]\n blue_lc = target.lightcurves[blue_filter]\n y_lc = target.lightcurves[yaxis_filter]\n\n (tmags, tmagerr, tcols, tcolerr) = calc_colour_lightcurve(blue_lc, red_lc, y_lc)\n\n plt.errorbar(tcols, tmags, yerr = tmagerr,xerr = tcolerr,\n color='k', marker='+',markersize=10, alpha=0.4,\n label='Blended target')\n\n if add_rc_centroid:\n plt.errorbar(getattr(RC,col_key), getattr(RC,yaxis_filter),\n yerr=getattr(RC,'sig_'+yaxis_filter),\n xerr=getattr(RC,'sig_'+col_key),\n color='g', marker='s',markersize=10, label='Red Clump centroid')\n\n plt.xlabel('SDSS ('+blue_filter+'-'+red_filter+') [mag]')\n\n plt.ylabel('SDSS-'+yaxis_filter+' [mag]')\n\n [xmin,xmax,ymin,ymax] = plt.axis()\n\n plt.axis([xmin,xmax,ymax,ymin])\n\n xticks = np.arange(xmin,xmax,0.1)\n yticks = np.arange(ymin,ymax,0.2)\n\n ax.set_xticks(xticks,minor=True)\n ax.set_yticks(yticks,minor=True)\n\n plot_file = path.join(params['red_dir'],'colour_magnitude_diagram_'+\\\n yaxis_filter+'_vs_'+blue_filter+red_filter\\\n +'.pdf')\n\n plt.grid()\n\n if red_filter == 'i' and blue_filter == 'r' and yaxis_filter == 'i':\n plt.axis([0.5,2.0,20.2,13.5])\n\n if red_filter == 'i' and blue_filter == 'r' and yaxis_filter == 'r':\n plt.axis([0.0,1.5,21.0,13.5])\n\n if red_filter == 'r' and blue_filter == 'g':\n plt.axis([0.5,3.0,22.0,14.0])\n\n if red_filter == 'i' and blue_filter == 'g':\n plt.axis([0.5,4.4,22.0,14.0])\n\n if add_extinction_vector:\n plot_extinction_vector(fig,params,yaxis_filter)\n\n box = ax.get_position()\n ax.set_position([box.x0, box.y0 + box.height * -0.025,\n box.width, box.height * 0.95])\n\n l = ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.2), ncol=2)\n\n l.legendHandles[0]._sizes = [50]\n l.legendHandles[1]._sizes = [50]\n\n plt.rcParams.update({'legend.fontsize':18})\n plt.rcParams.update({'font.size':18})\n plt.rc('xtick', labelsize=18)\n plt.rc('ytick', labelsize=18)\n\n plt.savefig(plot_file,bbox_inches='tight')\n\n plt.close(1)\n\n log.info('Colour-magnitude diagram output to '+plot_file)","def plot_carrier_frequency(self):\r\n roi = self.phase_roi\r\n phase_slice = (slice(roi[2], roi[3]), slice(roi[0], roi[1]))\r\n # calculation\r\n S = self.image[phase_slice] # signal in phase_roi\r\n t_axis = self.image.x_axis[roi[0]:roi[1]] # [ns] time axis\r\n y_axis = self.image.y_axis[roi[2]:roi[3]] # [mic] spatial scale\r\n N = S.shape[0]//2\r\n\r\n s = np.fft.fft(S, axis=0) / N # fft\r\n s_abs = np.abs(s[:N,:])\r\n f_axis = np.arange(N) / (2 * N) # spatial frequency axis\r\n\r\n s_mean = np.log10(np.mean(s_abs, axis=1))\r\n i0 = np.argmax(s_mean[3:])\r\n f0 = f_axis[3+i0] # [px^-1] fringe carrier frequency (estimate)\r\n s0 = s_mean[3+i0]\r\n sys.stdout.write(\"{} VISAR-{} fringe period = {:.1f} px\\n\".format(\r\n self.h5.shot_id[:11], self.leg, 1/f0))\r\n\r\n # plot calcs\r\n vlim_0 = dataimage.thresh_vlim(S, 0.01)\r\n vlim_1 = dataimage.thresh_vlim(np.log10(s_abs), (0.02, 0.005))\r\n tlim = (t_axis[0], t_axis[-1])\r\n ylim = (y_axis[0], y_axis[-1])\r\n flim = (0, 0.5) # [1/px]\r\n extent_0 = tlim + (0, S.shape[0]) # extent for signal\r\n# extent_0 = tlim + ylim # extent for signal\r\n extent_1 = tlim + flim # extent for fft\r\n\r\n # figure\r\n fig = plt.figure(figsize=(7,7), dpi=100)\r\n axs = []\r\n axs.append(fig.add_subplot(221, ylabel='[px]', title='signal'))\r\n axs.append(fig.add_subplot(222, sharey=axs[0], title='spatial lineout'))\r\n axs.append(fig.add_subplot(223, sharex=axs[0], title='log(fft(signal))',\r\n xlabel='time [ns]', ylabel=\"spatial frequency [px^-1]\"))\r\n axs.append(fig.add_subplot(224, sharey=axs[2], xlabel='log10(power)', title='spectral lineout'))\r\n\r\n axs[0].imshow(S, extent=extent_0,\r\n aspect='auto', vmin=vlim_0[0], vmax=vlim_0[1])\r\n axs[2].imshow(np.log10(s_abs), extent=extent_1,\r\n aspect='auto', vmin=vlim_1[0], vmax=vlim_1[1])\r\n axs[1].plot(np.mean(S, axis=1), np.arange(S.shape[0]))\r\n axs[3].plot(s_mean, f_axis)\r\n axs[0].set_ylim(*extent_0[2:])\r\n \r\n axs[3].annotate(\"fringe period\\n= {:.1f} px\".format(1/f0),\r\n (s0, f0), (0.95, 0.5), textcoords='axes fraction',\r\n arrowprops=dict(width=1, headwidth=6, facecolor='k',\r\n shrink=0.03), ha='right',)\r\n\r\n axs[3].axhline(f0*0.7, color='r', linestyle='dashed')\r\n axs[3].axhline(f0*1.4, color='r', linestyle='dashed')\r\n\r\n fig.tight_layout()\r\n fig.canvas.window().move(0,0)\r\n return fig","def visitcomp(plate,mjd,indiv=False,apred='test') :\n #plt.close('all')\n load=apload.ApLoad(apred=apred)\n a=load.apVisitSum(plate,mjd)[1].data\n\n #dr14=apload.ApLoad(dr='dr14')\n p=yanny.yanny(os.environ['PLATELIST_DIR']+'/platePlans.par',np=True)\n j=np.where(p['PLATEPLANS']['plateid'] == plate)[0][0]\n locid=p['PLATEPLANS']['locationid'][j]\n b=fits.open(os.environ['APOGEE_REDUX']+'/r8/fields/apo25m/{:04d}/apVisitSum-{:04d}-{:05d}.fits'.format(\n locid,plate,mjd))[1].data\n\n fig,ax=plots.multi(2,2)\n i1,i2=match.match(a['FIBERID'],b['FIBERID'])\n plots.plotc(ax[0,0],a['FIBERID'][i1],a['VHELIO'][i1]-b['VHELIO'][i2],a['RV_TEFF'][i1],zr=[3500,5500],xt='Fiber',yt=r'$\\Delta$ VHELIO')\n plots.plotc(ax[0,1],a['FIBERID'][i1],a['VHELIO'][i1]-b['VHELIO'][i2],a['RV_TEFF'][i1],zr=[3500,5500],yr=[-2.,2.],xt='Fiber',yt=r'$\\Delta$ VHELIO')\n plots.plotc(ax[1,0],a['FIBERID'][i1],a['RV_TEFF'][i1]-b['RV_TEFF'][i2],a['RV_TEFF'][i1],zr=[3500,5500],xt='Fiber',yt=r'$\\Delta$ RV_TEFF')\n plots.plotc(ax[1,1],a['RV_TEFF'][i1]-b['RV_TEFF'][i2],a['VHELIO'][i1]-b['VHELIO'][i2],a['RV_TEFF'][i1],zr=[3500,5500],xt=r'$\\Delta$ RV_TEFF',yt=r'$\\Delta$ VHELIO')\n out=load.filename('Plate',chips=True,plate=plate,mjd=mjd)\n outdir=os.path.dirname(out)\n outname=os.path.basename(out).replace('-a','').replace('.fits','_dr14comp.png')\n fig.tight_layout()\n pdb.set_trace()\n print(outdir+'/plots/'+outname)\n fig.savefig(outdir+'/plots/'+outname)\n\n if indiv :\n va=load.apPlate(plate,mjd)\n vb={}\n for chip in chips :\n tmp=fits.open(os.environ['APOGEE_REDUX']+'/r8/apo25m/{:04d}/{:05d}/apPlate-{:s}-{:04d}-{:05d}.fits'.format(\n plate,mjd,chip,plate,mjd))\n vb[chip] = tmp\n\n fig,ax=plots.multi(1,3,hspace=0.3) \n pfig,pax=plots.multi(1,3,hspace=0.3) \n wfig,wax=plots.multi(1,3,hspace=0.3) \n for i in range(len(i1)) :\n fiber = a['FIBERID'][i1[i]]\n if (a['VHELIO'][i1[i]]-b['VHELIO'][i2[i]]) > 0.5 :\n print(fiber,a['VHELIO'][i1[i]],b['VHELIO'][i2[i]],a['RV_TEFF'][i1[i]],b['RV_TEFF'][i2[i]])\n applot.chip(va,ax=ax,row=300-fiber,color='r')\n #applot.chip(va,ax=pax,row=300-fiber,color='r',pixel=True)\n applot.chip(vb,ax=ax,row=300-fiber,color='b')\n #applot.chip(vb,ax=pax,row=300-fiber,color='b',pixel=True)\n for ichip,chip in enumerate(chips) :\n pax[ichip].plot(va[chip][1].data[300-fiber,:]/vb[chip][1].data[300-fiber,:])\n wax[ichip].plot(va[chip][4].data[300-fiber,:]-vb[chip][4].data[300-fiber,:])\n plt.show()\n\n pdb.set_trace()\n for ichip in range(3) :\n ax[ichip].cla()\n pax[ichip].cla()\n wax[ichip].cla()\n plt.close()","def draw_heaters(ax, windtunnel):\n draw_heater(ax, windtunnel.heater_l)\n draw_heater(ax, windtunnel.heater_r)","def frontiere(f, X, y, w=None, step=50, alpha_choice=1, colorbar=True,\n samples=True):\n # construct cmap\n\n min_tot0 = np.min(X[:, 0])\n min_tot1 = np.min(X[:, 1])\n\n max_tot0 = np.max(X[:, 0])\n max_tot1 = np.max(X[:, 1])\n delta0 = (max_tot0 - min_tot0)\n delta1 = (max_tot1 - min_tot1)\n xx, yy = np.meshgrid(np.arange(min_tot0, max_tot0, delta0 / step),\n np.arange(min_tot1, max_tot1, delta1 / step))\n z = np.array([f(vec) for vec in np.c_[xx.ravel(), yy.ravel()]])\n z = z.reshape(xx.shape)\n labels = np.unique(z)\n color_blind_list = sns.color_palette(\"colorblind\", labels.shape[0])\n sns.set_palette(color_blind_list)\n my_cmap = ListedColormap(color_blind_list)\n plt.imshow(z, origin='lower', interpolation=\"mitchell\", alpha=0.80,\n cmap=my_cmap, extent=[min_tot0, max_tot0, min_tot1, max_tot1])\n if colorbar is True:\n ax = plt.gca()\n cbar = plt.colorbar(ticks=labels)\n cbar.ax.set_yticklabels(labels)\n\n labels = np.unique(y)\n k = np.unique(y).shape[0]\n color_blind_list = sns.color_palette(\"colorblind\", k)\n sns.set_palette(color_blind_list)\n ax = plt.gca()\n if samples is True:\n for i, label in enumerate(y):\n label_num = np.where(labels == label)[0][0]\n plt.scatter(X[i, 0], X[i, 1], c=color_blind_list[label_num],\n s=80, marker=symlist[label_num])\n plt.xlim([min_tot0, max_tot0])\n plt.ylim([min_tot1, max_tot1])\n ax.get_yaxis().set_ticks([])\n ax.get_xaxis().set_ticks([])\n if w is not None:\n plt.plot([min_tot0, max_tot0],\n [min_tot0 * -w[1] / w[2] - w[0] / w[2],\n max_tot0 * -w[1] / w[2] - w[0] / w[2]],\n \"k\", alpha=alpha_choice)","def plot_skyline_5578(fig_size,\n flux_5578,\n flux_5578_medfilt, show_plot=False):\n fig, ax = plt.subplots(figsize=(fig_size, fig_size / 2.5))\n ax.plot(flux_5578, alpha=0.5)\n ax.plot(flux_5578_medfilt, alpha=1.0)\n ax.set_ylabel(r\"Integrated flux of skyline 5578 $\\AA$\")\n ax.set_xlabel(\"Fibre\")\n p01 = np.nanpercentile(flux_5578, 1)\n p99 = np.nanpercentile(flux_5578, 99)\n ax.set_ylim(p01, p99)\n ax.set_title(r\"Checking throughput correction using skyline 5578 $\\AA$\")\n ax.tick_params(axis='both', which='minor')\n if show_plot:\n plt.show()\n\n return fig","def plot_spectrum(inp='jw02767005001-02-clear-prism-nrs2-2767_11027.spec.fits', z=9.505, vel_width=100, bkg=None, scale_disp=1.3, nspline=27, show_cont=True, draws=100, figsize=(16, 8), ranges=[(3650, 4980)], Rline=1000, full_log=False, write=False, eazy_templates=None, use_full_dispersion=True, get_spl_templates=False, scale_uncertainty_kwargs=None, plot_unit=None, spline_single=True, sys_err=0.02, return_fit_results=False, use_aper_columns=False, label=None, **kwargs):\n global SCALE_UNCERTAINTY\n \n lw, lr = utils.get_line_wavelengths()\n \n if isinstance(inp, str):\n sampler = SpectrumSampler(inp, **kwargs)\n file = inp\n elif isinstance(inp, pyfits.HDUList):\n sampler = SpectrumSampler(inp, **kwargs)\n file = None\n else:\n file = None\n sampler = inp\n \n if (label is None) & (file is not None):\n label = os.path.basename(file)\n \n spec = sampler.spec\n \n if (use_aper_columns > 0) & ('aper_flux' in spec.colnames):\n if ('aper_corr' in spec.colnames) & (use_aper_columns > 1):\n ap_corr = spec['aper_corr']*1\n else:\n ap_corr = 1\n \n flam = spec['aper_flux']*spec['to_flam']*ap_corr\n eflam = spec['aper_full_err']*spec['to_flam']*ap_corr\n else:\n flam = spec['flux']*spec['to_flam']\n eflam = spec['full_err']*spec['to_flam']\n \n wrest = spec['wave']/(1+z)*1.e4\n wobs = spec['wave']\n mask = spec['valid']\n \n flam[~mask] = np.nan\n eflam[~mask] = np.nan\n \n bspl = sampler.bspline_array(nspline=nspline, get_matrix=True)\n\n # bspl = utils.bspline_templates(wave=spec['wave']*1.e4,\n # degree=3,\n # df=nspline)\n \n w0 = utils.log_zgrid([spec['wave'].min()*1.e4,\n spec['wave'].max()*1.e4], 1./Rline)\n \n templates, tline, _A = make_templates(sampler, z,\n bspl=bspl,\n eazy_templates=eazy_templates,\n vel_width=vel_width,\n scale_disp=scale_disp,\n use_full_dispersion=use_full_dispersion,\n disp=spec.disp,\n grating=spec.grating,\n **kwargs,\n )\n \n if scale_uncertainty_kwargs is not None:\n _, escl, _ = calc_uncertainty_scale(file=None,\n data=(spec, _A),\n **scale_uncertainty_kwargs)\n eflam *= escl\n spec['escale'] *= escl\n \n okt = _A[:,mask].sum(axis=1) > 0\n \n _Ax = _A[okt,:]/eflam\n _yx = flam/eflam\n \n if eazy_templates is None:\n _x = np.linalg.lstsq(_Ax[:,mask].T, \n _yx[mask], rcond=None)\n else:\n _x = nnls(_Ax[:,mask].T, _yx[mask])\n \n coeffs = np.zeros(_A.shape[0])\n coeffs[okt] = _x[0]\n \n _model = _A.T.dot(coeffs)\n _mline = _A.T.dot(coeffs*tline)\n _mcont = _model - _mline\n \n full_chi2 = ((flam - _model)**2/eflam**2)[mask].sum()\n cont_chi2 = ((flam - _mcont)**2/eflam**2)[mask].sum()\n \n if return_fit_results:\n return templates, coeffs, flam, eflam, _model, mask, full_chi2\n \n try:\n oktemp = okt & (coeffs != 0)\n \n AxT = (_A[oktemp,:]/eflam)[:,mask].T\n \n covar_i = utils.safe_invert(np.dot(AxT.T, AxT))\n covar = utils.fill_masked_covar(covar_i, oktemp)\n covard = np.sqrt(covar.diagonal())\n \n has_covar = True\n except:\n has_covar = False\n covard = coeffs*0.\n N = len(templates)\n covar = np.eye(N, N)\n \n print(f'\\n# line flux err\\n# flux x 10^-20 erg/s/cm2')\n if label is not None:\n print(f'# {label}')\n \n print(f'# z = {z:.5f}\\n# {time.ctime()}')\n \n cdict = {}\n eqwidth = {}\n \n for i, t in enumerate(templates):\n cdict[t] = [float(coeffs[i]), float(covard[i])]\n if t.startswith('line '):\n lk = t.split()[-1]\n \n # Equivalent width:\n # coeffs, line fluxes are in units of 1e-20 erg/s/cm2\n # _mcont, continuum model is in units of 1-e20 erg/s/cm2/A\n # so observed-frame equivalent width is roughly\n # eqwi = coeffs[i] / _mcont[ wave_obs[i] ]\n \n if lk in lw:\n lwi = lw[lk][0]*(1+z)/1.e4\n continuum_i = np.interp(lwi, spec['wave'], _mcont)\n eqwi = coeffs[i]/continuum_i\n else:\n eqwi = np.nan\n \n eqwidth[t] = eqwi\n \n print(f'{t:>20} {coeffs[i]:8.1f} ± {covard[i]:8.1f} (EW={eqwi:9.1f})')\n \n \n if 'srcra' not in spec.meta:\n spec.meta['srcra'] = 0.0\n spec.meta['srcdec'] = 0.0\n spec.meta['srcname'] = 'unknown'\n \n spec['model'] = _model/spec['to_flam']\n spec['mline'] = _mline/spec['to_flam']\n \n data = {'z': float(z),\n 'file':file,\n 'label':label,\n 'ra': float(spec.meta['srcra']),\n 'dec': float(spec.meta['srcdec']),\n 'name': str(spec.meta['srcname']),\n 'wmin':float(spec['wave'][mask].min()),\n 'wmax':float(spec['wave'][mask].max()),\n 'coeffs':cdict,\n 'covar':covar.tolist(),\n 'wave': [float(m) for m in spec['wave']],\n 'flux': [float(m) for m in spec['flux']],\n 'err': [float(m) for m in spec['err']],\n 'escale': [float(m) for m in spec['escale']],\n 'model': [float(m) for m in _model/spec['to_flam']],\n 'mline':[float(m) for m in _mline/spec['to_flam']],\n 'templates':templates, \n 'dof': int(mask.sum()), \n 'fullchi2': float(full_chi2), \n 'contchi2': float(cont_chi2),\n 'eqwidth': eqwidth,\n }\n \n for k in ['z','wmin','wmax','dof','fullchi2','contchi2']:\n spec.meta[k] = data[k]\n \n #fig, axes = plt.subplots(len(ranges)+1,1,figsize=figsize)\n if len(ranges) > 0:\n fig = plt.figure(figsize=figsize, constrained_layout=True)\n gs = GridSpec(2, len(ranges), figure=fig)\n axes = []\n for i, _ra in enumerate(ranges):\n axes.append(fig.add_subplot(gs[0,i]))\n \n axes.append(fig.add_subplot(gs[1,:]))\n \n else:\n fig, ax = plt.subplots(1,1,figsize=figsize)\n axes = [ax]\n \n _Acont = (_A.T*coeffs)[mask,:][:,:nspline]\n _Acont[_Acont < 0.001*_Acont.max()] = np.nan\n \n if (draws is not None) & has_covar:\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n mu = np.random.multivariate_normal(coeffs[oktemp], covar_i, size=draws)\n \n #print('draws', draws, mu.shape, _A.shape)\n mdraws = _A[oktemp,:].T.dot(mu.T)\n else:\n mdraws = None\n \n if plot_unit is not None:\n unit_conv = (1*spec.meta['flamunit']).to(plot_unit,\n equivalencies=spec.equiv).value\n else:\n unit_conv = np.ones(len(wobs))\n \n for ax in axes:\n if 1:\n ax.errorbar(wobs, flam*unit_conv, eflam*unit_conv,\n marker='None', linestyle='None',\n alpha=0.5, color='k', ecolor='k', zorder=100)\n\n ax.step(wobs, flam*unit_conv, color='k', where='mid', lw=1, alpha=0.8)\n # ax.set_xlim(3500, 5100)\n\n #ax.plot(_[1]['templz']/(1+z), _[1]['templf'])\n \n ax.step(wobs[mask], (_mcont*unit_conv)[mask],\n color='pink', alpha=0.8, where='mid')\n ax.step(wobs[mask], (_model*unit_conv)[mask],\n color='r', alpha=0.8, where='mid')\n \n cc = utils.MPL_COLORS\n for w, c in zip([3727, 4980, 6565, 9070, 9530, 1.094e4, 1.282e4, \n 1.875e4], \n [cc['purple'], cc['b'], cc['g'], 'darkred', 'darkred', \n cc['pink'], cc['pink'], cc['pink']]):\n wz = w*(1+z)/1.e4\n dw = 70*(1+z)/1.e4\n ax.fill_between([wz-dw, wz+dw], [0,0], [100,100], \n color=c, alpha=0.07, zorder=-100)\n \n \n if mdraws is not None:\n ax.step(wobs[mask], (mdraws.T*unit_conv).T[mask,:],\n color='r', alpha=np.maximum(1./draws, 0.02), zorder=-100, where='mid')\n\n if show_cont:\n ax.plot(wobs[mask], (_Acont.T*unit_conv[mask]).T,\n color='olive', alpha=0.3)\n \n ax.fill_between(ax.get_xlim(), [-100, -100], [0, 0], color='0.8', \n alpha=0.5, zorder=-1)\n\n ax.fill_betweenx([0, 100], [0,0], [1215.67*(1+z)/1.e4]*2, \n color=utils.MPL_COLORS['orange'], alpha=0.2,\n zorder=-1)\n \n ax.grid()\n\n # axes[0].set_xlim(1000, 2500)\n # ym = 0.15; axes[0].set_ylim(-0.1*ym, ym)\n \n for i, r in enumerate(ranges):\n axes[i].set_xlim(*[ri*(1+z)/1.e4 for ri in r])\n # print('xxx', r)\n \n if spec.filter == 'clear':\n axes[-1].set_xlim(0.6, 5.29)\n axes[-1].xaxis.set_minor_locator(MultipleLocator(0.1))\n axes[-1].xaxis.set_major_locator(MultipleLocator(0.5))\n elif spec.filter == 'f070lp':\n axes[-1].set_xlim(0.69, 1.31)\n axes[-1].xaxis.set_minor_locator(MultipleLocator(0.02))\n elif spec.filter == 'f100lp':\n axes[-1].set_xlim(0.99, 1.91)\n axes[-1].xaxis.set_minor_locator(MultipleLocator(0.02))\n axes[-1].xaxis.set_major_locator(MultipleLocator(0.1))\n elif spec.filter == 'f170lp':\n axes[-1].set_xlim(1.69, 3.21)\n elif spec.filter == 'f290lp':\n axes[-1].set_xlim(2.89, 5.31)\n else:\n axes[-1].set_xlim(wrest[mask].min(), wrest[mask].max())\n \n axes[-1].set_xlabel(f'obs wavelenth, z = {z:.5f}')\n \n #axes[0].set_title(os.path.basename(file))\n \n for ax in axes:\n xl = ax.get_xlim()\n ok = wobs > xl[0]\n ok &= wobs < xl[1]\n ok &= np.abs(wrest-5008) > 100\n ok &= np.abs(wrest-6564) > 100\n ok &= mask\n if ok.sum() == 0:\n ax.set_visible(False)\n continue\n \n ymax = np.maximum((_model*unit_conv)[ok].max(), 10*np.median((eflam*unit_conv)[ok]))\n \n ymin = np.minimum(-0.1*ymax, -3*np.median((eflam*unit_conv)[ok]))\n ax.set_ylim(ymin, ymax*1.3)\n # print(xl, ymax)\n \n if ok.sum() > 0:\n if (np.nanmax((flam/eflam)[ok]) > 20) & (full_log):\n ax.set_ylim(0.005*ymax, ymax*5)\n ax.semilogy()\n \n if len(axes) > 0:\n gs.tight_layout(fig, pad=0.8)\n else:\n fig.tight_layout(pad=0.8)\n \n if label is not None:\n fig.text(0.015*12./12, 0.005, f'{label}',\n ha='left', va='bottom',\n transform=fig.transFigure, fontsize=8)\n \n fig.text(1-0.015*12./12, 0.005, time.ctime(),\n ha='right', va='bottom',\n transform=fig.transFigure, fontsize=6)\n \n \n return fig, spec, data","def plot_observed_spectrum(self, iremove = [], cc = [\"C0\", \"C2\", \"C3\"],\n yloc = 1.8, plot_boxes = False, label_molecules = True,\n show_bandpasses = True):\n\n bp_names = self.bp_names\n\n # Set planet and star parameters for an Earth-Sun analog at 6pc\n self.cn.planet.distance = 6.0\n self.cn.planet.a = 1.0\n self.cn.star.Rs = 1.0\n self.cn.star.Teff = 5780.\n\n \"\"\"\n wantSNR_grid = np.array([wantSNR for i in range(len(bp_names))])\n wantSNR_grid[0] = 1.0\n wantSNR_grid[1] = 1.0\n \"\"\"\n\n output = self.complete_spectrum_time()\n spectrum = output[2]\n\n fig, ax = plt.subplots(figsize = (16,5))\n ax.set_xlabel(\"Wavelength [$\\mu$m]\")\n ax.set_ylabel(r\"Planet-Star Flux Ratio ($\\times 10^{-10}$)\")\n for i in range(len(bp_names)):\n if i not in iremove:\n ax.plot(spectrum[0][i], 1e10*spectrum[3][i], \"o\", ms = 4.0, alpha = 0.65, color = \"w\", zorder = 80)\n ax.errorbar(spectrum[0][i], 1e10*spectrum[3][i], yerr=1e10*spectrum[4][i], fmt = \"o\", ms = 2.0, alpha = 0.65, color = \"k\", zorder = 80)\n if show_bandpasses:\n ax.axvspan(self.bandpasses[i][0], self.bandpasses[i][1], alpha = 0.2, color = cc[self.bp_chan[i]])\n\n self.cn.telescope.lammin = 0.2\n self.cn.telescope.lammax = 2.0\n self.cn.telescope.resolution = 140.\n # Re-do count rate calcs for true Earth spectrum\n self.cn.run_count_rates(self.AHR, self.LAMHR, self.FSTAR)\n ax.plot(self.cn.lam, 1e10*self.cn.Cratio, color = \"purple\", zorder = 70, lw = 4.0, alpha = 1.)\n ax.plot(self.cn.lam, 1e10*self.cn.Cratio, color = \"w\", zorder = 70, lw = 2.0, alpha = 0.65)\n ax.set_ylim(bottom=0.0)\n\n # Label Molecules\n if label_molecules:\n ax.text(0.27, 1.55, \"O$_3$\", ha = \"center\", va = \"center\", color = \"k\", zorder = 130)\n ax.text(0.6, 1.45, \"O$_3$\", ha = \"center\", va = \"center\", color = \"k\", zorder = 130)\n ax.text(0.69, 1.35, \"O$_2$\", ha = \"center\", va = \"center\", color = \"k\", zorder = 130)\n ax.text(0.76, 1.65, \"O$_2$\", ha = \"center\", va = \"center\", color = \"k\", zorder = 130)\n ax.text(0.96, 1.65, \"H$_2$O\", ha = \"center\", va = \"center\", color = \"k\", zorder = 130)\n ax.text(1.15, 1.45, \"H$_2$O\", ha = \"center\", va = \"center\", color = \"k\", zorder = 130)\n ax.text(1.4, 1.45, \"H$_2$O\", ha = \"center\", va = \"center\", color = \"k\", zorder = 130)\n ax.text(1.9, 1.25, \"H$_2$O\", ha = \"center\", va = \"center\", color = \"k\", zorder = 130)\n ax.text(1.6, 1.25, \"CO$_2$\", ha = \"center\", va = \"center\", color = \"k\", zorder = 130)\n\n lammin_inst = self.bandpasses[self.bp_chan == 0][0][0]\n lammax_inst = self.bandpasses[self.bp_chan == 0][-1][1]\n xloc = (lammax_inst + lammin_inst) / 2\n name = \"UV\"\n color = cc[0]\n bbox_fc = \"w\"\n ax.annotate(s='', xy=(lammin_inst,yloc), xytext=(lammax_inst,yloc), arrowprops=dict(arrowstyle='<->', color=color, lw = 2.0), zorder=2)\n ax.text(xloc, yloc, name, ha=\"center\", va=\"bottom\", color=color, zorder=99)#, bbox=dict(boxstyle=\"square\", fc=bbox_fc, ec=\"none\", zorder=2))\n if not show_bandpasses: ax.axvspan(lammin_inst, lammax_inst, alpha = 0.2, color = color)\n\n lammin_inst = self.bandpasses[self.bp_chan == 1][0][0]\n lammax_inst = self.bandpasses[self.bp_chan == 1][-1][1]\n xloc = (lammax_inst + lammin_inst) / 2\n name = \"visible\"\n color = cc[1]\n bbox_fc = \"w\"\n ax.annotate(s='', xy=(lammin_inst,yloc), xytext=(lammax_inst,yloc), arrowprops=dict(arrowstyle='<->', color=color, lw = 2.0), zorder=2)\n ax.text(xloc, yloc, name, ha=\"center\", va=\"bottom\", color=color, zorder=99)#, bbox=dict(boxstyle=\"square\", fc=bbox_fc, ec=\"none\", zorder=2))\n if not show_bandpasses: ax.axvspan(lammin_inst, lammax_inst, alpha = 0.2, color = color)\n\n lammin_inst = self.bandpasses[self.bp_chan == 2][0][0]\n lammax_inst = self.bandpasses[self.bp_chan == 2][-1][1]\n xloc = (lammax_inst + lammin_inst) / 2\n name = \"NIR\"\n color = cc[2]\n bbox_fc = \"w\"\n ax.annotate(s='', xy=(lammin_inst,yloc), xytext=(lammax_inst,yloc), arrowprops=dict(arrowstyle='<->', color=color, lw = 2.0), zorder=2)\n ax.text(xloc, yloc, name, ha=\"center\", va=\"bottom\", color=color, zorder=99)#, bbox=dict(boxstyle=\"square\", fc=bbox_fc, ec=\"none\", zorder=2))\n if not show_bandpasses: ax.axvspan(lammin_inst, lammax_inst, alpha = 0.2, color = color)\n\n if plot_boxes:\n\n ax2 = ax.twinx()\n\n \"\"\"\n Xdraw = len(tpbpcs_draws_tots[0][0])\n\n # Transform quantities for boxplot\n tmp = [np.zeros((len(tpbpcs_draws_tots[i]), Xdraw)) for i in range(len(spectroscopy.CHANNELS))]\n for i in range(Xdraw):\n for j in range(tp):\n for k in range(len(tpbpcs_draws_tots[j])):\n tmp[j][k,i] = tpbpcs_draws_tots[j][k][i]\n \"\"\"\n\n icount = 0\n for ichan in range(len(spectroscopy.CHANNELS)):\n\n data = []\n positions = []\n widths = []\n\n for j in range(len(bp_names[bp_chan == ichan])):\n\n data.append(tmp[icount,:])\n positions.append(np.mean(spectrum[0][icount]))\n widths.append(spectrum[0][icount][-1] - spectrum[0][icount][0] + np.mean(spectrum[1][icount][:]))\n color1 = cc[ichan]\n\n comp_str = \"$%i \\%%$\" %(100.*frac_bias_bp[icount])\n comp_str2 = \"$\\mathbf{%i \\%%}$\" %(100.*frac_bias_bp[icount])\n #ax2.text(positions[j], np.median(tmp[icount,:]) + 5.*np.std(tmp[icount,:]), comp_str2,\n # ha = \"center\", va = \"top\", fontsize = 12, color = \"w\")\n ax2.text(positions[j], np.median(tmp[icount,:]) + 5.*np.std(tmp[icount,:]), comp_str2,\n ha = \"center\", va = \"top\", fontsize = 12, color = color1)\n\n icount += 1\n\n positions = np.array(positions)\n widths = np.array(widths)\n bp1 = ax2.boxplot(data, sym = '', widths = widths, showfliers = False,\n boxprops = {\"color\" : color1, \"alpha\" : 0.5},\n whiskerprops = {\"color\" : color1, \"linewidth\" : 2.0},\n capprops = {\"color\" : color1, \"linewidth\" : 0.0},\n medianprops = {\"color\" : \"w\", \"linewidth\" : 2.0},\n patch_artist=True, positions = positions, whis = [5, 95]);\n\n for patch in bp1['boxes']:\n patch.set_facecolor(color1)\n\n ax2.set_ylabel(\"Science Time [hrs]\", labelpad = 22, rotation = 270)\n #ax2.set_title(r\"All %i targets (S/N$\\approx$%i)\" %(Ndraw, wantSNR))\n ax2.set_yscale(\"log\")\n\n ax2.set_xlabel(\"Wavelength [$\\mu$m]\")\n ax2.set_ylim(bottom = 0.0)\n\n ax2.set_xticks([0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0])\n ax2.set_xticklabels([0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0])\n ax2.set_xlim(0.1, 2.0)\n #ax2.set_xlim(0.4, 1.0)\n\n return fig, ax","def P_AI_Rocky(in_dict):\n # START\n fs = 16\n plt.rc('font', size=fs)\n fig = plt.figure(figsize=(14,12))\n ds = nc.Dataset(in_dict['fn'])\n\n # PLOT CODE\n aa = [-122.8, -122.54, 47.92, 48.22]\n import cmocean\n cmap = cmocean.cm.balance\n # cmap = 'RdYlBu_r'\n\n from warnings import filterwarnings\n filterwarnings('ignore') # skip some warning messages\n \n # plot Code\n \n # calculate divergence and vorticity\n uu = ds['u'][0, -1, :, :]\n vv = ds['v'][0, -1, :, :]\n u = zfun.fillit(uu)\n v = zfun.fillit(vv)\n u[np.isnan(u)] = 0\n v[np.isnan(v)] = 0\n \n G = zrfun.get_basic_info(in_dict['fn'], only_G=True)\n \n dive = ((np.diff(u, axis=1)/G['DX'][:, 1:-1])[1:-1, :]\n + (np.diff(v, axis = 0)/G['DY'][1:-1, :])[:, 1:-1])\n #dive[G['mask_rho'][1:-1,1:-1]==False] = np.nan\n \n vort = np.diff(v, axis=1)/G['DX'][1:,1:] - np.diff(u, axis=0)/G['DY'][1:,1:]\n #vort[G['mask_rho'][1:,1:]==False] = np.nan\n \n scl = 2e-3\n \n # panel 1\n ax = fig.add_subplot(121)\n # cs = plt.pcolormesh(G['lon_psi'], G['lat_psi'], dive/scl, cmap=cmap,\n # vmin=-1, vmax=1)\n cs = plt.pcolormesh(G['lon_rho'][1:-1,1:-1], G['lat_rho'][1:-1,1:-1], dive/scl, cmap=cmap,\n vmin=-1, vmax=1, shading='gouraud')\n tstr = (r'Surface Divergence (%0.1e $s^{-1}$)' % (scl))\n #pfun.add_bathy_contours(ax, ds, txt=True)\n pfun.add_coast(ax)\n ax.axis(aa)\n pfun.dar(ax)\n ax.set_xlabel('Longitude')\n ax.set_ylabel('Latitude')\n ax.set_title(tstr)\n pfun.add_info(ax, in_dict['fn'])\n ax.set_xticks([-122.8, -122.7, -122.6])\n ax.set_yticks([48, 48.1, 48.2])\n #\n # panel 2\n ax = fig.add_subplot(122)\n # cs = plt.pcolormesh(G['lon_rho'], G['lat_rho'], vort/scl, cmap=cmap,\n # vmin=-1, vmax=1)\n cs = plt.pcolormesh(G['lon_psi'], G['lat_psi'], vort/scl, cmap=cmap,\n vmin=-1, vmax=1, shading='gouraud')\n tstr = (r'Surface Vorticity (%0.1e $s^{-1}$)' % (scl))\n ax.set_xticks([-122.8, -122.7, -122.6])\n ax.set_yticks([])\n #fig.colorbar(cs)\n \n # Inset colorbar\n from mpl_toolkits.axes_grid1.inset_locator import inset_axes\n cbaxes = inset_axes(ax, width=\"4%\", height=\"40%\", loc='lower left')\n fig.colorbar(cs, cax=cbaxes, orientation='vertical')\n \n #pfun.add_bathy_contours(ax, ds)\n pfun.add_coast(ax)\n ax.axis(aa)\n pfun.dar(ax)\n ax.set_xlabel('Longitude')\n ax.set_title(tstr) \n \n #fig.tight_layout()\n # FINISH\n ds.close()\n if len(in_dict['fn_out']) > 0:\n plt.savefig(in_dict['fn_out'])\n plt.close()\n else:\n plt.show()\n plt.rcdefaults()","def plot_regime_diagram_background_L19(\n ax=None,\n ):\n if ax is None:\n ax = plt.gca()\n # range of power\n xpr = [-1, 1]\n ypr = [-3, 3]\n # range\n xlims = [10**i for i in xpr]\n ylims = [10**i for i in ypr]\n # background following Fig. 3 of Belcher et al., 2012\n nx = 500\n ny = 500\n xx = np.logspace(xpr[0], xpr[1], nx)\n yy = np.logspace(ypr[0], ypr[1], ny)\n zz1 = np.zeros([nx, ny])\n zz2 = np.zeros([nx, ny])\n zz3 = np.zeros([nx, ny])\n for i in np.arange(nx):\n for j in np.arange(ny):\n zz1[i,j] = 2*(1-np.exp(-0.5*xx[i]))\n zz2[i,j] = 0.22*xx[i]**(-2)\n zz3[i,j] = 0.3*xx[i]**(-2)*yy[j]\n zz = zz1 + zz2 + zz3\n\n rz_ST = zz1/zz\n rz_LT = zz2/zz\n rz_CT = zz3/zz\n fr = np.ones(zz.shape) * 7\n cfrac = 0.25\n fr[(rz_LT<cfrac) & (rz_CT<cfrac)] = 1\n fr[(rz_ST<cfrac) & (rz_CT<cfrac)] = 2\n fr[(rz_ST<cfrac) & (rz_LT<cfrac)] = 3\n fr[(rz_ST>=cfrac) & (rz_LT>=cfrac) & (rz_CT<cfrac)] = 4\n fr[(rz_ST>=cfrac) & (rz_CT>=cfrac) & (rz_LT<cfrac)] = 5\n fr[(rz_LT>=cfrac) & (rz_CT>=cfrac) & (rz_ST<cfrac)] = 6\n color_list = ['firebrick','forestgreen','royalblue','gold','orchid','turquoise','w']\n cb_ticks = [0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5]\n cmap, norm = from_levels_and_colors(cb_ticks, color_list)\n ax.contourf(xx, yy, np.transpose(fr), cmap=cmap, norm=norm)\n ax.contour(xx, yy, np.transpose(fr), colors='darkgray')\n ax.set_xlim(xlims)\n ax.set_ylim(ylims)\n ax.set_xscale('log')\n ax.set_yscale('log')\n ax.set_xlabel('La$_t$')\n ax.set_ylabel('$h/L_L$')\n ax.set_aspect(aspect=1/3)\n ax.text(0.11, 4e-3, 'Langmuir', bbox=dict(boxstyle=\"square\",ec='k',fc='w'))\n ax.text(3, 4e-3, 'Shear', bbox=dict(boxstyle=\"square\",ec='k',fc='w'))\n ax.text(0.13, 1e2, 'Convection', bbox=dict(boxstyle=\"square\",ec='k',fc='w'))","def plot_ratio_illustration_for_poster(fs, lfp_pre, lfp_band, zeros, extrema, extrema_kind, steepness_indices,\n steepness_values, save_figure=False):\n \"\"\"\n Plot a figure for illustration of sharpness ratio and steepness ratio calculation. use large fonts for poster.\n \"\"\"\n upto = 5\n fontsize = 20\n markersize = 8\n\n filter_offset = 167 # in ms\n samples_per_5ms = int(5 * fs / 1000)\n last_zero_idx = zeros[upto]\n extrema_to_use = extrema[:(upto - 1)]\n steepness_to_use = steepness_indices[:upto - 2]\n steepness_values_to_use = steepness_values[:upto - 2]\n sharpness_idx = np.sort(np.array([extrema_to_use - samples_per_5ms, extrema_to_use + samples_per_5ms]).flatten())\n\n extrema_idx = int((upto - 1) / 2)\n last_idx = np.max([last_zero_idx, extrema_to_use.max()])\n time_array = np.linspace(filter_offset, filter_offset + last_idx / fs * 1000, last_idx)\n plt.close()\n\n plt.figure(figsize=(15, 5))\n\n # plot LFP only up to last but one zero:\n plt.plot(time_array[:zeros[upto - 1]], lfp_pre[:zeros[upto - 1]], label='preprocessed')\n plt.plot(time_array[:zeros[upto - 1]], lfp_band[:zeros[upto - 1]], label='beta filtered', color='C1')\n plt.plot(time_array[zeros[:upto]], lfp_band[zeros[:upto]], 'o', color='C1', markersize=markersize)\n\n # plot zero line\n plt.axhline(0, color='grey')\n\n # plot +-5ms sharpness markers\n for idx, sharpness_sample in enumerate(sharpness_idx):\n # plt.axvline(x=time_array[sharpness_sample], color='k', alpha=.7, linewidth=.5)\n # color = 'red' if ll[idx] > 0 else 'blue'\n color = 'm'\n plt.plot(time_array[sharpness_sample], lfp_pre[sharpness_sample], '*', markersize=markersize, color=color)\n\n # plot maximum slope markers\n for idx, steepness_sample in enumerate(steepness_to_use):\n plt.plot(time_array[steepness_sample], lfp_pre[steepness_sample], 'd', markersize=markersize, color='g')\n # set up a tangent on this point\n m = (steepness_values_to_use[idx]) / 0.4\n y_val = lfp_pre[steepness_sample]\n x_val = time_array[steepness_sample]\n bias = y_val - m * x_val\n tangent = lambda x: m * x + bias\n tangent_time_array = np.linspace(time_array[steepness_sample] - 2,\n time_array[steepness_sample] + 2, 20)\n plt.plot(tangent_time_array, tangent(tangent_time_array), color='g')\n\n for idx, extrema in enumerate(extrema_to_use):\n if extrema_kind[idx] > 0:\n format = '^'\n label = 'peaks'\n else:\n format = 'v'\n label = 'troughs'\n\n color = 'red'\n plt.plot(time_array[extrema], lfp_pre[extrema], format, markersize=markersize, color=color)\n\n # remove labels for poster figure\n plt.xticks([], [])\n plt.yticks([], [])\n plt.xlabel('time', fontsize=fontsize)\n plt.ylabel('LFP', fontsize=fontsize)\n # plt.xlim([time_array[0], time_array[-1]])\n\n plt.tight_layout()\n plt.legend(frameon=False, prop={'size': 20})\n if save_figure:\n plt.savefig(os.path.join(SAVE_PATH_FIGURES, 'pre_sharpness.pdf'))\n plt.show()","def swe(lon, lat, month):\n\n im = month - 1\n\n h0 = np.array( [ 8.37, 9.43, 10.74, 11.67, 11.80, 12.48,\n 4.01, 1.08, 3.84, 6.24, 7.54, 8.00 ] )\n a = np.array( [ -0.0270, 0.0058, 0.1618, 0.0841, -0.0043, 0.2084,\n 0.0970, 0.0712, 0.0393, 0.1158, 0.0567, -0.0540 ] )\n b = np.array( [ -0.3400, -0.1309, 0.0276, -0.1328, -0.4284, -0.5739,\n -0.4930, -0.1450, -0.2107, -0.2803, -0.3201, -0.3650 ] )\n c = np.array( [ -0.0319, 0.0017, 0.0213, 0.0081, -0.0380, -0.0468,\n -0.0333, -0.0155, -0.0182, -0.0215, -0.0284, -0.0362 ] )\n d = np.array( [ -0.0056, -0.0021, 0.0076, -0.0003, -0.0071, -0.0023,\n -0.0026, 0.0014, -0.0053, 0.0015, -0.0032, -0.0112 ] )\n e = np.array( [ -0.0005, -0.0072, -0.0125, -0.0301, -0.0063, -0.0253,\n -0.0343, -0.0000, -0.0190, -0.0176, -0.0129, -0.0035 ] )\n\n x = (90. - lat) * np.cos( np.radians(lon) )\n y = (90. - lat) * np.sin( np.radians(lon) )\n\n h = ( h0[im] + ( a[im] * x ) + ( b[im] * y ) + ( c[im] * x * y ) +\n ( d[im] * x * x ) + ( e[im] * y * y ) )\n\n# h = np.where( h < 0., 0., h)\n \n return h","def draw_zenith(self, observatory):\n defaults = dict(color='green',alpha=0.75,lw=1.5)\n for k,v in defaults.items():\n kwargs.setdefault(k,v)\n\n # RA and Dec of zenith\n ra_zenith, dec_zenith = np.degrees(observatory.radec_of(0, '90'))\n xy = self.proj(ra_zenith, dec_zenith)\n \n self.plot(*xy,marker='+',ms=10,mew=1.5, **kwargs)\n self.tissot(ra_zenith, dec_zenith, DECAM, 100, fc='none',**kwargs)","def plotSurface(surfaceFile, comp=2, points=False, tris=False,\n profile=False, ax=None, annotate=True, norm=None,xscale=1, yscale=1):\n verts,data,tris = load_h5(surfaceFile)\n\n if comp==3: #radial displacements\n z = np.hypot(data[:,:,0], data[:,:,1]).flatten()\n else:\n z = data[:,:,comp].flatten()\n #z = data[:,:,comp].flatten()\n x = verts[:,0] / xscale\n y = verts[:,1] / yscale\n\n #NOTE: need to change grid for linear spacing to work properly\n xi = np.linspace(x.min(), x.max(), x.size)\n yi = np.linspace(y.min(), y.max(), y.size)\n zi = griddata(x,y,z, xi,yi, interp='nn') #'nn'\n\n #NOTE: getting error message here...\n # linear interpolation requires exactly the same limits\n #xi=np.arange(-15000.0,15000.0+1e-14,30000.0/x.size)\n #yi=np.arange(-15000.0,15000.0+1e-14,30000.0/x.size)\n #zi = griddata(x,y,z, xi,yi, interp='linear') #'nn'\n #ValueError: output grid must have constant spacing when using interp='linear'\n\n if ax==None:\n plt.figure()\n else:\n ax = plt.axes(ax)\n\n #plt.pcolor(xi, yi, zi, cmap=plt.cm.jet) #Very slow...\n x1, x2, y1, y2 = [x.min(), x.max(), y.min(), y.max()]\n im = plt.imshow(zi, cmap=plt.cm.jet, norm=norm, extent=[x1, x2, y1, y2])\n\n if annotate:\n compdict = {0:'Ux',1:'Uy',2:'Uz',3:'Ur'}\n plt.title('{} Displacement'.format(compdict[comp]))\n plt.xlabel('Distance [m]')\n plt.ylabel('Distance [m]')\n cb = plt.colorbar()\n cb.set_label('[m]')\n\n if points:\n plt.plot(x,y,'k.')\n\n if type(tris) is np.ndarray:\n plt.triplot(x, y, tris, 'k-')\n\n # EW profile line through the x-axis\n if profile:\n plt.axhline(linewidth=2, color='r')\n Zi = zi[x.size/2,:]\n plt.figure()\n plt.plot(xi, Zi, 'b.-')\n plt.title('Profile')\n plt.xlabel('Distance [m]')\n plt.ylabel('{} Displacement [m]'.format(compdict[comp]))\n\n return im","def show3(dlist,r=2,c=2,greyscale=False,output=False,samerange=True):\n\n#distrib.show3((d63[:128,:128,0]-1,d0[:128,:128,0]-1,N.log(d63[:128,:128,0]),d63ga[:128,:128,0]),greyscale=True)\n\n M.clf()\n\n fig = M.figure(figsize=(6.4, 6.4), dpi=100) \n axesarr=N.array([[0.01,0.51,0.4,0.4],\n [0.51,0.51,0.4,0.4],\n [0.01,0.01,0.4,0.4],\n [0.51,0.01,0.4,0.4]])\n\n print axesarr\n colorbax = 1.*axesarr\n print colorbax\n colorbax[:,2] = 0.*colorbax[:,2] + 0.03\n colorbax[:,0] += 0.4\n\n print colorbax\n\n if greyscale:\n colorscheme='binary'\n else:\n colorscheme='jet'\n\n # d63, d0, log d63, d63g\n titlearr=[r'$\\delta$',r'$\\delta_{\\rm initial}$',r'$\\log(1+\\delta)$',r'$\\delta_{\\rm Gauss}$']\n\n if (dlist[1] != None):\n min23 = min(min(dlist[2].flatten()),min(dlist[3].flatten()))\n max23 = max(max(dlist[2].flatten()),max(dlist[3].flatten()))\n\n max0 = max(dlist[1].flatten())\n min0 = min(dlist[1].flatten())\n\n initfact = min(max23/max0,min23/min0)\n print min23,max23, initfact\n\n sc = 0\n for d in dlist:\n if (d != None):\n M.axes(axesarr[sc])\n M.title(titlearr[sc],fontsize=23)\n if (sc > 1):\n print titlearr[sc]\n if (samerange):\n M.pcolor(d,cmap=M.get_cmap(colorscheme),vmin = min23,vmax=max23)\n else:\n M.pcolor(d,cmap=M.get_cmap(colorscheme))\n elif (sc == 1):\n #print min(d.flatten()*initfact),max(d.flatten()*initfact)\n if (samerange):\n M.pcolor(d*initfact,cmap=M.get_cmap(colorscheme),vmin = min23,vmax=max23)\n else:\n M.pcolor(d,cmap=M.get_cmap(colorscheme))\n\n else:\n M.pcolor(d,cmap=M.get_cmap(colorscheme))\n\n# if (sc == 1):\n# M.colorbar(ticks=[-0.1,-0.05,0,0.05,0.1])\n# else:\n\n M.axis('tight')\n M.axis('equal')\n M.axis('tight')\n M.xticks([])\n M.yticks([])\n\n cax = M.axes(colorbax[sc])\n M.colorbar(cax=cax)\n\n sc += 1\n\n #M.savefig('showdens.eps',dpi=8)\n #M.gcf().set_size_inches((6.4,6.4))\n #M.gcf().set_size_inches((15.,12.))\n if (output):\n if greyscale:\n M.savefig('showdens_grey.png',dpi=100)\n M.savefig('showdens_grey.pdf')\n else:\n fig.savefig('showdens.png',dpi=100)\n M.savefig('showdens.pdf')\n\n #M.show()","def app_complex(data_pupil,data_phase,oversize=4):\n#phase colors\n # cdict = {'red': ((0.0, 1.0, 1.0),(0.25, 0.0, 0.0),(0.5, 0.0, 0.0),(0.75, 1.0, 1.0),(1.00, 1.0, 1.0)),'green': ((0.0, 0.0, 0.0),(0.25, 1.0, 1.0),(0.5, 0.0, 0.0),(0.75, 1.0, 1.0),(1.0, 0.0, 0.0)),'blue': ((0.0, 0.0, 0.0),(0.25, 0.0, 0.0),(0.5, 1.0, 1.0),(0.75, 0.0, 0.0),(1.0, 0.0, 0.0))}\n #my_cmap = matplotlib.colors.LinearSegmentedColormap('my_colormap',cdict,256)\n\n size=data_pupil.shape[0]\n#make empty oversized array\n\n expand_phase=zeros([oversize*size,oversize*size])\n expand_amp=zeros([oversize*size,oversize*size])\n\n#copy fits into lower left corner\n\n expand_amp[0:size,0:size]=data_pupil[0:size,0:size]\n expand_phase[0:size,0:size]=data_phase[0:size,0:size]\n\n#move to corners\n\n expand_phase=roll(expand_phase,-size/2,0)\n expand_phase=roll(expand_phase,-size/2,1)\n\n expand_amp=roll(expand_amp,-size/2,0)\n expand_amp=roll(expand_amp,-size/2,1)\n\n# recalculate real and imaginary part\n\n #xr=expand_amp*cos(expand_phase)\n #yr=expand_amp*sin(expand_phase)\n\n# make complex array\n\n complexr=expand_amp*numpy.exp(1j*expand_phase)\n\n# apply 2d-fft\n\n complexr=numpy.fft.fftpack.fft2(complexr)\n return fftshift(complexr)","def plotArt(self):\n self.isArt=True\n warr=self.ws.value(self.xarr)\n asfarr=st.interpolate(warr, self.swarr, self.sfarr, left=0.0, right=0.0)\n asfarr=asfarr*self.farr.max()/asfarr.max()\n self.fpcurve,=self.axes.plot(self.xarr,asfarr,linewidth=0.5,linestyle='-',\n marker='None',color='r')","def fdplot(self, imx):\n fig = plt.figure()\n maxval = np.max(imx)\n ims = list(map(lambda im: [plt.imshow(np.fabs(im),norm=colors.Normalize(0.0,maxval))], imx))\n animation = anim.ArtistAnimation(fig,ims,interval=50)\n plt.show()","def plot_steel_pen_N4255(data_obj, test_num):\n\n new_pdf_page(data_obj.pdf_obj) #Create a new page in the pdf for the test results\n\n #--------------------------------#\n # Display the title for the test #\n #--------------------------------#\n n_img = len(data_obj.img_data)\n plt.suptitle('Test ' + str(test_num) + ': Steel penetration (' + str(data_obj.steel_pen) + ' mm)\\n' +\n 'boundary images shown below')\n\n #------------------------------------------------------------------------------------#\n # Display the boundaries of the test for the steps in the steel wedge for each image #\n #------------------------------------------------------------------------------------#\n ROI_size = [15 / data_obj.px_size[0], 5 / data_obj.px_size[1]]\n\n # Loop for each boundary (step) in the steel wedge / test\n for i_boundary in np.arange(12):\n\n # Go through each image and display the individual boundaries for the penetration test\n for i_img in np.arange(n_img):\n\n # ax2 = fig.add_subplot(n_img,12,12*i_img + i_boundary + 1)\n plt.subplot(n_img, 12, 12 * i_img + i_boundary + 1)\n\n plt.tick_params(axis='both', which='both', bottom='off', left='off', top='off', right='off',\n labelbottom='off', labelleft='off')\n\n #-------------------------------------------------------#\n # Create a new ROI for each \"boundary slice\" to display #\n #-------------------------------------------------------#\n center0 = data_obj.img_data[i_img].step_wedge_boundaries[i_boundary]\n center1 = data_obj.img_data[i_img].step_wedge_ROI.shape[1] / 2\n\n ROI_i = ROI(data_obj.img_data[i_img].step_wedge_ROI.get_img(), (center0, center1), ROI_size)\n\n # Calculate the boundary signal for the ROI\n bs = calc_boundary_sig(ROI_i, data_obj.img_data[i_img].px_size,\n ROI_size_mm=2, plot=True, force_middle=True)\n\n #------------------------------------------------------------------------------#\n # Display the additional details to the pdf, formatted for location in the pdf #\n #------------------------------------------------------------------------------#\n\n # Display the area (in mm) that the ROI covers\n if i_img == 0:\n plt.title(str(3 * i_boundary) + '/' + str(3 * (i_boundary + 1)) + ' mm', fontsize=7)\n\n #Display the BSNR values for the test\n elif i_img == 3:\n plt.title('BSNR=' + \"{0:.1f}\".format(data_obj.steel_pen_BSNR[i_boundary]), fontsize=6)\n\n # Display the image (orientation) number\n if i_boundary == 0:\n plt.ylabel('Orientation ' + str(i_img + 1), fontsize=7)","def main(ngrains=100,sigma=15.,c2a=1.6235,mu=0.,\n prc='cst',isc=False,tilt_1=0.,\n tilts_about_ax1=0.,tilts_about_ax2=0.):\n if isc:\n h = mmm()\n else:\n h=np.array([np.identity(3)])\n gr = []\n for i in range(ngrains):\n dth = random.uniform(-180., 180.)\n if prc=='cst': g = gen_gr_fiber(th=dth,sigma=sigma,mu=mu,tilt=tilt_1,iopt=0) # Basal//ND\n elif prc=='ext': g = gen_gr_fiber(th=dth,sigma=sigma,mu=mu,tilt=tilt_1,iopt=1) # Basal//ED\n else:\n raise IOError('Unexpected option')\n for j in range(len(h)):\n temp = np.dot(g,h[j].T)\n\n ## tilts_about_ax1\n if abs(tilts_about_ax1)>0:\n g_tilt = rd_rot(tilts_about_ax1)\n temp = np.dot(temp,g_tilt.T)\n ## tilts_about_ax2?\n elif abs(tilts_about_ax2)>0:\n g_tilt = td_rot(tilts_about_ax2)\n temp = np.dot(temp,g_tilt.T)\n elif abs(tilts_about_ax2)>0 and abs(tilts_about_ax2)>0:\n raise IOError('One tilt at a time is allowed.')\n\n phi1,phi,phi2 = euler(a=temp, echo=False)\n gr.append([phi1,phi,phi2,1./ngrains])\n\n mypf=upf.polefigure(grains=gr,csym='hexag',cdim=[1,1,c2a])\n mypf.pf_new(poles=[[0,0,0,2],[1,0,-1,0]],cmap='jet',ix='TD',iy='RD')\n return np.array(gr)","def visualizeObs():\n fcontourf(fObs, [-2, 2], [-1, 1], [0, 10])","def plot_vanHove_dt(comp,conn,start,step_size,steps):\n \n (fin,) = conn.execute(\"select fout from comps where comp_key = ?\",comp).fetchone()\n (max_step,) = conn.execute(\"select max_step from vanHove_prams where comp_key = ?\",comp).fetchone()\n Fin = h5py.File(fin,'r')\n g = Fin[fd('vanHove',comp[0])]\n\n temp = g.attrs['temperature']\n dtime = g.attrs['dtime']\n\n\n # istatus = plots.non_i_plot_start()\n \n fig = mplt.figure()\n fig.suptitle(r'van Hove dist temp: %.2f dtime: %d'% (temp,dtime))\n dims = figure_out_grid(steps)\n \n plt_count = 1\n outs = []\n tmps = []\n for j in range(start,start+step_size*steps, step_size):\n (edges,count,x_lim) = _extract_vanHove(g,j+1,1,5)\n if len(count) < 50:\n plt_count += 1\n continue\n #count = count/np.sum(count)\n \n sp_arg = dims +(plt_count,)\n ax = fig.add_subplot(*sp_arg)\n ax.grid(True)\n\n \n alpha = _alpha2(edges,count)\n \n ax.set_ylabel(r'$\\log{P(N)}$')\n ax.step(edges,np.log((count/np.sum(count))),lw=2)\n ax.set_title(r'$\\alpha_2 = %.2f$'%alpha + ' j:%d '%j )\n ax.set_xlim(x_lim)\n plt_count += 1\n\n mplt.draw()\n\n # plots.non_i_plot_start(istatus)\n\n del g\n Fin.close()\n del Fin","def display0(*args):\n #----------*----------* # unpack\n twiss_func = args[0]\n cos_like = args[1]\n sin_like = args[2]\n lat_plot = args[3]\n #-------------------- Bahnkoordinate (z)\n z = [twiss_func(i,'s') for i in range(twiss_func.nbpoints)]\n sgx = [twiss_func(i,'sigx') for i in range(twiss_func.nbpoints)]\n sgy = [twiss_func(i,'sigy') for i in range(twiss_func.nbpoints)]\n # zero = [0. for i in range(sigma_fun.nbpoints)]\n #-------------------- trajectories (tz)\n tz= [cos_like(i,'s') for i in range(cos_like.nbpoints)]\n cx= [cos_like(i,'cx') for i in range(cos_like.nbpoints)]\n # cxp= [cos_like(i,'cxp') for i in range(cos_like.nbpoints)]\n cy= [cos_like(i,'cy') for i in range(cos_like.nbpoints)]\n # cyp= [cos_like(i,'cyp') for i in range(cos_like.nbpoints)]\n # cz= [cos_like(i,'cz') for i in range(cos_like.nbpoints)]\n # cdp= [cos_like(i,'cdp') for i in range(cos_like.nbpoints)]\n\n sx= [sin_like(i,'sx') for i in range(sin_like.nbpoints)]\n # sxp= [sin_like(i,'sxp') for i in range(sin_like.nbpoints)]\n sy= [sin_like(i,'sy') for i in range(sin_like.nbpoints)]\n # syp= [sin_like(i,'syp') for i in range(sin_like.nbpoints)]\n # sz= [sin_like(i,'sz') for i in range(sin_like.nbpoints)]\n # sdp= [sin_like(i,'sdp') for i in range(sin_like.nbpoints)]\n #-------------------- lattice viseo\n stop_viseox = 5 # stop viseo plot after so many [m]\n stop_viseoy = 5 # stop viseo plot after so many [m]\n vzero = [0. for i in range(lat_plot.nbpoints)] # zero line\n vis_abszisse = [lat_plot(i,'s') for i in range(lat_plot.nbpoints)]\n vis_ordinate = [lat_plot(i,'viseo') for i in range(lat_plot.nbpoints)]\n #-------------------- figure frame\n width=14; height=7.6\n plt.figure(num=0,figsize=(width,height),facecolor='#eaecef',tight_layout=False)\n\n #-------------------- transverse X\n splot211=plt.subplot(211)\n splot211.set_title('transverse x')\n plt.plot(z,sgx ,label=r'$\\sigma$ [m]',color='green')\n plt.plot(tz,cx ,label='Cx[m]', color='blue',linestyle='-')\n # plt.plot(tz,cxp,label=\"Cx'[m]\",color='blue',linestyle=':')\n plt.plot(tz,sx, label='Sx[m]', color='red' ,linestyle='-')\n # plt.plot(tz,sxp,label=\"Sx'[m]\",color='red' ,linestyle=':')\n # vscale=plt.axis()[3]*0.1\n # viseox = [x*vscale for x in vis_ordinate]\n # for i,s in enumerate(vis_abszisse):\n # if s > stop_viseox:\n # viseox[i] = 0.\n # plt.plot(vis_abszisse,viseox,label='',color='black')\n plt.plot(vis_abszisse,vzero,color='black')\n plt.legend(loc='lower right',fontsize='x-small')\n\n #-------------------- transverse Y\n splot212=plt.subplot(212)\n splot212.set_title('transverse y')\n plt.plot(z,sgy ,label=r'$\\sigma$ [m]',color='green')\n plt.plot(tz,cy, label='Cy[m]', color='blue',linestyle='-')\n # plt.plot(tz,cyp,label=\"Cy'[m]\",color='blue',linestyle=':')\n plt.plot(tz,sy, label='Sy[m]', color='red' ,linestyle='-')\n # plt.plot(tz,syp,label=\"Sy'[m]\",color='red' ,linestyle=':')\n vscale=plt.axis()[3]*0.1\n viseoy = [x*vscale for x in vis_ordinate]\n # for i,s in enumerate(vis_abszisse):\n # if s > stop_viseoy:\n # viseoy[i] = 0.\n plt.plot(vis_abszisse,viseoy,label='',color='black')\n plt.plot(vis_abszisse,vzero,color='black')\n plt.legend(loc='lower right',fontsize='x-small')","def plot_waterfall(d, freqs, lsts, t_unit='hr', f_unit='MHz',\n raster=True):\n\n plt.imshow(d, aspect='auto', interpolation='none',\n rasterized=raster,\n extent=(freqs[0], freqs[-1], lsts[0], lsts[-1]))\n plt.xlabel(\"Frequency [%s]\" % f_unit)\n plt.ylabel(\"Time [%s]\" % t_unit)","def DisplayMesh():\r\n \r\n # Load Surface Mesh Data and generate normals\r\n VTKString = OpenData('C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles','muscle_surface.vtk')\r\n header, Vertices, Triangles = CreateMatrixVTK(VTKString)\r\n \r\n fig = plt.figure()\r\n ax1 = fig.add_subplot(111,projection = '3d')\r\n ax1.plot_trisurf(Vertices[:,0],Vertices[:,1],Vertices[:,2],triangles= Triangles[:,1:])\r\n ax1.set_zlabel('z')\r\n ax1.set_ylabel('y')\r\n ax1.set_xlabel('x')\r\n plt.show()","def plot_fr_and_spikes(self, t):\n plt.figure(figsize=(10, 8))\n\n plt.subplot(2, 2, 1)\n self.plot_base_image()\n\n plt.subplot(2, 2, 2)\n self.plot_firing_rates(t, mode='ON')\n plt.title('Retinal Image')\n\n # Spikes\n ax = plt.subplot(2, 2, 3)\n self.plot_spikes(ax, t, mode='ON', moving_average=True)\n\n ax = plt.subplot(2, 2, 4)\n self.plot_spikes(ax, t, mode='OFF', moving_average=True)","def app_SN_animated_gradient_plot(self):\n print('this option is yet to be implemented')","def opacity(nu, T, n_HI, n_e, n_l, rv, line='halpha'):\n n_l_cgs = n_l * 1e-6\n balmer_properties = {'wavelength': {'halpha': 6562.8e-10, 'hbeta': 4861.35e-10, 'hgamma': 4340.47e-10, 'hdelta': 4101.73e-10},\n 'f_osc': {'halpha': 6.407e-1, 'hbeta': 1.1938e-1, 'hgamma': 4.4694e-2, 'hdelta': 2.2105e-2},\n 'Aul' : {'halpha': 4.4101e7, 'hbeta': 8.4193e6, 'hgamma' : 2.530e6, 'hdelta': 9.732e5}}\n nu_0 = constants.c / balmer_properties['wavelength'][line]\n f_line = balmer_properties['f_osc'][line]\n\n u, a, delta_nu = u_a(nu, nu_0, n_HI, n_e, T, rv, line=line)\n phi_nu = voigt(u, a) / ( np.pi**.5 * delta_nu )\n C_osc = ( np.pi * consts.e.esu.value**2 / (consts.m_e.cgs.value * consts.c.cgs.value ) )\n abs_coeff_cgs = C_osc * f_line * phi_nu * n_l_cgs * ( 1 - np.exp(-constants.h * nu_0 / (constants.k * T )))\n abs_coeff_si = abs_coeff_cgs * 1e2\n\n return abs_coeff_si","def zernikeHexapodTrend(mnts='M20'):\n Tfile='/home/jghao/research/decamFocus/psf_withseeing/finerGrid_coeff_matrix/zernike_coeff_finerGrid_training.cp'\n b=p.load(open(Tfile))\n nobs = len(b)\n x = b[:,0]\n y = b[:,1]\n z = b[:,2]\n theta = b[:,3]\n phi = b[:,4]\n fwhm = b[:,5]\n e1 = b[:,6]\n e2 = b[:,7]\n thetax = theta*np.cos(np.deg2rad(phi))\n thetay = theta*np.sin(np.deg2rad(phi))\n if mnts == 'M20':\n idxBase = 9\n if mnts == 'M22real':\n idxBase = 29\n if mnts == 'M22imag':\n idxBase = 49\n idx = np.arange(14)\n zernikeName=('Piston','Tip','Tilt','Astignism','Defocus','Astignism','Trefoil','Coma','Coma','Trefoil','Ashtray','Astigm.5th','Spherical','Astigm.5th','Ashtray','16','17','18','19','20')\n for i in range(14):\n pl.figure(figsize=(21,10))\n pl.subplot(2,3,1)\n bp.bin_scatter(x,b[:,idxBase+idx[i]],binsize=0.01,fmt='bo',scatter=True)\n pl.xlabel('x decenter')\n pl.ylabel(zernikeName[i+1])\n pl.title(mnts)\n pl.subplot(2,3,2)\n bp.bin_scatter(y,b[:,idxBase+idx[i]],binsize=0.01,fmt='bo',scatter=True)\n pl.xlabel('y decenter')\n pl.ylabel(zernikeName[i+1])\n pl.title(mnts)\n pl.subplot(2,3,3)\n bp.bin_scatter(z,b[:,idxBase+idx[i]],binsize=0.01,fmt='bo',scatter=True)\n pl.xlabel('z-defocus')\n pl.ylabel(zernikeName[i+1])\n pl.title(mnts)\n pl.subplot(2,3,4)\n bp.bin_scatter(thetax,b[:,idxBase+idx[i]],binsize=5,fmt='bo',scatter=True)\n pl.xlabel('x-tilt')\n pl.ylabel(zernikeName[i+1])\n pl.title(mnts)\n pl.subplot(2,3,5)\n bp.bin_scatter(thetay,b[:,idxBase+idx[i]],binsize=5,fmt='bo',scatter=True)\n pl.xlabel('y-tilt')\n pl.ylabel(zernikeName[i+1])\n pl.title(mnts)\n pl.savefig(mnts+'_'+str(i+1)+'_'+zernikeName[i+1]+'.png')\n pl.close()","def plot_map(priors):\n sns.set_style(\"white\")\n\n cmap=sns.cubehelix_palette(8, start=.5, rot=-.75,as_cmap=True)\n hdulists=list(map(lambda prior:postmaps.make_fits_image(prior,prior.sim), priors))\n fig = plt.figure(figsize=(10*len(priors),10))\n figs=[]\n for i in range(0,len(priors)):\n figs.append(aplpy.FITSFigure(hdulists[i][1],figure=fig,subplot=(1,len(priors),i+1)))\n\n for i in range(0,len(priors)):\n vmin=np.min(priors[i].sim)\n vmax=np.max(priors[i].sim)\n figs[i].show_colorscale(vmin=vmin,vmax=vmax,cmap=cmap)\n figs[i].show_markers(priors[i].sra, priors[i].sdec, edgecolor='black', facecolor='black',\n marker='o', s=20, alpha=0.5)\n figs[i].tick_labels.set_xformat('dd.dd')\n figs[i].tick_labels.set_yformat('dd.dd')\n figs[i].add_colorbar()\n figs[i].colorbar.set_location('top')\n return figs,fig","def cov_plot(self, matrix, station=\"\", hour = \"\", date=\"\" , averaged = \"\" ):\n var = self.var_dics[self.var]['name'] \n fig,ax = plt.subplots()\n date = self.date_prettyfier(date)\n hour = str(hour).replace('0','00:00').replace('1','12:00')\n if not averaged:\n title = \"Stat: \" + station + ', H: ' + hour + ', Date: ' + date + ', ' + var\n filename = 'Cov_' + station + '_hour_' + hour.replace(':','') + '_date_' + str(date).replace('/','') + '_' +var\n \n elif averaged :\n title = var.replace('temp','Temp.') + \" , Stat: \" + station + ', H: ' + str(hour) + ', Date: ' + str(date)\n filename ='Cov_' + station + '_hour_' + str(hour).replace(':','') + '_averaged_' + str(date).replace('/','') + '_' + var \n\n plt.title(title.replace('_', ' ' ), y=1.03, fontsize = self.font-2)\n\n num = len(matrix[0,:])\n Num = range(num)\n\n vmin, vmax = -3, 3\n if self.var == 'direction': \n vmin, vmax = -10, 10\n color_map= plt.imshow(matrix, interpolation= 'nearest', cmap = 'RdYlBu', vmin = vmin, vmax = vmax ) # nearest serves for discreete grid # cmaps blue, seismic \n plt.ylim(-0.5, 15.5)\n plt.xlim(-0.5, 15.5)\n plt.xticks(Num, Num)\n plt.xlabel('Pressure level an_dep [hPa]', fontsize = self.font-2)\n plt.yticks(Num, Num)\n plt.ylabel('Pressure level fg_dep [hPa]', fontsize = self.font-2)\n ax.set_xticklabels(labels = self.pretty_pressure, fontsize = self.font-4, rotation=45)\n ax.set_yticklabels(labels = self.pretty_pressure, fontsize = self.font-4)\n\n bar = plt.colorbar()\n bar.ax.set_ylabel(\"Covariance\", fontsize = self.font)\n \n for i in Num: # creating text labels\n for j in Num:\n value = '{0:.2f}'.format(matrix[i,j])\n text = ax.text( j,i, value , ha = 'center' , va = 'center', color = 'black', fontsize = 5)\n\n if not os.path.isdir('plots/covariances/'+station): os.mkdir('plots/covariances/'+station)\n plt.savefig('plots/covariances/' + station + '/' + filename + '.png', bbox_inches='tight', dpi = 200)\n plt.close()","def find_chart():\r\n ###############################################\r\n # Read values of S/N\r\n sn = np.loadtxt(outtable, usecols=(14,))\r\n xs, ys = np.loadtxt(outtable, usecols=(1, 2)).T\r\n specs = np.loadtxt(outtable, usecols=(0,), dtype=str)\r\n ###############################################\r\n # Find good (and bad) regions according to S/N\r\n good = np.where(((~np.isnan(sn)) & (sn >= sn_cut)))[0]\r\n bad = np.where((sn < sn_cut))[0]\r\n ###############################################\r\n # Filter arrays for S/N\r\n sn = sn[good]\r\n xs = xs[good]\r\n ys = ys[good]\r\n specs = specs[good].tolist()\r\n specs = [x.replace(\".fits\", \"\")[1:] for x in specs]\r\n ###############################################\r\n # Set limits for the plot\r\n norm = Normalize(0, 1)\r\n ###############################################\r\n # Set colormap\r\n # cmap = brewer2mpl.get_map('YlGnBu', 'sequential', 5).mpl_colormap\r\n # Produces a collection of polygons with colors according to S/N values\r\n coll = PolyCollection(polygons_bins[good], array=np.ones_like(sn),\r\n cmap=\"gray\", edgecolors='0.5', norm=norm)\r\n ###############################################\r\n # Initiate figure and axis for matplotlib\r\n fig = plt.figure(figsize=(6.25, 6))\r\n gs = gridspec.GridSpec(1, 1)\r\n gs.update(left=0.08, right=0.985, bottom=0.08, top=0.985, hspace=0.05,\r\n wspace=0.06)\r\n ax = plt.subplot(gs[0])\r\n ###############################################\r\n # Draw the polygons\r\n draw_map(fig, ax, coll)\r\n ###############################################\r\n # Add contours according to V-band image\r\n draw_contours(\"vband\", fig, ax)\r\n ###############################################\r\n for x, y, spec in zip(xs, ys, specs):\r\n ax.text(x, y, spec, fontsize=10)\r\n # Write labels\r\n xylabels(ax)\r\n ##############################################\r\n # Save the figure\r\n plt.show()\r\n plt.savefig(\"figs/find_chart.pdf\")\r\n return","def plot_overview(cube=nro_12co,\n region_file='../shell_candidates/AllShells.reg', mode='peak', plotname='12co_peak_shells.png',\n interactive=False, show_shells=True, shells_highlight=None, dist=orion_dist, vmin=None, vmax=None,\n scalebar_color=\"white\", scalebar_pc = 1., scale_factor=1., pmin=0.25,\n pmax=99.75, cbar_label=r\"Peak T$_{\\rm MB}$ [K]\",\n circle_color='white', circle_linewidth=1, circle_style=\"solid\", return_fig=False, show=True,\n title=r\"$^{12}$CO Peak T$_{MB}$\", recenter=False, ra=None, dec=None, radius=None):\n try:\n cube = SpectralCube.read(cube)\n except ValueError:\n pass\n\n if mode == \"peak\":\n image = (cube.max(axis=0) * scale_factor).hdu\n \n\n if mode == \"mom0\":\n image = (cube.moment0() * scale_factor).hdu\n\n\n\n fig = FITSFigure(image)\n if show:\n fig.show_colorscale(cmap='viridis', vmin=vmin, vmax=vmax, pmin=pmin,\n pmax=pmax, interpolation='none')\n fig.tick_labels.set_yformat(\"dd:mm\")\n fig.tick_labels.set_xformat(\"hh:mm\")\n #fig.hide_yaxis_label()\n #fig.hide_ytick_labels()\n plt.title(title)\n plt.xlabel(\"RA (J2000)\")\n plt.ylabel(\"DEC (J2000)\")\n\n if show_shells:\n shell_list = get_shells(region_file=region_file)\n for i, shell in enumerate(shell_list):\n if shells_highlight:\n if i+1 in shells_highlight:\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle='solid', edgecolor=circle_color,\n facecolor='none', linewidth=3)\n else:\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle=circle_style, edgecolor=circle_color,\n facecolor='none', linewidth=circle_linewidth)\n else:\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle=circle_style, edgecolor=circle_color,\n facecolor='none', linewidth=circle_linewidth)\n\n #RECENTER\n if recenter:\n fig.recenter(ra, dec, radius)\n\n\n #SCALEBAR\n fig.add_scalebar(206265 * scalebar_pc / (dist.to(u.pc).value * 3600), color=scalebar_color)\n fig.scalebar.set_label(\"{} pc\".format(scalebar_pc))\n\n fig.add_colorbar()\n cb = fig.colorbar\n cb.set_axis_label_text(cbar_label)\n\n if return_fig:\n return fig\n else:\n fig.save(plotname, dpi=600)","def data_vis():\n dataroot = 'solar_data.txt'\n debug = False \n diff = False\n X, y = read_data(dataroot, debug, diff)\n\n # First plot the original timeseries\n fig = plt.figure(figsize=(40,40))\n\n fig.add_subplot(3,3,1)\n plt.plot(y)\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\n # plt.show()\n\n fig.add_subplot(3,3,2)\n plt.plot(X[:,0])\n plt.title('Avg Zenith Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,3)\n plt.plot(X[:,1])\n plt.title('Avg Azimuth Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,4)\n plt.plot(X[:,2])\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\n # plt.show()\n\n fig.add_subplot(3,3,5)\n plt.plot(X[:,3])\n plt.title('Avg Tower RH [%]')\n # plt.show()\n\n fig.add_subplot(3,3,6)\n plt.plot(X[:,4])\n plt.title('Avg Total Cloud Cover [%]')\n # plt.show()\n\n fig.add_subplot(3,3,7)\n plt.plot(X[:,5])\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\n # plt.show()\n\n ##########################################################################################\n # Plotting the Fourier Transform of the signals\n\n freq = np.fft.fftfreq(len(y), 1*60*60)\n\n fig = plt.figure(figsize=(40,40))\n\n fig.add_subplot(3,3,1)\n plt.plot(freq, np.abs(np.fft.fft(y)))\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\n # plt.show()\n\n fig.add_subplot(3,3,2)\n plt.plot(freq, np.abs(np.fft.fft(X[:,0])))\n plt.title('Avg Zenith Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,3)\n plt.plot(freq, np.abs(np.fft.fft(X[:,1])))\n plt.title('Avg Azimuth Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,4)\n plt.plot(freq, np.abs(np.fft.fft(X[:,2])))\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\n # plt.show()\n\n fig.add_subplot(3,3,5)\n plt.plot(freq, np.abs(np.fft.fft(X[:,3])))\n plt.title('Avg Tower RH [%]')\n # plt.show()\n\n fig.add_subplot(3,3,6)\n plt.plot(freq, np.abs(np.fft.fft(X[:,4])))\n plt.title('Avg Total Cloud Cover [%]')\n # plt.show()\n\n fig.add_subplot(3,3,7)\n plt.plot(freq, np.abs(np.fft.fft(X[:,5])))\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\n # plt.show()\n\n ##################################################################################################\n # Print correlation matrix\n\n df = pd.DataFrame(np.c_[y, X])\n df.columns = ['Avg Global PSP (vent/cor) [W/m^2]','Avg Zenith Angle [degrees]','Avg Azimuth Angle [degrees]','Avg Tower Dry Bulb Temp [deg C]','Avg Tower RH [%]','Avg Total Cloud Cover [%]','Avg Avg Wind Speed @ 6ft [m/s]']\n f = plt.figure(figsize=(19, 15))\n plt.matshow(df.corr(), fignum=f.number)\n plt.xticks(range(df.shape[1]), df.columns, fontsize=14, rotation=20)\n plt.yticks(range(df.shape[1]), df.columns, fontsize=14)\n cb = plt.colorbar()\n cb.ax.tick_params(labelsize=14)\n plt.title('Correlation Matrix', fontsize=16);\n plt.show()","def plot_combined_spectrum(SSC, band):\n\n def get_spectrum(SSC, band):\n spectrum = spectra[str(SSC['no'])][band]\n frequency = spectrum['frequency'].to(u.GHz)\n intensity = spectrum['spectrum'].to(u.K)\n # shift spectrum to rest frequency\n velshift = SSC['velshift']\n frequency = [(-vsys-velshift).to(u.GHz, equivalencies=u.doppler_optical(f)).value for f in frequency]*u.GHz\n # remove NaNs\n frequency, intensity = crossmatch(frequency.to(u.GHz).value, intensity.to(u.K).value)\n return frequency, intensity\n\n def get_model(SSC, band):\n with open(escape_fname(os.path.join(XCLASSdir,'SSC_'+str(SSC['no']),'combined_model.spectrum.pickle')), 'rb') as f:\n m = pickle.load(f, encoding=\"latin1\")\n frequency = (m[:,0]*u.MHz).to(u.GHz)\n model = m[:,1]*u.K\n return frequency.value,model.value\n\n def set_up_figure(SSC, band):\n fig,ax = plt.subplots(nrows=1, ncols=1, squeeze=True, sharex='col', sharey='row', figsize=(10,8))\n ax.text(0.05, 0.9, 'SSC '+str(SSC['no'])+': '+band, color='k', transform=ax.transAxes, ha='left', va='top', weight='bold', fontsize=16, bbox=props)\n return fig,ax\n\n def plot_spectrum(ax, frequency, spectrum):\n ax.plot(frequency, spectrum, lw=1, ls='-', color='k', zorder=3)\n ax.fill_between(frequency, spectrum, [0. for f in frequency], color='grey', alpha=0.5, zorder=2)\n\n def plot_fitted_spectrum(ax, frequency, model):\n ax.plot(frequency, model, lw=1, ls='-', color='r', zorder=5)\n # ax.fill_between(frequency, model, [0. for f in frequency], color='r', alpha=0.5, zorder=4)\n\n def get_detected_lines(band=None):\n # get detected species\n all_species = []\n for SSC in SSCs:\n for specie in detected_species[str(SSC['no'])]:\n if not specie in all_species:\n all_species.append(specie)\n # get all lines of the detected species\n all_lines = []\n for specie in all_species:\n slines = [l for l in lines if l['XCLASS']==specie]\n for sl in slines:\n all_lines.append(sl)\n # keep only lines of given band\n if not band==None:\n bandlines = []\n for line in all_lines:\n if band=='LSB':\n if line['restfreq']<350*u.GHz:\n bandlines.append(line)\n elif band=='USB':\n if line['restfreq']>350*u.GHz:\n bandlines.append(line)\n return sorted(bandlines, key=lambda k: k['restfreq'])\n else:\n return sorted(all_lines, key=lambda k: k['restfreq'])\n\n def label_lines(ax, spectrum, band):\n detected_lines = get_detected_lines(band=band)\n for idx,line in enumerate(detected_lines):\n restfreq = line['restfreq'].to(u.GHz).value\n if (restfreq>frequency[0] and restfreq<frequency[-1]):\n if band=='LSB':\n xlim = [342.4, 346.2]\n elif band=='USB':\n xlim = [354.3, 358.1]\n xloc = xlim[0] +((idx+0.5)/len(detected_lines))*(xlim[1]-xlim[0])\n ax.axvline(x=restfreq, ymin=0, ymax=1, color='dimgrey', ls='--', lw=0.5, zorder=1)\n ax.plot([restfreq,xloc], [1.05*np.nanmax(spectrum), 1.05*1.05*np.nanmax(spectrum)], color='dimgrey', ls='--', lw=0.5, zorder=1, clip_on=False)\n ax.text(xloc, 1.06*1.05*np.nanmax(spectrum), line_tex(line), color='dimgrey', fontsize=10, rotation=90, ha='center', va='bottom')\n\n def format_figure(ax, frequency, spectrum, band):\n if band=='LSB':\n ax.set_xlim([342.4, 346.2])\n elif band=='USB':\n ax.set_xlim([354.3, 358.1])\n ax.set_ylim(-0.05*np.nanmax(spectrum), 1.05*np.nanmax(spectrum))\n ax.xaxis.set_major_locator(MultipleLocator(0.5))\n ax.xaxis.set_minor_locator(MultipleLocator(0.1))\n ax.yaxis.set_major_locator(MultipleLocator(10))\n ax.yaxis.set_minor_locator(MultipleLocator(2))\n ax.tick_params(axis='both', which='major', labelsize=12)\n ax.set_axisbelow(True)\n ax.grid(axis='y', ls=':', c='grey')\n ax.set_xlabel(r'$\\nu_\\mathrm{rest}$ [GHz]', fontsize=12)\n ax.set_ylabel(r'T$_\\mathrm{b}$ [K]', fontsize=12)\n fig.set_tight_layout(True)\n\n def save_figure(fig, band):\n savepath = escape_fname(os.path.join(plotdir, '03.XCLASS_fit', 'combined_spectra', 'SSC_'+str(SSC['no'])+'.'+band+'.combined_spectrum.pdf'))\n os.system('mkdir -p '+os.path.dirname(savepath))\n fig.savefig(savepath, dpi=300, bbox_inches='tight')\n\n\n frequency, spectrum = get_spectrum(SSC, band)\n mfrequency, model = get_model(SSC, band)\n fig,ax = set_up_figure(SSC, band)\n plot_spectrum(ax, frequency, spectrum)\n plot_fitted_spectrum(ax, mfrequency, model)\n label_lines(ax, spectrum, band)\n format_figure(ax, frequency, spectrum, band)\n save_figure(fig, band)","def test1():\n\t\n\td = np.arange(-10000,10000,10) # MHz\n\t#Voigt\n\tp_dict = {'Bfield':300,'rb85frac':1,'Btheta':0,'lcell':75e-3,'T':58,'Dline':'D2','Elem':'Cs'}\n\t\n\t#timing:\n\tst = time.clock()\n\tTF = get_spectra(d,[1,0,0],p_dict,outputs=['Iy'])\n\tet = time.clock() - st\n\tprint(('E-field - Elapsed time (s):', et))\n\n\t'''\n\t#check vs old elecsus\n\tfrom elecsus_v2.libs import spectra as old_spec\n\tst = time.clock()\n\tTF_old = old_spec.get_spectra(d,p_dict,outputs=['Iy'])\n\tet = time.clock() - st\n\tprint 'Old elecsus - Elapsed time (s):', et\n\t'''\n\t\n\tfig = plt.figure(\"Faraday comparison\")\n\tax1 = fig.add_subplot(111)\n\tax1.plot(d,TF[0],'r',lw=2,label='Faraday')\n\t#ax1.plot(d,TF_old[0],'k--',lw=2,label='Vanilla ElecSus')\n\t\n\t#ax1.legend(loc=0)\n\t\n\tax1.set_xlabel('Detuning (MHz)')\n\tax1.set_ylabel('Transmission')\n\t\n\tplt.show()","def hexapodZernikeLinearModel():\n Tfile='/home/jghao/research/decamFocus/psf_withseeing/finerGrid_coeff_matrix/zernike_coeff_finerGrid_training.cp'\n b=p.load(open(Tfile))\n nobs = len(b)\n x = b[:,0]\n y = b[:,1]\n z = b[:,2]\n theta = b[:,3]\n phi = b[:,4]\n fwhm = b[:,5]\n e1 = b[:,6]\n e2 = b[:,7]\n thetax = theta*np.cos(np.deg2rad(phi))\n thetay = theta*np.sin(np.deg2rad(phi))\n \n M22realTrefoil2 = b[:,37] # for x decenter\n M22imagTrefoil1 = b[:,54] \n M22TrefoilXshift = 0.5*(M22realTrefoil2+M22imagTrefoil1)\n\n M22realTrefoil1 = b[:,34] # for y decenter\n M22imagTrefoil2 = b[:,57] \n M22TrefoilYshift = 0.5*(M22realTrefoil1 - M22imagTrefoil2)\n\n M20defocus = b[:,12] # for defocus\n\n M22realComa2 = b[:,36] # for x-tilt\n M22imagComa1 = b[:,55]\n M22ComaXtilt = 0.5*(M22realComa2+M22imagComa1)\n\n M22realComa1 = b[:,35] # for y-tilt\n M22imagComa2 = b[:,56]\n M22ComaYtilt = 0.5*(M22realComa1 - M22imagComa2)\n \n pl.figure(figsize=(21,12))\n pl.subplot(2,3,1)\n t=bp.bin_scatter(M22TrefoilXshift,x,nbins=20,fmt='bo',scatter=True)\n res = linefit(M22TrefoilXshift,x)\n pl.plot(M22TrefoilXshift,M22TrefoilXshift*res[1]+res[0],'r,')\n pl.ylabel('x-decenter')\n pl.xlabel('(M22realTrefoil2+M22imagTrefoil1)/2')\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\n pl.subplot(2,3,2)\n t=bp.bin_scatter(M22TrefoilYshift,y,nbins=20,fmt='bo',scatter=True)\n res = linefit(M22TrefoilYshift,y)\n pl.plot(M22TrefoilYshift,M22TrefoilYshift*res[1]+res[0],'r,')\n pl.ylabel('y-decenter')\n pl.xlabel('(M22realTrefoil1 - M22imagTrefoil2)/2')\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\n pl.subplot(2,3,3)\n t=bp.bin_scatter(M20defocus,z,nbins=20,fmt='bo',scatter=True)\n res = linefit(M20defocus,z)\n pl.plot(M20defocus,M20defocus*res[1]+res[0],'r,')\n pl.ylabel('z-defocus')\n pl.xlabel('M20defocus')\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\n pl.subplot(2,3,4)\n t=bp.bin_scatter(M22ComaXtilt,thetax,nbins=20,fmt='bo',scatter=True)\n res = linefit(M22ComaXtilt,thetax)\n pl.plot(M22ComaXtilt,M22ComaXtilt*res[1]+res[0],'r,')\n pl.ylabel('x-tilt')\n pl.xlabel('(M22realComa2+M22imagComa1)/2')\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\n pl.subplot(2,3,5)\n t=bp.bin_scatter(M22ComaYtilt,thetay,nbins=20,fmt='bo',scatter=True)\n res = linefit(M22ComaYtilt,thetay)\n pl.plot(M22ComaYtilt,M22ComaYtilt*res[1]+res[0],'r,')\n pl.ylabel('y-tilt')\n pl.xlabel('(M22realComa1 - M22imagComa2)/2')\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\n\n pl.close()","def plotAll(fx,tfarray,tlst,flst,fignum=1,starttime=0,timeinc='hrs',\r\n dt=1.0,title=None,vmm=None,cmap=None,aspect=None,interpolation=None,\r\n cbori=None,cbshrink=None,cbaspect=None,cbpad=None,normalize='n',\r\n scale='log'):\r\n \r\n #time increment\r\n if timeinc=='hrs':\r\n tinc=3600/dt\r\n elif timeinc=='min':\r\n tinc=60/dt\r\n elif timeinc=='sec':\r\n tinc=1/dt\r\n else:\r\n raise ValueError(timeinc+'is not defined')\r\n #colormap\r\n if cmap==None:\r\n cmap='jet'\r\n else:\r\n cmap=cmap\r\n #aspect ratio\r\n if aspect==None:\r\n aspect='auto'\r\n else:\r\n aspect=aspect\r\n #interpolation\r\n if interpolation==None:\r\n interpolation='gaussian'\r\n else:\r\n interpolation=interpolation\r\n #colorbar orientation\r\n if cbori==None:\r\n cbori='vertical'\r\n else:\r\n cbori=cbori\r\n #colorbar shinkage\r\n if cbshrink==None:\r\n cbshrink=.99\r\n else:\r\n cbshrink=cbshrink\r\n #colorbar aspect\r\n if cbaspect==None:\r\n cbaspect=20\r\n else:\r\n cbaspect=cbaspect\r\n #colorbar pad\r\n if cbpad==None:\r\n cbpad=.1\r\n else:\r\n cbpad=cbpad\r\n \r\n #scale\r\n if scale=='log':\r\n zerofind=np.where(abs(tfarray)==0)\r\n tfarray[zerofind]=1.0\r\n if normalize=='y':\r\n plottfarray=20*np.log10(abs(tfarray/np.max(abs(tfarray))))\r\n else:\r\n plottfarray=20*np.log10(abs(tfarray))\r\n elif scale=='linear':\r\n if normalize=='y':\r\n plottfarray=abs(plottfarray/np.max(abs(plottfarray)))**2\r\n else:\r\n plottfarray=abs(tfarray)**2\r\n \r\n t=np.arange(len(fx))*dt+starttime*dt\r\n FX=np.fft.fft(padzeros(fx))\r\n FXfreq=np.fft.fftfreq(len(FX),dt)\r\n \r\n #set some plot parameters\r\n plt.rcParams['font.size']=10\r\n plt.rcParams['figure.subplot.left']=.13\r\n plt.rcParams['figure.subplot.right']=.98\r\n plt.rcParams['figure.subplot.bottom']=.07\r\n plt.rcParams['figure.subplot.top']=.96\r\n plt.rcParams['figure.subplot.wspace']=.25\r\n plt.rcParams['figure.subplot.hspace']=.20\r\n #plt.rcParams['font.family']='helvetica'\r\n \r\n fig=plt.figure(fignum)\r\n \r\n #plot FFT of fx\r\n fax=fig.add_axes([.05,.25,.1,.7])\r\n plt.plot(abs(FX[0:len(FX)/2]/max(abs(FX)))**2,FXfreq[0:len(FX)/2],'-k')\r\n plt.xlim(0,1)\r\n plt.ylim(0,FXfreq[len(FX)/2-1])\r\n fax.xaxis.set_major_locator(MultipleLocator(.5))\r\n \r\n #plot TFD\r\n pax=fig.add_axes([.25,.25,.75,.7])\r\n if vmm!=None:\r\n vmin=vmm[0]\r\n vmax=vmm[1]\r\n plt.imshow(plottfarray,extent=(tlst[0]/tinc,tlst[-1]/tinc,\r\n flst[0],flst[-1]),aspect=aspect,vmin=vmin,vmax=vmax,cmap=cmap,\r\n interpolation=interpolation)\r\n else:\r\n plt.imshow(plottfarray,extent=(tlst[0]/tinc,tlst[-1]/tinc,\r\n flst[0],flst[-1]),aspect=aspect,cmap=cmap,\r\n interpolation=interpolation)\r\n plt.xlabel('Time('+timeinc+')',fontsize=12,fontweight='bold')\r\n plt.ylabel('Frequency (Hz)',fontsize=12,fontweight='bold')\r\n if title!=None:\r\n plt.title(title,fontsize=14,fontweight='bold')\r\n plt.colorbar(orientation=cbori,shrink=cbshrink,pad=cbpad,aspect=cbaspect)\r\n \r\n #plot timeseries\r\n tax=fig.add_axes([.25,.05,.60,.1])\r\n plt.plot(t,fx,'-k')\r\n plt.axis('tight')\r\n plt.show()","def flatNoisePellicle():\n #Get data\n wdir = '/home/rallured/Dropbox/AXRO/Metrology/' \\\n 'NoiseStudy/SolarBwPellicle/'\n d1,dx1 = met.read4DFits(wdir+'161209_Avg8_Meas1.fits')\n d2,dx2 = met.read4DFits(wdir+'161209_Avg8_Meas2.fits')\n d3,dx3 = met.read4DFits(wdir+'161209_Avg8_Meas3.fits')\n d4,dx4 = met.read4DFits(wdir+'161209_Avg8_Meas4.fits')\n\n #Construct power spectra\n f12,pow12 = fourier.meanPSD((d1-d2)[:,100:-100],\\\n win=np.hanning,dx=dx1,irregular=True)\n f23,pow23 = fourier.meanPSD((d2-d3)[:,100:-100],\\\n win=np.hanning,dx=dx1,irregular=True)\n f34,pow34 = fourier.meanPSD((d3-d4)[:,100:-100],\\\n win=np.hanning,dx=dx1,irregular=True)\n f14,pow14 = fourier.meanPSD((d1-d4)[:,100:-100],\\\n win=np.hanning,dx=dx1,irregular=True)\n\n #Mid frequency\n midfreq = [1000*np.sqrt(np.sum(p[np.logical_and(f>.1,f<1.)])) \\\n for f,p in zip([f12,f23,f34,f14],[pow12,pow23,pow34,pow14])]\n\n #Plot\n plt.loglog(f12,pow12/f12[0],label='1-2: %.2f' % midfreq[0])\n plt.loglog(f23,pow23/f23[0],label='2-3: %.2f' % midfreq[1])\n plt.loglog(f34,pow34/f34[0],label='3-4: %.2f' % midfreq[2])\n plt.loglog(f14,pow14/f14[0],label='1-4: %.2f' % midfreq[3])\n plt.legend(loc='lower left')\n plt.grid()\n plt.title('4D Repeatability: SolarB Flat+Pellicle')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n\n print midfreq\n\n return f12,pow12","def plotBrighterFatter(out='BrighterFatter.pdf', requirementFWHM=10.8, sigma=3):\n matplotlib.rc('text', usetex=True)\n\n #600nm\n low = [fileIO.cPicleRead(file) for file in g.glob('results/I600nm5k*.pkl')]\n med = [fileIO.cPicleRead(file) for file in g.glob('results/I600nm10k*.pkl')]\n high = [fileIO.cPicleRead(file) for file in g.glob('results/I600nm54k*.pkl')]\n data = (low, med, high)\n fluxes600 = []\n fluxes600err = []\n wx600 = []\n wxerrs = []\n wy600 = []\n wyerrs = []\n for x in data:\n wx = np.median([d['wx'] for d in x])\n wxerr = np.median([d['wxerr'] for d in x])\n wy = np.median([d['wy'] for d in x])\n wyerr = np.median([d['wyerr'] for d in x])\n wx600.append(wx)\n wxerrs.append(wxerr)\n wy600.append(wy)\n wyerrs.append(wyerr)\n fluxes600.append(np.median([d['peakvalue'] for d in x]))\n fluxes600err.append(np.std([d['peakvalue'] for d in x]))\n\n wx600 = _FWHMGauss(np.asarray(wx600))\n wy600 = _FWHMGauss(np.asarray(wy600))\n fluxes600 = np.asarray(fluxes600)\n fluxes600err = np.asarray(fluxes600err)\n #averaged over many runs\n wx600err = _FWHMGauss(np.asarray(wxerr))\n wy600err = _FWHMGauss(np.asarray(wyerr))\n w600 = np.sqrt(wx600*wy600)\n w600err = np.sqrt(wx600err*wy600err)\n print wx600\n print wy600\n print fluxes600\n\n #800nm\n nom = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm?.pkl')]\n nom5k = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm5k*.pkl')]\n nom10k = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm10k*.pkl')]\n nom20k = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm20k*.pkl')]\n nom30k = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm30k*.pkl')]\n nom38k = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm38k*.pkl')]\n nom50k = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm50k*.pkl')]\n nom54k = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm54k*.pkl')]\n\n data = (nom5k, nom10k, nom20k, nom30k, nom38k, nom50k, nom54k, nom)\n fluxes800 = []\n fluxes800err = []\n wx800 = []\n wxerrs = []\n wy800 = []\n wyerrs = []\n for x in data:\n wx = np.max([d['wx'] for d in x])\n wxerr = np.max([d['wxerr'] for d in x])\n wy = np.max([d['wy'] for d in x])\n wyerr = np.max([d['wyerr'] for d in x])\n wx800.append(wx)\n wxerrs.append(wxerr)\n wy800.append(wy)\n wyerrs.append(wyerr)\n fluxes800.append(np.median([d['peakvalue'] for d in x]))\n fluxes800err.append(np.std([d['peakvalue'] for d in x]))\n\n wx800 = _FWHMGauss(np.asarray(wx800))\n wy800 = _FWHMGauss(np.asarray(wy800))\n fluxes800 = np.asarray(fluxes800)\n fluxes800err = np.asarray(fluxes800err)\n #averaged over many runs\n wx800err = _FWHMGauss(np.asarray(wxerr))\n wy800err = _FWHMGauss(np.asarray(wyerr))\n w800 = np.sqrt(wx800*wy800)\n w800err = np.sqrt(wx800err*wy800err)\n print wx800\n print wy800\n print fluxes800\n\n #plot FWHM\n fig = plt.figure()\n ax1 = fig.add_subplot(311)\n ax2 = fig.add_subplot(312)\n ax3 = fig.add_subplot(313)\n fig.subplots_adjust(hspace=0, top=0.93, bottom=0.17, left=0.11, right=0.93)\n ax1.set_title('CCD273 PSF Intensity Dependency')\n\n ax1.errorbar(fluxes600, wx600, yerr=sigma*wx600err, xerr=sigma*fluxes600err, fmt='o', label='600nm', c='g')\n ax2.errorbar(fluxes600, wy600, yerr=sigma*wy600err, xerr=sigma*fluxes600err, fmt='o', label='600nm', c='g')\n ax3.errorbar(fluxes600, w600, yerr=sigma*w600err, xerr=sigma*fluxes600err, fmt='o', label='600nm', c='g')\n\n ax1.errorbar(fluxes800, wx800, yerr=sigma*wx800err, xerr=sigma*fluxes800err, fmt='s', label='800nm', c='m')\n ax2.errorbar(fluxes800, wy800, yerr=sigma*wy800err, xerr=sigma*fluxes800err, fmt='s', label='800nm', c='m')\n ax3.errorbar(fluxes800, w800, yerr=sigma*w800err, xerr=sigma*fluxes800err, fmt='s', label='800nm', c='m')\n\n #linear fits\n z1 = np.polyfit(fluxes600, wx600, 1)\n p1 = np.poly1d(z1)\n z2 = np.polyfit(fluxes600, wy600, 1)\n p2 = np.poly1d(z2)\n z3 = np.polyfit(fluxes600, w600, 1)\n p3 = np.poly1d(z3)\n x = np.linspace(0., fluxes600.max()*1.05, 100)\n #ax1.plot(x, p1(x), 'g-')\n #ax2.plot(x, p2(x), 'g-')\n #ax3.plot(x, p3(x), 'g-')\n print '600nm fits:'\n print p1\n print p2\n print p3\n\n # Bayesian\n p600x, params600x, errors600x, outliers600x = linearFitWithOutliers(fluxes600, wx600, wx600err,\n outtriangle='BF600FWHMx.png')\n p600y, params600y, errors600y, outliers600y = linearFitWithOutliers(fluxes600, wy600, wy600err,\n outtriangle='BF600FWHMy.png')\n p600, params600, errors600, outliers600 = linearFitWithOutliers(fluxes600, w600, w600err,\n outtriangle='BF600FWHM.png')\n print params600x[::-1], errors600x[::-1]\n print params600y[::-1], errors600y[::-1]\n print params600[::-1], errors600[::-1]\n\n ax1.plot(x, params600x[0] + params600x[1]*x, 'g-')\n #ax1.plot(fluxes600[outliers600x], wx600[outliers600x], 'ro', ms=20, mfc='none', mec='red')\n ax2.plot(x, params600y[0] + params600y[1]*x, 'g-')\n #ax2.plot(fluxes600[outliers600y], wy600[outliers600y], 'ro', ms=20, mfc='none', mec='red')\n ax3.plot(x, params600[0] + params600[1]*x, 'g-')\n #ax3.plot(fluxes600[outliers600], w600[outliers600], 'ro', ms=20, mfc='none', mec='red')\n\n z1 = np.polyfit(fluxes800, wx800, 1)\n p1 = np.poly1d(z1)\n z2 = np.polyfit(fluxes800, wy800, 1)\n p2 = np.poly1d(z2)\n z3 = np.polyfit(fluxes800, w800, 1)\n p3 = np.poly1d(z3)\n x = np.linspace(0., fluxes800.max()*1.05, 100)\n #ax1.plot(x, p1(x), 'm-')\n #ax2.plot(x, p2(x), 'm-')\n #ax3.plot(x, p3(x), 'm-')\n print '800nm fits:'\n print p1\n print p2\n print p3\n\n # Bayesian\n p800x, params800x, errors800x, outliers800x = linearFitWithOutliers(fluxes800, wx800, wx800err,\n outtriangle='BF800FWHMx.png')\n p800y, params800y, errors800y, outliers800y = linearFitWithOutliers(fluxes800, wy800, wy800err,\n outtriangle='BF800FWHMy.png')\n p800, params800, errors800, outliers800 = linearFitWithOutliers(fluxes800, w800, w800err,\n outtriangle='BF800FWHM.png')\n print params800x[::-1], errors800x[::-1]\n print params800y[::-1], errors800y[::-1]\n print params800[::-1], errors800[::-1]\n\n ax1.plot(x, params800x[0] + params800x[1]*x, 'm-')\n #ax1.plot(fluxes800[outliers800x], wx800[outliers800x], 'ro', ms=20, mfc='none', mec='red')\n ax2.plot(x, params800y[0] + params800y[1]*x, 'm-')\n #ax2.plot(fluxes800[outliers800y], wy800[outliers800y], 'ro', ms=20, mfc='none', mec='red')\n ax3.plot(x, params800[0] + params800[1]*x, 'm-')\n #ax3.plot(fluxes800[outliers800], w800[outliers800], 'ro', ms=20, mfc='none', mec='red')\n\n #requirements\n #ax1.axhline(y=requirementFWHM, label='Requirement (800nm)', c='r', ls='--')\n #ax2.axhline(y=requirementFWHM, label='Requirement (800nm)', c='r', ls='--')\n #ax3.axhline(y=requirementFWHM, label='Requirement (800nm)', c='r', ls='-')\n\n plt.sca(ax1)\n plt.xticks(visible=False)\n plt.sca(ax2)\n plt.xticks(visible=False)\n plt.sca(ax3)\n\n ax1.set_ylim(4.3, 10.8)\n ax2.set_ylim(4.3, 10.8)\n ax3.set_ylim(4.3, 10.8)\n ax1.set_xlim(0., fluxes800.max()*1.05)\n ax2.set_xlim(0., fluxes800.max()*1.05)\n ax3.set_xlim(0., fluxes800.max()*1.05)\n\n ax3.set_ylabel(r'FWHM $\\, [\\mu$m$]$')\n ax1.set_ylabel(r'FWHM$_{X} \\, [\\mu$m$]$')\n ax2.set_ylabel(r'FWHM$_{Y} \\, [\\mu$m$]$')\n ax3.set_xlabel(r'Intensity $\\quad [e^{-}]$')\n ax1.legend(shadow=True, fancybox=True, numpoints=1, loc='lower right')\n ax2.legend(shadow=True, fancybox=True, numpoints=1, loc='lower right')\n ax3.legend(shadow=True, fancybox=True, numpoints=1, loc='lower right')\n plt.savefig(out)\n plt.close()\n\n print 'R2:'\n R2 = _R2FromGaussian(wx800pix, wy800pix)*1e3\n errR2 = _R2err(wx800pix, wy800pix, wxerr, wyerr)*1e3\n print R2\n p, params, errors, outliers = linearFitWithOutliers(fluxes800, R2, errR2, outtriangle='BF800R2.png')\n print params[::-1], errors[::-1]\n\n fig = plt.figure()\n ax1 = fig.add_subplot(211)\n ax2 = fig.add_subplot(212)\n fig.subplots_adjust(hspace=0, top=0.93, bottom=0.17, left=0.11, right=0.93)\n ax1.set_title('CCD273 PSF Intensity Dependency')\n ax1.errorbar(fluxes800, R2, yerr=sigma*errR2, fmt='o', label='800nm', c='b')\n ax1.plot(x, params[0] + params[1]*x, 'm-')\n ax1.plot(fluxes800[outliers], R2[outliers], 'ro', ms=20, mfc='none', mec='red')\n ax1.set_ylabel(r'$R^{2} \\, [$mas$^{2}]$')\n\n print 'Ellipticity'\n ell = _ellipticityFromGaussian(wx800pix, wy800pix)\n print ell\n ellerr = _ellipticityerr(wx800pix, wy800pix, wxerr, wyerr)\n p, params, errors, outliers = linearFitWithOutliers(fluxes800, ell, ellerr, outtriangle='BF800ell.png')\n print params[::-1], errors[::-1]\n\n ax2.errorbar(fluxes800, ell, yerr=sigma*ellerr, fmt='s', label='800nm', c='m')\n ax2.plot(x, params[0] + params[1]*x, 'm-')\n ax2.plot(fluxes800[outliers], ell[outliers], 'ro', ms=20, mfc='none', mec='red')\n ax2.axhline(y=0.156, label='Requirement', c='r')\n ax1.axhline(y=2., label='Requirement', c='r')\n ax1.set_xlim(0., fluxes800.max()*1.05)\n ax2.set_xlim(0., fluxes800.max()*1.05)\n ax1.set_ylim(0.8, 2.1)\n ax2.set_ylim(-0.01, 0.165)\n ax2.set_ylabel('Ellipticity')\n ax2.set_xlabel(r'Intensity $\\quad [e^{-}]$')\n ax1.legend(shadow=True, fancybox=True, numpoints=1, loc='lower right')\n ax2.legend(shadow=True, fancybox=True, numpoints=1)\n\n plt.savefig('R2ellIntensity.pdf')\n plt.close()","def plot_phase(self,res):\n x = np.linspace(0,1,res)\n y = np.linspace(0,1,res)\n X,Y = np.meshgrid(x,y)\n plt.figure()\n ax = plt.axes(projection = '3d')\n ax.plot_surface(X,Y,np.angle(self.psi)[:,:,math.floor(res/2)])\n plt.show()","def get_iPTF14gqr(colorplt=False):\n z = 0.063\n # ebv = 0.082\n D = cosmo.luminosity_distance([z])[0].value * 1e+6 # in pc\n dis_mod = 5*np.log10(D / 10)\n t_exp = 56943.74 # \n t_max = 56950.26 # g band max light + 3\n \n tb = Table(fits.open('../data/otherSN/De2018/tables1.fit')[1].data)\n tb.rename_column('MJD' , 'mjd')\n tb['texp_rf'] = (tb['mjd'] - t_exp) / (1+z)\n tb['tmax_rf'] = (tb['mjd'] - t_max) / (1+z)\n # tb = tb[tb[\"Filt\"]==\"g \"]\n tb = tb[~np.isnan(tb['e_mag'])]\n tb.rename_column('Filt' , 'filter')\n tb.rename_column('e_mag' , 'emag')\n tb.rename_column('mag' , 'mag0')\n \n ixg = tb['filter']==\"g \"\n ixB = tb['filter']==\"B \"\n ixV = tb['filter']==\"V \"\n ixr = tb['filter']==\"r \"\n ixi = tb['filter']==\"i \"\n ixUVW1 = tb['filter']==\"UVW1\"\n ixUVW2 = tb['filter']==\"UVW2\"\n \n tb['wave'] = np.zeros(len(tb))\n tb['wave'][ixUVW2] = 2079\n tb['wave'][ixUVW1] = 2614\n tb['wave'][ixB] = 4359\n tb['wave'][ixg] = 4814\n tb['wave'][ixV] = 5430\n tb['wave'][ixr] = 6422\n tb['wave'][ixi] = 7883\n \n tb['mag0_abs'] = tb['mag0'] - dis_mod\n \n tb = tb.to_pandas()\n tb[\"texp_rf\"] = tb[\"Phase\"]\n tb = tb.drop(columns=[\"recno\", \"Phase\", \"l_mag\"])\n \"\"\"\n ix = np.any([tb['Tel'].values==\"P60 \",\n tb[\"filter\"].values=='g '], axis=0)\n tb = tb[ix]\n \"\"\"\n tb = add_datecol(tb)\n tb = add_physcol(tb)\n tt = tb[\"tmax_rf\"].values\n epochs = [\" \" for x in range(len(tt))]\n epochs = np.array(epochs)\n \"\"\"\n ix = (tt>-5.6)&(tt<-5.55)\n epochs[ix] = \"epoch 01\"\n \"\"\"\n ix = (tt>-5.55)&(tt<-5.50)\n epochs[ix] = \"epoch 02\"\n \n ix = (tt>-5.50)&(tt<-5.45)\n epochs[ix] = \"epoch 03\"\n \n ix = (tt>-5.2)&(tt<-5.0)\n epochs[ix] = \"epoch 04\"\n ix = (tt>-5.0)&(tt<-4.7)\n epochs[ix] = \"epoch 05\"\n \n ix = (tt>-4.7)&(tt<-4.5)\n epochs[ix] = \"epoch 06\"\n ix = (tt>-4.5)&(tt<-3.5)\n epochs[ix] = \"epoch 07\"\n ix = (tt>-3.5)&(tt<-2.5)\n epochs[ix] = \"epoch 08\"\n ix = (tt>-1.5)&(tt<-1)\n epochs[ix] = \"epoch 09\"\n ix = (tt>-1)&(tt<-0.82)\n epochs[ix] = \"epoch 10\"\n ix = (tt>-0.82)&(tt<-0.6)\n epochs[ix] = \"epoch 11\"\n ix = (tt>-0.5)&(tt<0.5)\n epochs[ix] = \"epoch 12\"\n ix = (tt>0.5)&(tt<1.5)\n epochs[ix] = \"epoch 13\"\n ix = (tt>1.5)&(tt<2.5)\n epochs[ix] = \"epoch 14\"\n ix = (tt>3.5)&(tt<4.5)\n epochs[ix] = \"epoch 15\"\n ix = (tt>4.5)&(tt<5)\n epochs[ix] = \"epoch 16\"\n ix = (tt>5)&(tt<5.6)\n epochs[ix] = \"epoch 17\"\n ix = (tt>5.6)&(tt<5.8)\n epochs[ix] = \"epoch 18\"\n ix = (tt>6)&(tt<7)\n epochs[ix] = \"epoch 19\"\n ix = (tt>7)&(tt<8)\n epochs[ix] = \"epoch 20\"\n ix = (tt>8)&(tt<9)\n epochs[ix] = \"epoch 21\"\n tb[\"epoch\"] = epochs\n\n if colorplt==False:\n return tb\n else:\n tb = add_datecol(tb)\n ix = np.in1d(tb[\"filter\"].values, np.array(['g ', 'r ', 'i ']))\n tb = tb[ix]\n\n dates = get_date_span(tb)\n datesave = []\n for i in range(len(dates)):\n x = dates[i]\n ix = tb[\"date\"].values == x\n tbsub = tb[ix]\n if len(tbsub)!=0:\n flts = tbsub['filter'].values\n if \"r \" in flts and np.sum(np.unique(flts))!=1:\n datesave.append(x)\n datesave = np.array(datesave)\n \n mcolor = []\n mcolor_unc = []\n mjds = []\n colorname = []\n for i in range(len(datesave)):\n x = datesave[i]\n ix = tb[\"date\"].values == x\n tbsub = tb[ix]\n gtb = tbsub[tbsub[\"filter\"].values==\"g \"]\n rtb = tbsub[tbsub[\"filter\"].values==\"r \"]\n itb = tbsub[tbsub[\"filter\"].values==\"i \"]\n if len(gtb)!=0:\n gmjds = gtb[\"mjd\"].values\n gmags = gtb[\"mag0\"].values\n gemags = gtb[\"emag\"].values\n gwtgs = 1/gemags**2\n gmag = np.sum(gmags * gwtgs) / np.sum(gwtgs)\n gmjd = np.sum(gmjds * gwtgs) / np.sum(gwtgs)\n gemag = 1/ np.sqrt(np.sum(gwtgs))\n if len(rtb)!=0:\n rmjds = rtb[\"mjd\"].values\n rmags = rtb[\"mag0\"].values\n remags = rtb[\"emag\"].values\n rwtgs = 1/remags**2\n rmag = np.sum(rmags * rwtgs) / np.sum(rwtgs)\n rmjd = np.sum(rmjds * rwtgs) / np.sum(rwtgs)\n remag = 1/ np.sqrt(np.sum(rwtgs))\n if len(itb)!=0:\n imjds = itb[\"mjd\"].values\n imags = itb[\"mag0\"].values\n iemags = itb[\"emag\"].values\n iwtgs = 1/iemags**2\n imag = np.sum(imags * iwtgs) / np.sum(iwtgs)\n imjd = np.sum(imjds * iwtgs) / np.sum(iwtgs)\n iemag = 1/ np.sqrt(np.sum(iwtgs))\n if len(gtb)!=0 and len(rtb)!=0:\n mcolor.append(gmag - rmag)\n mjds.append( 0.5 * (gmjd + rmjd) )\n mcolor_unc.append( np.sqrt(gemag**2 + remag**2) )\n colorname.append(\"gmr\")\n if len(rtb)!=0 and len(itb)!=0:\n mcolor.append(rmag - imag)\n mjds.append( 0.5 * (rmjd + imjd) )\n mcolor_unc.append( np.sqrt(remag**2 + iemag**2) )\n colorname.append(\"rmi\")\n \n ctb = Table(data = [mjds, mcolor, mcolor_unc, colorname],\n names = [\"mjd\", \"c\", \"ec\", \"cname\"])\n \n ctb['tmax_rf'] = (ctb['mjd'] - t_max) / (1+z)\n ctb = ctb.to_pandas()\n return ctb","def plot_stream(x,y,gvx,gvy,oargs,outfile):\r\n\t\r\n\tme = \"LE_Plot.plot_stream: \"\r\n\t\r\n\t## Expand out parameters\r\n\tb,X,xmax,ymax,BW,smooth = oargs\r\n\tgv = np.sqrt(gvx*gvx+gvy*gvy)\r\n\t\t\r\n\tshowplot = False\r\n\r\n\t## Smooth data\r\n\tif smooth is not 0.0:\r\n\t\tgvy = gaussian_filter(gvy, smooth)\r\n\t\tgvx = gaussian_filter(gvx, smooth)\r\n\t\tgv = gaussian_filter(gv, smooth)\r\n\toutfile += \"_sm\"+str(smooth)\r\n\t\t\r\n\t## --------------------------------------------------------------------\t\r\n\t\r\n\t## Plotting\r\n\t\r\n\tt0 = time.time()\r\n\tfs = 25\r\n\t\r\n\tfig = plt.figure(facecolor=\"white\")\r\n\tfig.suptitle(outfile)\r\n\t\r\n\t## Add subplot with exact solution\r\n\tif not BW:\r\n\t\tfrom LE_ExactHO import main as plot_exact\r\n\t\tax1 = fig.add_subplot(121,aspect=\"auto\")\r\n\t\tax2 = fig.add_subplot(122,aspect=\"auto\",sharey=ax1)\r\n\t\tplot_exact((ax2,xmax,ymax,b,False))\r\n\t\tfig.tight_layout();fig.subplots_adjust(top=0.93)\r\n\t\tprint me+\"Plotting exact\",round(time.time()-t0,1),\"seconds\"\r\n\telse:\r\n\t\tax1 = fig.add_subplot(111)\r\n\t\r\n\t## Accoutrements\t\r\n\tax1.set_xlim([-xmax,xmax]);\tax1.set_ylim([-ymax,ymax])\r\n\tax1.set_xlabel(\"$x$\",fontsize=fs);ax1.set_ylabel(\"$\\eta$\",fontsize=fs)\r\n\t## Plot wall positions if BW; plot separatrix if HO\r\n\tif BW:\tplot_walls(ax1, X, xmax,ymax,2)\r\n\telse:\tplot_separatrix(ax1, b, xmax, ymax, 2)\r\n\t\r\n\t## Line widths\r\n\tlw1 = 3.0*gv/gv.max()\r\n\t\r\n\tt0=time.time()\r\n\t## Plot absolute speed contour and streamplot\r\n\t## NOTE fudge (-) to force agreement with exact\r\n\t# ax1.contourf(xi,yi,gv, 4, alpha=0.4)\r\n\tax1.streamplot(-x,y, -gvx,gvy, arrowsize=1.8, arrowstyle=\"->\", linewidth=lw1, minlength=xmax/20)\r\n\t\t\t\r\n\tprint me+\"Plotting data \",round(time.time()-t0,1),\"seconds\"; t0=time.time()\r\n\t\t\r\n\t## Output\r\n\tfig.savefig(outfile+\".png\",facecolor=fig.get_facecolor(), edgecolor=\"none\")\r\n\tprint me+\"Plot saved\",outfile+\".png\"\r\n\tif showplot:\tplt.show()\r\n\r\n\tplt.close()\r\n\t\t\t\r\n\treturn","def plot_pretty():\n\n ts, ys, lin_model, K, us, dt_control, biass, end_time = simulate()\n plt.style.use('seaborn-deep')\n\n black = '#2B2B2D'\n red = '#E90039'\n orange = '#FF1800'\n white = '#FFFFFF'\n yellow = '#FF9900'\n\n plt.figure(figsize=(12.8, 9.6))\n plt.rcParams.update({'font.size': 16, 'text.color': white, 'axes.labelcolor': white,\n 'axes.edgecolor': white, 'xtick.color': white, 'ytick.color': white})\n\n plt.gcf().set_facecolor(black)\n\n plt.subplot(2, 3, 1)\n plt.plot(ts, ys[:, 2], color=orange)\n plt.axhline(lin_model.yd2n(K.ysp)[1], color=white)\n plt.title(r'$C_{FA}$')\n plt.xlim([0, ts[-1]])\n plt.gca().set_facecolor(black)\n\n plt.subplot(2, 3, 2)\n plt.plot(ts, ys[:, 0], color=orange)\n plt.axhline(lin_model.yd2n(K.ysp)[0], color=white)\n plt.title(r'$C_{G}$')\n plt.xlim([0, ts[-1]])\n plt.gca().set_facecolor(black)\n\n plt.subplot(2, 3, 3)\n plt.plot(ts, ys[:, 3], color=orange)\n plt.title(r'$C_{E}$')\n plt.xlim([0, ts[-1]])\n plt.gca().set_facecolor(black)\n\n plt.subplot(2, 3, 4)\n plt.plot(ts, us[:, lin_model.inputs[1]], color=red)\n plt.title(r'$F_{m, in}$')\n plt.xlim([0, ts[-1]])\n plt.gca().set_facecolor(black)\n\n plt.subplot(2, 3, 5)\n plt.plot(ts, us[:, lin_model.inputs[0]], color=red)\n plt.title(r'$F_{G, in}$')\n plt.xlim([0, ts[-1]])\n plt.gca().set_facecolor(black)\n\n plt.subplot(2, 3, 6)\n plt.plot(\n numpy.arange(dt_control, end_time, dt_control),\n biass[:, 1],\n color=red\n )\n plt.plot(\n numpy.arange(dt_control, end_time, dt_control),\n biass[:, 0],\n color=yellow\n )\n plt.legend([r'$C_{FA}$', r'$C_G$'], facecolor=black)\n plt.title('bias')\n plt.xlim([0, ts[-1]])\n plt.gca().set_facecolor(black)\n\n # plt.suptitle('Closedloop bioreactor without noise')\n plt.tight_layout(rect=[0, 0.03, 1, 0.95])\n plt.savefig('no_noise_pretty.png', transparent=True)\n plt.show()","def traces(mndata,Params,srate,imagepath):\n\t#plot high gamma traces\n\t#data should be bandpassed (todo)\n\t#resample to srate\n\tst = resample(Params[\"st\"],srate)\n\ten = resample(Params[\"en\"],srate)\n\tbl_en = resample(Params[\"bl_en\"],srate)\n\tbl_st = resample(Params[\"bl_st\"],srate)\n\tplot_tp = resample(Params[\"plot\"],srate)\n\tcue = resample(500,srate)\n\t\n\tcolors = ['red','orange','green','blue']\n\tx = np.array(range(st,en+1))\n\tf, (ax,ax2) = plt.subplots(1,2, sharex = False)\n\tax.axhline(y = 0,color = 'k',linewidth=2)\n\tax.axvline(x = 0,color='k',linewidth=2)\n\tax.axvline(x = cue,color = 'gray',linewidth = 2)\n\tax.axvline(x = cue+cue,color = 'gray',linewidth = 2)\n\tax.axvspan(cue, cue+cue, facecolor='0.5', alpha=0.25,label = 'cue')\n\n\tfor j in range(len(Params[\"conditions\"])):\n\t\tcondition = Params['conditions'][j]\n\t\ty = mndata[condition]['data']\n\t\tax.plot(x,y, label = condition,linewidth = 2,color = colors[j])\n\t\n\tax.set_ylim((-30,85))\n\tax.set_xlim(st,en)\n\tax.legend()\n\tax.xaxis.set_ticklabels(['', '0', '','500', '', '1000', '', '1500', '', '2000','','2500','', '3000'],minor=False)\n\tax.xaxis.set_ticks(range(st,en,plot_tp))\n\n\tax.set_xlabel(\"time (ms)\")\n\tax.set_ylabel(\"% change baseline\")\n\tax.set_title('Analytic Amplitude - High Gamma (70-150Hz)', fontsize = 18)\n\n\t#plot brain with elec location\n\t#brain = plt.imread(imagepath)\n\t#aa = pylab.mean(brain,2)\n\t#ax2.imshow(aa)\n\t#a2.gray()\n\n\t#brain = Image.open(imagepath)\n\t#ax2.set_axis_off()\n\t#im = plt.imshow(brain, origin = 'lower')\n\n\t#brain = _png.read_png(imagepath)\n\t#imagebox = OffsetImage(brain,zoom =5)\n\t#ab = AnnotationBbox(imagebox,)\n\n\tim = Image.open(imagepath)\n\tax2.imshow(im,aspect = 'auto',origin = 'lower')\n\tax2.set_xlim((0,750))\n\tax2.set_title('Electrode Location',fontsize = 18)\n\n\n\n\treturn f, (ax, ax2)","def plot(self):\n # -- plotting\n fig = plt.figure(figsize=figsize)\n ax = fig.add_axes([0.08, 0.12, 0.55, 0.85])\n ax.plot(self.raw['stress'][1:], self.raw['e'][1:], ls=(0, (1, 1)),\n marker='o', lw=1.5, c='k', mfc='w', label='Experimental data')\n ax.plot(self.sigmaV, self.eSigmaV, ls='', marker='|', c='r', ms=15,\n mfc='w', mew=1.5,\n label=str().join([r'$\\sigma^\\prime_\\mathrm{v_0}=$ ',\n f'{self.sigmaV:.0f} kPa']))\n # Compression index\n x4Cc = np.linspace(\n self.cleaned['stress'].iloc[-4], self.cleaned['stress'].iloc[-1])\n y4Cc = -self.idxCc * np.log10(x4Cc) + self.idxCcInt\n ax.plot(x4Cc, y4Cc, ls='-', lw=1.125, color=colors[1],\n label=str().join([r'$C_\\mathrm{c}=$', f'{self.idxCc:.3f}']))\n if self.fitCc:\n ax.plot(self.cleaned['stress'].iloc[self.maskCc],\n self.cleaned['e'].iloc[self.maskCc], ls='', marker='x',\n color=colors[1],\n label=f'Data for linear fit\\n(R$^2={self.r2Cc:.3f}$)')\n # Recompression index\n x4Cr = np.linspace(self.raw['stress'].iloc[self.maskCr].min(),\n self.raw['stress'].iloc[self.maskCr].max())\n y4Cr = -self.idxCr * np.log10(x4Cr) + self.idxCrInt\n ax.plot(x4Cr, y4Cr, ls='-', lw=1.125, color=colors[2],\n label=str().join([r'$C_\\mathrm{r}=$', f'{self.idxCr:.3f}']))\n ax.plot(self.raw['stress'].iloc[self.maskCr],\n self.raw['e'].iloc[self.maskCr], ls='', marker='+',\n color=colors[2],\n label=f'Data for linear fit\\n(R$^2={self.r2Cr:.3f}$)')\n # other details\n ax.spines['top'].set_visible(False)\n ax.spines['right'].set_visible(False)\n ax.set(xscale='log', ylabel='Void ratio, $e$',\n xlabel=str().join(['Effective vertical stress, ',\n r'$\\sigma^\\prime_\\mathrm{v}$ [kPa]']))\n ax.xaxis.set_major_formatter(mtick.ScalarFormatter())\n ax.yaxis.set_minor_locator(mtick.AutoMinorLocator())\n ax.grid(False)\n ax.legend(bbox_to_anchor=(1.125, 0.5), loc=6,\n title=r\"\\textbf{Compressibility curve}\")\n return fig","def ShowOneContour(index,all_images,all_pointing,thex0,they0,all_titles,object_name,all_expo,dir_top_img,all_filt,figname):\n plt.figure(figsize=(15,6))\n spec_index_min=100 # cut the left border\n spec_index_max=1900 # cut the right border\n star_halfwidth=70\n \n YMIN=-15\n YMAX=15\n \n figfilename=os.path.join(dir_top_img,figname) \n \n #center is approximately the one on the original raw image (may be changed)\n #x0=int(all_pointing[index][0])\n x0=int(thex0[index])\n \n \n # Extract the image \n full_image=np.copy(all_images[index])\n \n # refine center in X,Y\n star_region_X=full_image[:,x0-star_halfwidth:x0+star_halfwidth]\n \n profile_X=np.sum(star_region_X,axis=0)\n profile_Y=np.sum(star_region_X,axis=1)\n\n NX=profile_X.shape[0]\n NY=profile_Y.shape[0]\n \n X_=np.arange(NX)\n Y_=np.arange(NY)\n \n avX,sigX=weighted_avg_and_std(X_,profile_X**4) # take squared on purpose (weigh must be >0)\n avY,sigY=weighted_avg_and_std(Y_,profile_Y**4)\n \n x0=int(avX+x0-star_halfwidth)\n \n \n # find the center in Y on the spectrum\n yprofile=np.sum(full_image[:,spec_index_min:spec_index_max],axis=1)\n y0=np.where(yprofile==yprofile.max())[0][0]\n\n # cut the image in vertical and normalise by exposition time\n reduc_image=full_image[y0-20:y0+20,x0:spec_index_max]/all_expo[index] \n reduc_image[:,0:100]=0 # erase central star\n \n X_Size_Pixels=np.arange(0,reduc_image.shape[1])\n Y_Size_Pixels=np.arange(0,reduc_image.shape[0])\n Transverse_Pixel_Size=Y_Size_Pixels-int(float(Y_Size_Pixels.shape[0])/2.)\n \n # calibration in wavelength\n #grating_name=all_filt[index].replace('dia ','')\n grating_name=get_disperser_filtname(all_filt[index])\n \n lambdas=Pixel_To_Lambdas(grating_name,X_Size_Pixels,all_pointing[index],True)\n \n #if grating_name=='Ron200':\n # holo = Hologram('Ron400',verbose=True)\n #else: \n # holo = Hologram(grating_name,verbose=True)\n #lambdas=holo.grating_pixel_to_lambda(X_Size_Pixels,all_pointing[index])\n #if grating_name=='Ron200':\n # lambdas=lambdas*2.\n \n\n X,Y=np.meshgrid(lambdas,Transverse_Pixel_Size) \n T=np.transpose(reduc_image)\n \n \n plt.contourf(X, Y, reduc_image, 100, alpha=1., cmap='jet',origin='lower')\n C = plt.contour(X, Y, reduc_image , 20, colors='black', linewidth=.5,origin='lower')\n \n \n for line in LINES:\n if line == O2 or line == HALPHA or line == HBETA or line == HGAMMA:\n plt.plot([line['lambda'],line['lambda']],[YMIN,YMAX],'-',color='lime',lw=0.5)\n plt.text(line['lambda'],YMAX-3,line['label'],verticalalignment='bottom', horizontalalignment='center',color='lime', fontweight='bold',fontsize=16)\n \n \n \n plt.axis([X.min(), X.max(), Y.min(), Y.max()]); plt.grid(True)\n plt.title(all_titles[index])\n plt.grid(color='white', ls='solid')\n plt.text(200,-5.,all_filt[index],verticalalignment='bottom', horizontalalignment='center',color='yellow', fontweight='bold',fontsize=16)\n plt.xlabel('$\\lambda$ (nm)')\n plt.ylabel('pixels')\n plt.ylim(YMIN,YMAX)\n plt.xlim(0.,1200.)\n plt.savefig(figfilename)","def plot(model, center, extent, outname):\n # define model grid\n xg = np.linspace(-extent, extent, model.shape[0])\n yg = xg.copy()\n interp_func = RectBivariateSpline(xg, yg, model)\n\n x = np.array([-2, -1, 0, 1, 2]) + center[0]\n y = np.array([-2, -1, 0, 1, 2]) + center[1]\n psf = interp_func(x, y)\n\n x, y = np.meshgrid(x, y)\n f = pl.figure(figsize=(10, 5))\n\n pl.gray()\n ax1 = pl.subplot(121)\n ax1.imshow(model, interpolation='nearest', origin='lower',\n extent=(-extent, extent, -extent, extent),\n norm=LogNorm(vmin=model.min(), vmax=model.max()))\n ax1.plot(x, y, 's', mec='r', mfc='none', mew=2)\n\n pl.xlim(-2.5, 2.5)\n pl.ylim(-2.5, 2.5)\n ax2 = pl.subplot(122)\n ax2.imshow(psf, interpolation='nearest', origin='lower',\n extent=(-extent, extent, -extent, extent),\n norm=LogNorm(vmin=model.min(), vmax=model.max()))\n\n ax2.set_xticks([-2, -1, 0, 1, 2])\n ax2.set_yticks([-2, -1, 0, 1, 2])\n ax2.set_xticklabels(['%0.3f' % v for v in x[0]])\n ax2.set_yticklabels(['%0.3f' % v for v in y[:, 0]])\n\n coordsA, coordsB = \"data\", \"data\"\n pixels = np.array([[0.0, 0.0], [2., 2.], [-1., -1.]])\n locs = np.array([[-0.5, 0.5], [-0.5, 0.5], [-0.5, -0.5]])\n rads = [0.15, 0.25, -0.25]\n for i, p in enumerate(pixels):\n xy1 = p + center\n xy2 = p + locs[i]\n con = ConnectionPatch(xyA=xy2, xyB=xy1, coordsA=coordsA,\n coordsB=coordsB, axesA=ax2, axesB=ax1,\n arrowstyle=\"<-, head_length=1.2, head_width=0.8\", \n shrinkB=5,\n connectionstyle='arc3, rad=%s' % rads[i],\n color='r', lw=2)\n ax2.add_artist(con)\n ax2.plot(p[0], p[1], 's', mfc='none', mec='r', mew=2, ms=50)\n\n #pl.xlim(-2.5, 2.5)\n #pl.ylim(-2.5, 2.5)\n f.savefig(outname)","def eos_plot(mat, name, ax,spec='t', vmin=None, vmax=None,\n linthreshx=3e-5, linthreshy=0.1, nx=300, ny=350, xmax=None, ymax=None):\n\n DT_tables = [el for el in mat.tables if el.endswith('{s}_DT'.format(s=spec))]\n\n Rmax = np.min([mat.get_table(el)['Rmax'] for el in DT_tables])\n Rmin = np.max([mat.get_table(el)['Rmin'] for el in DT_tables])\n\n Tmax = np.min([mat.get_table(el)['Tmax'] for el in DT_tables])\n Tmin = np.max([mat.get_table(el)['Tmin'] for el in DT_tables])\n\n if Rmin == 0:\n Xarr = np.logspace(-5, np.log10(Rmax)-0.1, nx)\n Xarr[0] = 0\n else:\n Xarr = np.logspace(np.log10(Rmin), np.log10(Rmax)-0.1, nx)\n if Tmin == 0:\n Yarr = np.logspace(1, np.log10(Tmax)-0.1, ny)\n #Yarr[0] = 0\n else:\n Yarr = np.logspace(np.log10(Tmin)+0.1, np.log10(Tmax)-0.1, ny)\n print Yarr.min()\n\n X, Y = np.meshgrid(Xarr, Yarr, indexing='ij')\n\n if name in mat.tables:\n print 'ok'\n tab = mat.get_table(name, spec)\n F = tab(X,Y)\n if vmax is None:\n vmax = np.percentile(F, 99.5) \n if vmin is None:\n vmin = np.percentile(F[F>0], 0.5)\n\n cs = ax.pcolormesh(X, Y*K2eV, F, cmap=plt.cm.jet, norm = LogNorm(),\n vmin=vmin, vmax=vmax)\n levels = np.arange(np.log10(F[F>0].min()), int(np.log10(F.max())))\n logF = np.log10(np.where(F>0, F, F[F>0].min()))\n cl = ax.contour(X, Y/11640, logF, levels, colors='k')\n plt.clabel(cl, fontsize=10, inline=False, fmt='%1.0d', use_clabeltext=True)\n plt.title('Table {0}: {1}'.format(tab['Material_ID'], name.replace('_', '\\_')))\n cb = plt.colorbar(cs)\n if F.min()<0:\n min_label = ' (min {0:.0e} GPa)'.format(F.min())\n else:\n min_label = ''\n cb.set_label('{0} [{1}] {2}'.format(tab.label.replace('_', '\\_'),\n tab.units, min_label))\n contour_at_1 = False\n else:\n F = mat.derived_quantity[name, spec](X,Y)\n if vmax is None:\n vmax = np.percentile(F, 99) \n cs = ax.pcolormesh(X, Y*K2eV, F, vmin=0, vmax=vmax, cmap=plt.cm.jet)\n plt.title(ur'Table {0}: total: {1}'.format(\n mat.get_table(DT_tables[0], spec)['Material_ID'],\n derived_quantities[name]['description'].decode('utf8').replace('\\n','')))\n plt.colorbar(cs)\n if name in ['gamma_3']:\n cl = ax.contour(X, Y/11640, F, [1, 2,3], colors='k')\n contour_at_1 = True\n if name in ['G3', 'gamma_3']:\n contour_at_1 = False\n if contour_at_1:\n cl = ax.contour(X, Y*K2eV, F, [1], colors='white', linestyles='solid')\n\n\n cl = ax.contourf(X, Y*K2eV, F>0, [0,0.5], colors='white', hatches=['//'])\n\n ax.set_xscale('symlog', linthreshx=3e-5)\n ax.set_yscale('symlog', linthreshy=0.1)\n if xmax is None:\n ax.set_xlim(0, Xarr.max())\n else:\n ax.set_xlim(0, xmax)\n if ymax is None:\n ax.set_ylim(0, Yarr.max()*K2eV)\n else:\n ax.set_ylim(0, ymax)\n\n ax.set_xlabel(r'$\\rho$ [g.cm$^{-3}$]')\n ax.set_ylabel(r'$T$ [eV]')\n return ax","def plot_slice(self,res):\n x = np.linspace(0,1,res)\n y = np.linspace(0,1,res)\n X,Y = np.meshgrid(x,y)\n plt.figure()\n ax = plt.axes(projection = '3d')\n ax.plot_surface(X,Y,abs(self.psi)[:,:,math.floor(res/2)])\n plt.show()","def hexapodZernikeTrend(mnts='M20'):\n Tfile='/home/jghao/research/decamFocus/psf_withseeing/finerGrid_coeff_matrix/zernike_coeff_finerGrid_training.cp'\n b=p.load(open(Tfile))\n nobs = len(b)\n x = b[:,0]\n y = b[:,1]\n z = b[:,2]\n theta = b[:,3]\n phi = b[:,4]\n fwhm = b[:,5]\n e1 = b[:,6]\n e2 = b[:,7]\n thetax = theta*np.cos(np.deg2rad(phi))\n thetay = theta*np.sin(np.deg2rad(phi))\n if mnts == 'M20':\n idxBase = 9\n if mnts == 'M22real':\n idxBase = 29\n if mnts == 'M22imag':\n idxBase = 49\n idx = np.arange(14)\n zernikeName=('Piston','Tip','Tilt','Astignism','Defocus','Astignism','Trefoil','Coma','Coma','Trefoil','Ashtray','Astigm.5th','Spherical','Astigm.5th','Ashtray','16','17','18','19','20')\n for i in range(14):\n pl.figure(figsize=(21,10))\n pl.subplot(2,3,1)\n bp.bin_scatter(b[:,idxBase+idx[i]],x,nbins=20,fmt='bo',scatter=True)\n pl.ylabel('x-decenter')\n pl.xlabel(zernikeName[i+1])\n pl.ylim(-0.1,0.1)\n pl.title(mnts)\n pl.subplot(2,3,2)\n bp.bin_scatter(b[:,idxBase+idx[i]],y,nbins=20,fmt='bo',scatter=True)\n pl.ylabel('y-decenter')\n pl.xlabel(zernikeName[i+1])\n pl.title(mnts)\n pl.ylim(-0.1,0.1)\n pl.subplot(2,3,3)\n bp.bin_scatter(b[:,idxBase+idx[i]],z,nbins=20,fmt='bo',scatter=True)\n pl.ylabel('z-defocus')\n pl.xlabel(zernikeName[i+1])\n pl.title(mnts)\n pl.ylim(-0.1,0.1)\n pl.subplot(2,3,4)\n bp.bin_scatter(b[:,idxBase+idx[i]],thetax,nbins=20,fmt='bo',scatter=True)\n pl.ylabel('x-tilt')\n pl.xlabel(zernikeName[i+1])\n pl.title(mnts)\n pl.ylim(-40,40)\n pl.subplot(2,3,5)\n bp.bin_scatter(b[:,idxBase+idx[i]],thetay,nbins=20,fmt='bo',scatter=True)\n pl.ylabel('y-tilt')\n pl.xlabel(zernikeName[i+1])\n pl.title(mnts)\n pl.ylim(-40,40)\n pl.savefig(zernikeName[i+1]+mnts+'_'+str(i+1)+'.png')\n pl.close()","def plot_examples(cms):\r\n data = amp_axis\r\n\r\n fig, axs = plt.subplots(1, 2, figsize=(30, 8)) #create two plots\r\n for [ax, cmap] in zip(axs, cms):\r\n psm = ax.pcolormesh(time_axis, tof_axis, data, cmap=cmap, rasterized=True, vmin = 250) #specify axis and minimum amplitude value to show on the graph\r\n fig.colorbar(psm, ax=ax, label = 'Amplitude') #define the legend of the amplitude data\r\n \r\n ax.set_ylabel('Time of Flight [\\u03bcs]') #set label for y axis\r\n ax.set_xlabel('Time [min]') #set label for x axis\r\n \r\n ax.hlines(8.744, 0, stop_time, colors = 'white') #create two white lines for the safe operating range for ToF\r\n ax.hlines(9.555, 0, stop_time, colors = 'white') \r\n \r\n plt.show()","def plot_two_filt(self, ax, x_filts, alphas, tits):\n if self.filt_type == 'Tikhonov' or self.filt_type == 'GMRF' \\\n or self.filt_type == 'IGMRF':\n st1 = tits[0] + r', $\\alpha = %.2E$'\n st2 = tits[1] + r', $\\alpha = %.2E$'\n elif self.filt_type == 'TSVD':\n st1 = tits[0] + r', $\\alpha = %.f$'\n st2 = tits[1] + r', $\\alpha = %.f$'\n \n t = self.t\n x_true = self.x_true\n\n ax.plot(t, x_true, 'k-', label='true', lw=1.5)\n ax.plot(t, x_filts[0], 'r-', label=st1 % alphas[0], lw=1.5)\n ax.plot(t, x_filts[1], 'g-', label=st2 % alphas[1], lw=1.5)\n ax.set_title(r'Filtered Solutions')\n ax.set_xlabel(r'$t$')\n ax.set_ylabel(r'$x$')\n leg = ax.legend(loc='upper left')\n leg.get_frame().set_alpha(0.5)\n ax.grid()","def __init__(self):\n Page.__init__(self, u\"Esfera, parametrización por proyecciones estereográficas\")\n\n r = .998\n esf = ParametricPlot3D(lambda t, f: (r * sin(t) * cos(f), r * sin(t) * sin(f), r * cos(t)), (0, pi, 70), (0, 2 * pi, 70))\n# esf.setAmbientColor(_1(99,136,63))\n esf.setDiffuseColor(_1(99, 136, 63))\n esf.setSpecularColor(_1(99, 136, 63))\n\n\n def proyZm1(u, v, t1):\n \"\"\"proy desde el polo norte al plano z=-1\"\"\"\n den = u ** 2 + v ** 2 + 4\n x = u - t1 * (u - 4 * u / den)\n y = v - t1 * (v - 4 * v / den)\n z = -1 - t1 * (-2 + 8 / den)\n return (x, y, z)\n\n def proyZ1(u, v, t2):\n \"\"\"proy desde el polo sur al plano z=1\"\"\"\n den = u ** 2 + v ** 2 + 4\n x = u - t2 * (u - 4 * u / den)\n y = v - t2 * (v - 4 * v / den)\n z = 1 - t2 * (2 - 8 / den)\n return (x, y, z)\n\n stereo = ParametricPlot3D(proyZm1, (-3, 3, 70), (-3, 3, 70))\n stereo.setLinesVisible(True)\n stereo.setMeshVisible(False)\n stereo.setMeshDiffuseColor(_1(117, 55, 79))\n\n stereo2 = ParametricPlot3D(proyZ1, (-3, 3, 70), (-3, 3, 70))\n stereo2.setLinesVisible(True)\n stereo2.setMeshVisible(False)\n stereo2.setMeshDiffuseColor(_1(80, 87, 193))\n stereo2.setTransparency(0.5)\n stereo2.setTransparencyType(8)\n\n\n baseplane = BasePlane()\n baseplane.setHeight(-1.005)\n baseplane.setRange((-4, 4, 7))\n self.addChild(esf)\n self.addChild(stereo2)\n self.addChild(stereo)\n self.addChild(baseplane)\n\n params = [stereo,stereo2]\n\n ## no queremos los controles\n for i,p in enumerate(params):\n p.parameters['t%d' % (i+1)].hide()\n\n anims = [p.parameters['t%d' % (i+1)].asAnimation() for i,p in enumerate(params)]\n self.setupAnimations(anims)","def test_lightcurve_seismology_plot():\n KeplerLightCurveFile(TABBY_Q8).PDCSAP_FLUX.periodogram().plot()","def apolco(a,minfeh=-3,out=None) :\n apo=np.where((a['TELESCOPE'] == 'apo25m') & (a['RV_FEH']>minfeh) )[0]\n fig=vscat(a[apo],marker='o',density=True)\n lco=np.where((a['TELESCOPE'] == 'lco25m') & (a['RV_FEH']>minfeh) )[0]\n vscat(a[lco],fig=fig,ls=':',marker='+',density=True)\n if out is not None : \n fig[0].savefig(out+'_1.png')\n plt.close()\n i1,i2=match.match(a['APOGEE_ID'][apo],a['APOGEE_ID'][lco])\n print('matched {:d} stars'.format(len(i1)))\n fig,ax=plots.multi(1,2)\n #plots.plotp(ax[0,0],a['SNR'][apo[i1]],a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],yr=[-3,3],yt=r'$\\Delta$ VHELIO_AVG',xt='S/N')\n #plots.plotp(ax[0,1],a['SNR'][apo[i1]],a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],yr=[-50,50],yt=r'$\\Delta$ VHELIO_AVG',xt='S/N')\n #plots.plotp(ax[1,0],a['SNR'][apo[i1]],a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],yr=[-0.5,0.5],yt=r'$\\Delta$ VSCATTER',xt='S/N')\n #plots.plotp(ax[1,1],a['SNR'][apo[i1]],a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],yr=[-5,5],yt=r'$\\Delta$ VSCATTER',xt='S/N')\n ax[0].hist(a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],bins=np.arange(-0.5,0.5,0.02),histtype='step')\n ax[0].set_xlabel(r'$\\Delta$ VHELIO_AVG')\n ax[1].hist(a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],bins=np.arange(-0.25,0.25,0.01),histtype='step')\n ax[1].set_xlabel(r'$\\Delta$ VSCATTER')\n if out is not None : \n fig.savefig(out+'_2.png')\n plt.close()","def plot_tiltres_xavier(setup, mtilt, ytilt, yfit, fitmask, fwhm, slit=None, outfile=None, show_QA=False, out_dir=None):\n\n plt.rcdefaults()\n plt.rcParams['font.family']= 'times new roman'\n\n # Outfil\n method = inspect.stack()[0][3]\n if (outfile is None) and (not show_QA):\n outfile = qa.set_qa_filename(setup, method, slit=slit, out_dir=out_dir)\n\n # Setup\n plt.figure(figsize=(8, 4))\n plt.clf()\n ax = plt.gca()\n\n # Scatter plot\n res = (mtilt - ytilt) - yfit\n xmin = 0.95*np.asarray([ytilt,mtilt]).min()\n xmax = 1.05*np.asarray([ytilt,mtilt]).max()\n ax.hlines(0.0, xmin, xmax,linestyle='--', color='green')\n ax.plot(ytilt[fitmask], (res[fitmask]), 'ko', mfc='k', markersize=5.0, label='Good Points')\n ax.plot(ytilt[~fitmask],(res[~fitmask]), 'ro', mfc='r', markersize=5.0, label='Rejected Points')\n #ax.scatter(mtilt, res)\n rms = np.std(res[fitmask])\n ax.text(0.90, 0.90, 'Slit {:d}: RMS (pixels) = {:0.5f}'.format(slit, rms),\n transform=ax.transAxes, size='large', ha='right', color='black',fontsize=16)\n ax.text(0.90, 0.80, ' Slit {:d}: RMS/FWHM = {:0.5f}'.format(slit, rms/fwhm),\n transform=ax.transAxes, size='large', ha='right', color='black',fontsize=16)\n # Label\n ax.set_xlabel('Spectral Pixel')\n ax.set_ylabel('RMS (pixels)')\n ax.set_title('RMS of Each Arc Line Traced')\n ax.set_xlim((xmin,xmax))\n # Finish\n plt.tight_layout(pad=0.2, h_pad=0.0, w_pad=0.0)\n if show_QA:\n plt.show()\n\n if outfile is not None:\n plt.savefig(outfile, dpi=400)\n\n plt.close()\n plt.rcdefaults()\n\n return","def create_parametric_fin_heat_sink(\n self,\n hs_height=100,\n hs_width=100,\n hs_basethick=10,\n pitch=20,\n thick=10,\n length=40,\n height=40,\n draftangle=0,\n patternangle=10,\n separation=5,\n symmetric=True,\n symmetric_separation=20,\n numcolumn_perside=2,\n vertical_separation=10,\n matname=\"Al-Extruded\",\n center=[0, 0, 0],\n plane_enum=0,\n rotation=0,\n tolerance=1e-3,\n ):\n all_objs = self.modeler.primitives.object_names\n self[\"FinPitch\"] = self.modeler.primitives._arg_with_dim(pitch)\n self[\"FinThickness\"] = self.modeler.primitives._arg_with_dim(thick)\n self[\"FinLength\"] = self.modeler.primitives._arg_with_dim(length)\n self[\"FinHeight\"] = self.modeler.primitives._arg_with_dim(height)\n self[\"DraftAngle\"] = draftangle\n self[\"PatternAngle\"] = patternangle\n self[\"FinSeparation\"] = self.modeler.primitives._arg_with_dim(separation)\n self[\"VerticalSeparation\"] = self.modeler.primitives._arg_with_dim(vertical_separation)\n self[\"HSHeight\"] = self.modeler.primitives._arg_with_dim(hs_height)\n self[\"HSWidth\"] = self.modeler.primitives._arg_with_dim(hs_width)\n self[\"HSBaseThick\"] = self.modeler.primitives._arg_with_dim(hs_basethick)\n if numcolumn_perside > 1:\n self[\"NumColumnsPerSide\"] = numcolumn_perside\n if symmetric:\n self[\"SymSeparation\"] = self.modeler.primitives._arg_with_dim(symmetric_separation)\n # ipk['PatternDirection'] = 'Y'\n # ipk['LengthDirection'] = 'X'\n # ipk['HeightDirection'] = 'Z'\n self[\"Tolerance\"] = self.modeler.primitives._arg_with_dim(tolerance)\n\n self.modeler.primitives.create_box(\n [\"-HSWidth/200\", \"-HSHeight/200\", \"-HSBaseThick\"],\n [\"HSWidth*1.01\", \"HSHeight*1.01\", \"HSBaseThick+Tolerance\"],\n \"HSBase\",\n matname,\n )\n Fin_Line = []\n Fin_Line.append(self.Position(0, 0, 0))\n Fin_Line.append(self.Position(0, \"FinThickness\", 0))\n Fin_Line.append(self.Position(\"FinLength\", \"FinThickness + FinLength*sin(PatternAngle*3.14/180)\", 0))\n Fin_Line.append(self.Position(\"FinLength\", \"FinLength*sin(PatternAngle*3.14/180)\", 0))\n Fin_Line.append(self.Position(0, 0, 0))\n self.modeler.primitives.create_polyline(Fin_Line, cover_surface=True, name=\"Fin\")\n Fin_Line2 = []\n Fin_Line2.append(self.Position(0, \"sin(DraftAngle*3.14/180)*FinThickness\", \"FinHeight\"))\n Fin_Line2.append(self.Position(0, \"FinThickness-sin(DraftAngle*3.14/180)*FinThickness\", \"FinHeight\"))\n Fin_Line2.append(\n self.Position(\n \"FinLength\",\n \"FinThickness + FinLength*sin(PatternAngle*3.14/180)-sin(DraftAngle*3.14/180)*FinThickness\",\n \"FinHeight\",\n )\n )\n Fin_Line2.append(\n self.Position(\n \"FinLength\", \"FinLength*sin(PatternAngle*3.14/180)+sin(DraftAngle*3.14/180)*FinThickness\", \"FinHeight\"\n )\n )\n Fin_Line2.append(self.Position(0, \"sin(DraftAngle*3.14/180)*FinThickness\", \"FinHeight\"))\n self.modeler.primitives.create_polyline(Fin_Line2, cover_surface=True, name=\"Fin_top\")\n self.modeler.connect([\"Fin\", \"Fin_top\"])\n self.modeler.primitives[\"Fin\"].material_name = matname\n # self.modeler.thicken_sheet(\"Fin\",'-FinHeight')\n num = int((hs_width / (separation + thick)) / (max(1 - math.sin(patternangle * 3.14 / 180), 0.1)))\n self.modeler.duplicate_along_line(\"Fin\", self.Position(0, \"FinSeparation+FinThickness\", 0), num, True)\n self.modeler.duplicate_along_line(\"Fin\", self.Position(0, \"-FinSeparation-FinThickness\", 0), num / 4, True)\n\n all_names = self.modeler.primitives.object_names\n list = [i for i in all_names if \"Fin\" in i]\n if numcolumn_perside > 0:\n self.modeler.duplicate_along_line(\n list,\n self.Position(\"FinLength+VerticalSeparation\", \"FinLength*sin(PatternAngle*3.14/180)\", 0),\n \"NumColumnsPerSide\",\n True,\n )\n\n all_names = self.modeler.primitives.object_names\n list = [i for i in all_names if \"Fin\" in i]\n self.modeler.split(list, self.CoordinateSystemPlane.ZXPlane, \"PositiveOnly\")\n all_names = self.modeler.primitives.object_names\n list = [i for i in all_names if \"Fin\" in i]\n self.modeler.create_coordinate_system(self.Position(0, \"HSHeight\", 0), mode=\"view\", view=\"XY\", name=\"TopRight\")\n\n self.modeler.split(list, self.CoordinateSystemPlane.ZXPlane, \"NegativeOnly\")\n\n if symmetric:\n\n self.modeler.create_coordinate_system(\n self.Position(\"(HSWidth-SymSeparation)/2\", 0, 0),\n mode=\"view\",\n view=\"XY\",\n name=\"CenterRightSep\",\n reference_cs=\"TopRight\",\n )\n\n self.modeler.split(list, self.CoordinateSystemPlane.YZPlane, \"NegativeOnly\")\n self.modeler.create_coordinate_system(\n self.Position(\"SymSeparation/2\", 0, 0),\n mode=\"view\",\n view=\"XY\",\n name=\"CenterRight\",\n reference_cs=\"CenterRightSep\",\n )\n self.modeler.duplicate_and_mirror(list, self.Position(0, 0, 0), self.Position(1, 0, 0))\n Center_Line = []\n Center_Line.append(self.Position(\"-SymSeparation\", \"Tolerance\", \"-Tolerance\"))\n Center_Line.append(self.Position(\"SymSeparation\", \"Tolerance\", \"-Tolerance\"))\n Center_Line.append(self.Position(\"VerticalSeparation\", \"-HSHeight-Tolerance\", \"-Tolerance\"))\n Center_Line.append(self.Position(\"-VerticalSeparation\", \"-HSHeight-Tolerance\", \"-Tolerance\"))\n Center_Line.append(self.Position(\"-SymSeparation\", \"Tolerance\", \"-Tolerance\"))\n self.modeler.primitives.create_polyline(Center_Line, cover_surface=True, name=\"Center\")\n self.modeler.thicken_sheet(\"Center\", \"-FinHeight-2*Tolerance\")\n all_names = self.modeler.primitives.object_names\n list = [i for i in all_names if \"Fin\" in i]\n self.modeler.subtract(list, \"Center\", False)\n else:\n self.modeler.create_coordinate_system(\n self.Position(\"HSWidth\", 0, 0), mode=\"view\", view=\"XY\", name=\"BottomRight\", reference_cs=\"TopRight\"\n )\n self.modeler.split(list, self.CoordinateSystemPlane.YZPlane, \"NegativeOnly\")\n all_objs2 = self.modeler.primitives.object_names\n list_to_move = [i for i in all_objs2 if i not in all_objs]\n center[0] -= hs_width / 2\n center[1] -= hs_height / 2\n center[2] += hs_basethick\n self.modeler.set_working_coordinate_system(\"Global\")\n self.modeler.translate(list_to_move, center)\n if plane_enum == self.CoordinateSystemPlane.XYPlane:\n self.modeler.rotate(list_to_move, self.CoordinateSystemAxis.XAxis, rotation)\n elif plane_enum == self.CoordinateSystemPlane.ZXPlane:\n self.modeler.rotate(list_to_move, self.CoordinateSystemAxis.XAxis, 90)\n self.modeler.rotate(list_to_move, self.CoordinateSystemAxis.YAxis, rotation)\n elif plane_enum == self.CoordinateSystemPlane.YZPlane:\n self.modeler.rotate(list_to_move, self.CoordinateSystemAxis.YAxis, 90)\n self.modeler.rotate(list_to_move, self.CoordinateSystemAxis.ZAxis, rotation)\n self.modeler.unite(list_to_move)\n self.modeler.primitives[list_to_move[0]].name = \"HeatSink1\"\n return True","def plot(self):\n\t\tself.plotOfSpect()","def plot_tiltres_joe(setup, mtilt, ytilt, yfit, fitmask, fwhm, slit=None, outfile=None, show_QA=False, out_dir=None):\n\n plt.rcdefaults()\n plt.rcParams['font.family']= 'times new roman'\n\n # Outfil\n method = inspect.stack()[0][3]\n if (outfile is None) and (not show_QA):\n outfile = qa.set_qa_filename(setup, method, slit=slit, out_dir=out_dir)\n\n # Setup\n plt.figure(figsize=(10, 6))\n plt.clf()\n ax = plt.gca()\n\n # Scatter plot\n res = (mtilt - yfit)\n xmin = 0.95*np.asarray([ytilt,mtilt]).min()\n xmax = 1.05*np.asarray([ytilt,mtilt]).max()\n ax.hlines(0.0, xmin, xmax,linestyle='--', color='green')\n ax.plot(ytilt[fitmask], (res[fitmask]), 'ko', mfc='k', markersize=5.0, label='Good Points')\n ax.plot(ytilt[~fitmask],(res[~fitmask]), 'ro', mfc='r', markersize=5.0, label='Rejected Points')\n #ax.scatter(mtilt, res)\n rms = np.std(res[fitmask])\n ax.text(0.90, 0.90, 'Slit {:d}: RMS (pixels) = {:0.5f}'.format(slit, rms),\n transform=ax.transAxes, size='large', ha='right', color='black',fontsize=16)\n ax.text(0.90, 0.80, ' Slit {:d}: RMS/FWHM = {:0.5f}'.format(slit, rms/fwhm),\n transform=ax.transAxes, size='large', ha='right', color='black',fontsize=16)\n # Label\n ax.set_xlabel('Spectral Pixel')\n ax.set_ylabel('RMS (pixels)')\n ax.set_title('RMS of Each Arc Line Traced')\n ax.set_xlim((xmin,xmax))\n # Finish\n plt.tight_layout(pad=0.2, h_pad=0.0, w_pad=0.0)\n if show_QA:\n plt.show()\n\n if outfile is not None:\n plt.savefig(outfile, dpi=400)\n\n plt.close()\n plt.rcdefaults()\n\n return","def grayplot_NH(QC,stage):\n\n\n #set some constants\n numpts=QC['GMtcs'].shape[1] #number of timepoints\n rightsignallim = np.arange(-20,21,20) #GS, main plot signal limits - 2% assuming mode 1000 normalization\n leftsignallim = np.arange(0,21,10) #DVars limits\n rylimz=[np.min(rightsignallim),np.max(rightsignallim)]\n lylimz=[np.min(leftsignallim),np.max(leftsignallim)]\n FDmult = 10 #multiplier to FD to get in range of DVars values\n FDthresh = 0.2 #FD threshold to mark frame for scrubbing (use 0.1 for filtered FD)\n\n #compute data quality metrics -- CG: compute by hand to better understand (separated here for practice)\n [mvm,ddt_mvm,FD] = compute_FD(QC['MVM'])\n DVars = compute_DVARS(QC['GMtcs'][:,:,stage]) # compute DVARs for a particular processing stage\n GS = compute_GS(QC['GMtcs'][:,:,stage]) # compute global signal for a particular processing stage\n\n #create plot\n fig = plt.figure(figsize=(10,10),constrained_layout = True)\n gs = GridSpec(9,1,figure=fig)\n\n #plot individual mvm params\n ax1 = fig.add_subplot(gs[0:2])\n pointindex = np.arange(1,numpts+1)\n plt.plot(pointindex,mvm)\n\n plt.xlim([0, numpts])\n plt.ylim([-1.5, 1.5])\n plt.ylabel('mvm-XYZPYR')\n\n #Next, plot FD, DVARS and GS on the same plot\n ax2a = fig.add_subplot(gs[2:4])\n ax2b = ax2a.twinx()\n ax2a.plot(pointindex,DVars,color=[0,0,1],alpha=0.5)\n ax2b.plot(pointindex,GS,color=[0,1,0],alpha=0.5)\n ax2a.plot(pointindex,FD*FDmult,color=[1,0,0],alpha=0.5)\n ax2a.hlines(FDthresh*FDmult,pointindex[0],pointindex[-1],'k',alpha=0.5)\n \n plt.xlim([0, numpts])\n ax2a.set_ylim(lylimz)\n ax2a.set_yticks(leftsignallim)\n ax2b.set_ylim(rylimz)\n ax2b.set_yticks(rightsignallim)\n ax2a.set_ylabel('R:FD*' + str(FDmult) +' B:DV G:GS')\n\n #next plot gray matter signal\n ax3 = fig.add_subplot(gs[4:8])\n new_GMtcs = QC['GMtcs'][:,:,stage]\n plt.imshow(new_GMtcs,cmap='gray',vmin=-20,vmax=20,aspect='auto') #default: showing 2% signal on mode 1000 norm\n plt.ylabel('GRAY')\n\n #finally, plot WM and CSF ts\n ax4 = fig.add_subplot(gs[8:])\n new_WMCSF = np.vstack((QC['WMtcs'][:,:,stage],QC['CSFtcs'][:,:,stage]))\n plt.imshow(new_WMCSF,cmap='gray',vmin=-20,vmax=20,aspect='auto')\n plt.ylabel('WM CSF')\n plt.xlabel('frames')\n\n return fig","def plotSpectrum(inp,xrng=[],yrng=[],xlabel='',ylabel='',xlog=False,ylog=False,grid=False,\n legend=[],legend_location='upper right',fontscale=1,legend_fontscale=1,title='',\n color='k',colormap=None,linestyle='-',linewidth=1.5,alpha=1.,\n show_noise=True,color_noise='k',linestyle_noise='-',linewidth_noise=1.5,alpha_noise=0.5,\n comparison=None,color_comparison='grey',linestyle_comparison='-',linewidth_comparison=1.5,alpha_comparison=1,\n residual=False,color_residual='m',linestyle_residual='-',linewidth_residual=1.5,alpha_residual=0.5,\n telluric=False,color_telluric='grey',linestyle_telluric='-',linewidth_telluric=1.5,alpha_telluric=0.2,\n features=[],mdwarf=False,ldwarf=False,tdwarf=False,young=False,binary=False,nsamples=100,\n band=[],band_color='k',band_alpha=0.2,band_label='',band_label_position='bottom',band_width=0.1,\n show_zero=True,stack=0.,zeropoint=0.,color_zero='k',linestyle_zero=':',linewidth_zero=1.5,alpha_zero=0.3,\n inset=False,inset_xrange=[],inset_yrange=[],inset_position=[0.65,0.60,0.20,0.20],inset_features=False,\n output='',multiplot=False,multipage=False,layout=[1,1],figsize=[],tight=True,\n interactive=False,**kwargs):\n\n# keyword parameters (for backward compatability)\n for k in ['showZero','showzero']: show_zero=kwargs.get(k,show_zero)\n for k in ['showNoise','noise','uncertainty','shownoise','showuncertainty','show_uncertainty']: show_noise=kwargs.get(k,show_noise)\n\n for k in ['line_style','lineStyle','ls','linestyles','line_styles']: linestyle=kwargs.get(k,linestyle)\n for k in ['line_width','lineWidth','width','lw','linewidths','line_widths']: linewidth=kwargs.get(k,linewidth)\n for k in ['colors','colour','colours']: color=kwargs.get(k,color)\n for k in ['colorScheme','color_scheme','colorscheme','colorMap','color_map']: colormap=kwargs.get(k,colormap)\n\n for k in ['colornoise','colorNoise','colorUnc','coloruncertainty','color_uncertainty','colorUncertainty']: color_noise=kwargs.get(k,color_noise)\n for k in ['linestylenoise','line_style_noise','linestyleNoise']: linestyle_noise=kwargs.get(k,linestyle_noise)\n for k in ['linewidthnoise','linewidthNoise','line_width_noise']: linewidth_noise=kwargs.get(k,linewidth_noise)\n for k in ['alphanoise','alphaNoise']: alpha_noise=kwargs.get(k,alpha_noise)\n\n for k in ['colorzero','colorZero']: color_zero=kwargs.get(k,color_zero)\n for k in ['linestylezero','line_style_zero','linestyleZero']: linestyle_zero=kwargs.get(k,linestyle_zero)\n for k in ['linewidthzero','linewidthZero','line_width_zero']: linewidth_zero=kwargs.get(k,linewidth_zero)\n for k in ['alphazero','alphaZero']: alpha_zero=kwargs.get(k,alpha_zero)\n\n for k in ['colorcomparison','colorComparison']: color_comparison=kwargs.get(k,color_comparison)\n for k in ['linestyleComparison','line_style_comparison','linestylecomparison']: linestyle_comparison=kwargs.get(k,linestyle_comparison)\n for k in ['linewidthcomparison','linewidthComparison','line_width_comparison']: linewidth_comparison=kwargs.get(k,linewidth_comparison)\n for k in ['alphacomparison','alphaComparison']: alpha_comparison=kwargs.get(k,alpha_comparison)\n\n for k in ['colorresidual','colorResidual']: color_residual=kwargs.get(k,color_residual)\n for k in ['linestyleresidual','line_style_residual','linestyleResidual']: linestyle_residual=kwargs.get(k,linestyle_residual)\n for k in ['linewidthresidual','linewidthResidual','line_width_residual']: linewidth_residual=kwargs.get(k,linewidth_residual)\n for k in ['alpharesidual','alphaResidual']: alpha_residual=kwargs.get(k,alpha_residual)\n\n for k in ['bands']: band=kwargs.get(k,band)\n if len(band) == 2 and isinstance(band[0],list) == False: band = [band]\n for k in ['bandcolors','bandcolor','band_colors']: band_color=kwargs.get(k,band_color)\n for k in ['bandalphas','band_alphas','bandalpha']: band_alpha=kwargs.get(k,band_alpha)\n for k in ['band_labels','bandlabel','bandlabels']: band_label=kwargs.get(k,band_label)\n for k in ['band_label_positions','bandlabelposition','bandlabelpositions']: band_label_position=kwargs.get(k,band_label_position)\n for k in ['bandwidth','bandwidths','band_widths']: band_width=kwargs.get(k,band_width)\n for par in [band_color,band_alpha,band_label,band_label_position,band_width]:\n if not isinstance(par,list): par = [par]*len(band)\n if len(par) < len(band): par.extend([par[-1] for x in range(len(band)-len(par))])\n\n for k in ['legends','label','labels']: legend=kwargs.get(k,legend)\n if not isinstance(legend,list): legend = [legend]\n for k in ['legendfontscale','legendFontscale']: legend_fontscale=kwargs.get(k,legend_fontscale)\n legend_fontscale=legend_fontscale*fontscale\n for k in ['legendLocation','legendlocation','labelLocation','labellocation','label_location']: legend_location=kwargs.get(k,legend_location)\n\n for k in ['xrange','x_range','wave_range','wrange','wrng']: xrng=kwargs.get(k,xrng)\n if not isinstance(xrng,list): xrng = [xrng]\n for k in ['yrange','y_range','flux_range','frange','frng']: yrng=kwargs.get(k,yrng)\n if not isinstance(yrng,list): yrng = [yrng]\n\n for k in ['multilayout','multiLayout','multi_layout']: layout=kwargs.get(k,layout)\n for k in ['file','filename']: output=kwargs.get(k,output)\n if not isinstance(output,str): output=''\n filetype = '.pdf'\n if output!='': filetype=output.split('.')[-1]\n\n if comparison != None and isinstance(comparison,splat.Spectrum) == False and isinstance(comparison,list) == False: \n print('plotSpectrum() Warning: comparison spectrum should be a splat Spectrum object, you passed {}'.format(comparison))\n comparison = None\n\n# some plotting constants\n xlabel_default = 'Wavelength'\n ylabel_deafult = 'Flux'\n\n# telluric bands in micron\n telluric_bands = [[1.1,1.2]*u.micron,[1.3,1.5]*u.micron,[1.75,2.0]*u.micron]\n\n# assign features by group\n if not isinstance(features,list): features = [features]\n if ldwarf==True or mdwarf==True: features.extend(['k','na','feh','tio','co','h2o','h2'])\n if tdwarf==True: features.extend(['k','ch4','h2o','h2'])\n if young==True: features.extend(['vo'])\n if binary==True: features.extend(['sb'])\n\n# clean repeats in features while maintaining order - set does not do this\n if len(features)>0:\n fea = []\n for i in features:\n if i not in fea: fea.append(i)\n features = fea\n\n\n# if a list is passed, use this list\n splist = copy.deepcopy(inp)\n if isinstance(splist,list) == False: splist = [splist]\n \n# set up for multiplot\n if len(splist) == 1: multiplot = False\n \n# array of lists => force multiplot\n elif len(splist) > 1 and isinstance(splist[0],list) == True: multiplot = True\n else: pass\n\n# reformat array of spectra of multiplot is used (i.e., user forgot to set)\n if multiplot == True and isinstance(splist[0],splat.Spectrum):\n splist = [[s] for s in splist]\n\n elif multiplot == False and isinstance(splist[0],splat.Spectrum):\n splist = [splist]\n \n# flatten array if multiplot is not set\n elif multiplot == False and isinstance(splist[0],list) and len(splist) > 1:\n splist = [[item for sublist in splist for item in sublist]] # flatten\n else: pass\n\n# total number of spectra - use to assign default legends\n allsps = [item for sublist in splist for item in sublist] # Total number of spectra\n if len(legend) == 0: legend=[sp.name for sp in allsps]\n if len(legend) < len(allsps):\n legend.extend([allsps[i].name for i in range(len(legend),len(allsps)-len(legend))])\n \n\n# now run a loop through the input subarrays\n plt.close('all')\n\n# set up here for multiple file output\n nplot = 1\n if multipage == True or multiplot == True:\n nplot = layout[0]*layout[1]\n numpages = int(len(splist) / nplot) + 1\n if (len(splist) % nplot == 0):\n numpages -= 1\n fig = []\n \n if multipage == True and filetype.lower() == 'pdf':\n pdf_pages = PdfPages(output)\n \n if multipage == False:\n if len(splist) > 1:\n filebase = output.replace('.{}'.format(filetype),'')\n files = [filebase+'{}.'.format(i+1)+filetype for i in numpy.arange(len(splist))]\n else:\n files = [output]\n\n pg_n = 0 # page counter\n plt_n = 0 # plot per page counter\n lg_n = 0 # legend per plot counter\n\n for plts,sp in enumerate(splist):\n# set specific plot parameters\n if not isinstance(sp[0],splat.Spectrum):\n raise ValueError('\\nInput to plotSpectrum has wrong format:\\n\\n{}\\n\\n'.format(sp[0]))\n\n# set up plotting defaults for the list of spectra - REPLACE THIS\n if not isinstance(zeropoint,list): zeropoint = [zeropoint]*len(sp)\n if len(zeropoint) < len(sp): zeropoint.extend([zeropoint[-1] for x in range(len(sp)-len(zeropoint))])\n if not isinstance(color,list): color = [color]*len(sp)\n if len(color) < len(sp): color.extend([color[-1] for x in range(len(sp)-len(color))])\n if not isinstance(linestyle,list): linestyle = [linestyle]*len(sp)\n if len(linestyle) < len(sp): linestyle.extend([linestyle[-1] for x in range(len(sp)-len(linestyle))])\n if not isinstance(linewidth,list): linewidth = [linewidth]*len(sp)\n if len(linewidth) < len(sp): linewidth.extend([linewidth[-1] for x in range(len(sp)-len(linewidth))])\n if not isinstance(alpha,list): alpha = [alpha]*len(sp)\n if len(alpha) < len(sp): alpha.extend([alpha[-1] for x in range(len(sp)-len(alpha))])\n if not isinstance(color_noise,list): color_noise = [color_noise]*len(sp)\n if len(color_noise) < len(sp): color_noise.extend([color_noise[-1] for x in range(len(sp)-len(color_noise))])\n if not isinstance(linestyle_noise,list): linestyle_noise = [linestyle_noise]*len(sp)\n if len(linestyle_noise) < len(sp): linestyle_noise.extend([linestyle_noise[-1] for x in range(len(sp)-len(linestyle_noise))])\n if not isinstance(linewidth_noise,list): linewidth_noise = [linewidth_noise]*len(sp)\n if len(linewidth_noise) < len(sp): linewidth_noise.extend([linewidth_noise[-1] for x in range(len(sp)-len(linewidth_noise))])\n if not isinstance(alpha_noise,list): alpha_noise = [alpha_noise]*len(sp)\n if len(alpha_noise) < len(sp): alpha_noise.extend([alpha_noise[-1] for x in range(len(sp)-len(color_noise))])\n if not isinstance(color_comparison,list): color_comparison = [color_comparison]*len(sp)\n if len(color_comparison) < len(sp): color_comparison.extend([color_comparison[-1] for x in range(len(sp)-len(color_comparison))])\n if not isinstance(linestyle_comparison,list): linestyle_comparison = [linestyle_comparison]*len(sp)\n if len(linestyle_comparison) < len(sp): linestyle_comparison.extend([linestyle_comparison[-1] for x in range(len(sp)-len(linestyle_comparison))])\n if not isinstance(linewidth_comparison,list): linewidth_comparison = [linewidth_comparison]*len(sp)\n if len(linewidth_comparison) < len(sp): linewidth_comparison.extend([linewidth_comparison[-1] for x in range(len(sp)-len(linewidth_comparison))])\n if not isinstance(alpha_comparison,list): alpha_comparison = [alpha_comparison]*len(sp)\n if len(alpha_comparison) < len(sp): alpha_comparison.extend([alpha_comparison[-1] for x in range(len(sp)-len(alpha_comparison))])\n\n# settings that work if the spectrum was read in as legitmate Spectrum object\n try:\n xlabel = kwargs.get('xlabel','{} ({})'.format(sp[0].wave_label,sp[0].wave.unit))\n ylabel = kwargs.get('ylabel','{} ({})'.format(sp[0].flux_label,sp[0].flux.unit))\n except:\n xlabel = kwargs.get('xlabel',xlabel_default)\n ylabel = kwargs.get('ylabel',ylabel_default)\n# initial plot range\n bound = [numpy.nanmin(sp[0].wave.value),numpy.nanmax(sp[0].wave.value)]\n ymax = [numpy.nanquantile(s.flux.value,0.98) for s in sp]\n bound.extend(numpy.array([-0.02,1.3])*numpy.nanmax(ymax)+\\\n numpy.array([numpy.nanmin(zeropoint),numpy.nanmax(zeropoint)+stack*(len(sp)-1)]))\n\n# set colormap if provided\n if colormap != None:\n values = numpy.arange(len(sp))\n color_map = plt.get_cmap(colormap)\n norm = colmap.Normalize(vmin=0, vmax=1.0*values[-1])\n scalarMap = cm.ScalarMappable(norm=norm, cmap=color_map)\n for i in range(len(sp)): color[i] = scalarMap.to_rgba(values[i])\n\n# GENERATE PLOTS\n if multiplot == True or multipage == True:\n plt_n = plts % nplot\n if (plt_n == 0):\n fig.append(plt.figure())\n pg_n += 1\n ax = fig[pg_n-1].add_subplot(layout[0], layout[1], plt_n+1)\n \n# plotting a single plot with all spectra\n else:\n plt.close('all')\n plt_n = 0\n fig = []\n if len(figsize)>0: fig.append(plt.figure(figsize=figsize))\n else: fig.append(plt.figure())\n ax = fig[0].add_subplot(111)\n \n for ii, a in enumerate(sp):\n# zeropoint and stack\n flx = [i+zeropoint[ii] for i in a.flux.value]\n if stack > 0: flx = [f + (len(sp)-ii-1)*stack for f in flx]\n ax.plot(a.wave.value,flx,color=color[ii],linestyle=linestyle[ii], lw=linewidth[ii], alpha=alpha[ii], zorder = 10, label = legend[lg_n]) \n\n# add comparison\n if comparison != None:\n# zeropoint and stack\n cflx = [i+zeropoint[ii] for i in comparison.flux.value]\n if stack > 0: cflx = [f + (len(sp)-ii-1)*stack for f in cflx]\n ax.plot(comparison.wave.value,cflx,color=color_comparison[ii],linestyle=linestyle_comparison[ii], lw=linewidth_comparison[ii], alpha=alpha_comparison[ii], zorder = 10)\n \n# add residual\n if residual == True and len(sp) == 2:\n # Save flux values from first spectrum\n if ii == 0:\n flx0 = [f - (len(sp)-ii-1)*stack for f in flx]\n \n # Subtract fluxes and plot\n elif ii == 1:\n res = [flx0[f_n] - f for f_n, f in enumerate(flx)]\n ax.plot(a.wave.value, res, alpha = alpha_residual[ii], color = color_residual[ii], linsetyle=linestyle_residual[ii], lw=linewidth_residual[ii])\n \n # Fix bound[2] if residual goes below 0\n if numpy.nanmin(res) < bound[2]:\n b0 = numpy.argmin(a.wave.value[a.wave.value > bound[0]])\n b1 = numpy.argmax(a.wave.value[a.wave.value < bound[1]])\n bound[2] = numpy.nanmin(res[b0:b1])\n\n# noise\n if show_noise == True:\n ns = [i+zeropoint[ii] for i in a.noise.value]\n ax.plot(a.wave.value,ns,color=color_noise[ii],linestyle=linestyle_noise[ii],alpha=alpha_noise[ii], lw=linewidth_noise[ii], zorder = 10)\n\n# zeropoint\n if show_zero == True:\n ze = numpy.ones(len(a.flux))*zeropoint[ii]\n ax.plot(a.wave.value,ze,color=color[ii],linestyle=linestyle_zero,alpha=alpha_zero,lw=linewidth_zero, zorder = 10)\n\n# save maximum flux among all spectra for plotting\n# THIS IS VERY SLOW AND IT WOULD BE BETTER TO FIND AN ALTERNATE APPROACH\n if len(features)>0:\n f = interp1d(a.wave,flx,bounds_error=False,fill_value=0.)\n if ii == 0: \n wvmax = numpy.linspace(bound[0],bound[1],nsamples)\n flxmax = numpy.array(f(wvmax))\n else: flxmax = numpy.maximum(flxmax,numpy.array(f(wvmax)))\n\n# legend counter\n lg_n = lg_n + 1 # Increment legend\n\n\n# label features\n# THIS NEEDS TO BE FIXED WITH GRETEL'S STUFF\n if len(features) > 0:\n yoff = 0.02*(bound[3]-bound[2]) # label offset\n fontsize = int((10-numpy.nanmin([(layout[0]*layout[1]-1),6]))*fontscale)\n for ftr in features:\n ftr = ftr.lower()\n if ftr in FEATURE_LABELS:\n ftrc = checkDict(ftr,FEATURE_LABELS)\n if ftrc != False:\n for ii,waveRng in enumerate(FEATURE_LABELS[ftrc]['wavelengths']):\n wRng = waveRng.to(sp[0].wave.unit).value\n# features must be contained in plot range (may change this)\n if numpy.nanmin(wRng) > bound[0] and numpy.nanmax(wRng) < bound[1]:\n wfeature = numpy.where(numpy.logical_and(wvmax >= numpy.nanmin(wRng),wvmax <= numpy.nanmax(wRng)))\n if len(wvmax[wfeature]) == 0: wfeature = numpy.argmax(numpy.absolute(wvmax-numpy.nanmedian(wRng)))\n y = numpy.nanmax(flxmax[wfeature])+yoff\n flxmax[wfeature] = flxmax[wfeature]+3.*yoff\n\n if FEATURE_LABELS[ftrc]['type'] == 'band':\n ax.plot(wRng,[y+yoff]*2,color='k',linestyle='-')\n ax.plot([wRng[0]]*2,[y,y+yoff],color='k',linestyle='-')\n ax.text(numpy.mean(wRng),y+1.5*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=fontsize)\n else:\n for w in wRng: ax.plot([w]*2,[y,y+yoff],color='k',linestyle='-')\n ax.text(numpy.mean(wRng),y+1.5*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=fontsize)\n bound[3] = numpy.nanmax([numpy.nanmax(flxmax)+2.*yoff,bound[3]])\n\n# add grid\n if grid == True: ax.grid() \n\n# axis labels \n fontsize = (numpy.round(numpy.max([13./((layout[0]*layout[1])**0.33),5]))) * fontscale\n legend_fontsize = (13-numpy.min([(layout[0]*layout[1]-1),8])) * legend_fontscale\n ax.set_xlabel(xlabel, fontsize = fontsize)\n ax.set_ylabel(ylabel, fontsize = fontsize)\n ax.tick_params(axis='x', labelsize=fontsize)\n ax.tick_params(axis='y', labelsize=fontsize)\n\n# add title\n if title!='': ax.set_title(title)\n\n# log scale?\n if kwargs.get('xlog',False): ax.set_xscale('log',nonposx='clip')\n if kwargs.get('ylog',False): ax.set_yscale('log',nonposy='clip')\n\n# place legend\n if len(legend) > 0:\n if legend_location == 'outside':\n box = ax.get_position()\n ax.set_position([box.x0, box.y0 + box.height * 0.15, box.width * 0.7, box.height * 0.7])\n ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), prop={'size':legend_fontsize})\n else:\n ax.legend(loc=legend_location, prop={'size':legend_fontsize})\n bound[3] = bound[3]+0.1*(bound[3]-bound[2]) # extend axis for in-plot legends\n\n# overplot telluric absorption\n if telluric == True:\n yoff = 0.02*(bound[3]-bound[2]) # label offset\n for waveRng in telluric_bands:\n wR = waveRng.to(sp[0].wave.unit).value\n rect = patches.Rectangle((wR[0],bound[2]),wR[1]-wR[0],bound[3]-bound[2],facecolor=color_telluric,alpha=alpha_telluric,color=color_telluric)\n ax.add_patch(rect)\n ax.text(numpy.mean(wR),bound[2]+3*yoff,r'$\\oplus$',horizontalalignment='center',fontsize=fontsize)\n\n# overplot color swaths for pre-specified bands\n if len(band) > 0:\n for i,b in enumerate(band):\n if not isinstance(b,list): \n try: b = [float(b)-0.5*band_width,float(b)+0.5*band_width]\n except:\n print('\\nWarning: plotSpectrum bands variables should be array of 2-element arrays; you passed {}'.format(band))\n b = [0.,0.]\n rect = patches.Rectangle((b[0],bound[2]),b[1]-b[0],bound[3]-bound[2],facecolor=band_color[i],color=band_color[i],alpha=band_alpha[i])\n ax.add_patch(rect)\n if band_label_position[i].lower() == 'top':\n ax.text(numpy.mean(b),bound[3]-3*yoff,band_label[i],horizontalalignment='center',fontsize=fontsize)\n elif band_label_position[i].lower() == 'middle':\n ax.text(numpy.mean(b),0.5*(bound[2]+bound[3]),band_label[i],horizontalalignment='center',fontsize=fontsize)\n else:\n ax.text(numpy.mean(b),bound[2]+3*yoff,band_label[i],horizontalalignment='center',fontsize=fontsize)\n\n# place inset - RIGHT NOW ONLY SETTING LIMITS WITH FIRST SPECTRUM IN LIST\n if inset == True and len(inset_xrange) == 2:\n ax_inset = fig[pg_n-1].add_axes(inset_position) #, axisbg='white')\n bound2 = inset_xrange\n if len(inset_yrange) == 0:\n b0 = numpy.argmax(sp[0].wave.value > bound2[0])\n b1 = numpy.argmin(sp[0].wave.value < bound2[1])\n inset_yrange = [numpy.nanmin(sp[0].flux.value[b0:b1]),numpy.nanmax(sp[0].flux.value[b0:b1])]\n bound2.extend(inset_yrange)\n db = (bound2[3]-bound2[2])\n bound2[2] = bound2[2]-0.05*db\n bound2[3] = bound2[3]+0.05*db\n ax_inset.axis(bound2)\n inset_fontsize = fontsize*0.7\n\n for ii,a in enumerate(sp):\n flx = [i+zeropoint[ii] for i in a.flux.value]\n ax_inset.plot(a.wave.value,flx,color=colors[ii],linestyle=linestyle[ii],linewidth=linewidth[ii],alpha=alpha[ii]) \n ax_inset.set_xlabel('')\n ax_inset.set_ylabel('')\n ax_inset.tick_params(axis='x', labelsize=inset_fontsize)\n ax_inset.tick_params(axis='y', labelsize=inset_fontsize)\n# ax_inset.legend()\n\n# inset feature labels\n if len(inset_features) > 0:\n yoff = 0.05*(bound2[3]-bound2[2])\n for ftr in inset_features:\n ftrc = checkDict(ftr,FEATURE_LABELS)\n if ftrc != False:\n for ii,waveRng in enumerate(FEATURE_LABELS[ftrc]['wavelengths']):\n wRng = waveRng.to(sp[0].wave.unit).value\n if (numpy.min(wRng) > bound2[0] and numpy.max(wRng) < bound2[1]):\n wfeature = numpy.where(numpy.logical_and(wvmax >= numpy.nanmin(wRng),wvmax <= numpy.nanmax(wRng)))\n if len(wvmax[wfeature]) == 0: wfeature = numpy.argmax(numpy.absolute(wvmax-numpy.nanmedian(wRng)))\n y = numpy.nanmax(flxmax[wfeature])+yoff\n flxmax[wfeature] = flxmax[wfeature]+3.*yoff\n \n if FEATURE_LABELS[ftrc]['type'] == 'band':\n ax_inset.plot(wR,[y+yoff]*2,color='k',linestyle='-')\n ax_inset.plot([wR[0]]*2,[y,y+yoff],color='k',linestyle='-')\n ax_inset.text(numpy.mean(wR),y+2*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=inset_fontsize)\n else:\n for w in waveRng:\n ax_inset.plot([w]*2,[y,y+yoff],color='k',linestyle='-')\n ax_inset.text(numpy.mean(wR),y+2*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=inset_fontsize)\n waveRng = [wR[0]-0.02,wR[1]+0.02] # for overlap\n \n# update offset\n if len(inset_features) > 0: bound2[3] = numpy.nanmax([bound2[3],numpy.nanmax(flxmax)+5.*yoff])\n ax_inset.axis(bound2)\n\n# finalize bounding\n if len(xrng) > 0: bound[0:2] = xrng\n if len(yrng) > 0: bound[2:4] = yrng\n if isUnit(bound[0]): bound = [x.value for x in bound]\n ax.axis(bound)\n \n# save to file or display\n# ERROR HERE - CHECK WHAT FILES\n if multipage == False:\n if files[plts] != '' and (plts % nplot == 3 or plts == len(splist)-1):\n if kwargs.get('tight',True) == True: \n plt.savefig(files[plts], bbox_inches='tight')\n else:\n plt.savefig(files[plts])\n if output == '' and not kwargs.get('web',False):\n plt.show()\n if (kwargs.get('interactive',False) != False): plt.ion()\n else: plt.ioff()\n\n\n# save figures in multipage format and write off pdf file\n if multipage == True: \n for pg_n in numpy.arange(numpages):\n# fig[pg_n].text(0.5, 0.04, xlabel, ha = 'center', va = 'center')\n# fig[pg_n].text(0.06, 0.5, ylabel, ha = 'center', va = 'center', rotation = 'vertical')\n fig[pg_n].tight_layout\n fig[pg_n].suptitle(title, fontsize = int(14*fontsize), fontweight = 'bold')\n pdf_pages.savefig(fig[pg_n])\n if filetype.lower() == 'pdf':\n pdf_pages.close()\n\n plt.clf()\n return fig","def DT(time_lvl = 0, date = 160924 ):\n \n #-------Customised color in RGB ------------\n C = [[232,232,230],#grey\n [203,203,203], #grey\n [161,161,161], #grey\n [130,130,130], #grey\n [149,53,229], #lillac, 39\t64\t197\t149,53,229\n [39,64,197], #blue dark,7,67,194\n [15,110,229], #blue\n [80,149,240], #blue\n [74,192,243], #blue\n [152,219,248], #blue\n [183,237,247], #blue\n [251,217,198], #redish\n [255,197,166], #redish\n [255,172,164], #redish\n [253,139,142], #redish\n [253,101,105], #redish\n [255,66,74], #redish\n [238,13,28], #red\n [214,78,166], #pink\n [214,102,201], \n [217,155,210],\n [216,181,211]]\n C = np.array( C )\n C = np.divide( C, 255. ) # RGB has to be between 0 and 1 in python\n #-----------------------------------------------------------\n \n fig = plt.figure()\n \n \n #-----Setting our map area and projection of interest-------\n m = Basemap( llcrnrlon = -90., llcrnrlat = 0., urcrnrlon = 50., urcrnrlat=70.,\\\n resolution = 'l', area_thresh = 10000., projection = 'merc' )\n #m = Basemap(width=11500000,height=8500000,resolution='l',projection='eqdc',\\\n # lat_1=07.,lat_2=40,lat_0=44,lon_0=-30.)\n #m = Basemap(width=190000,height=2200000,resolution='l', projection='tmerc',lon_0=-30,lat_0=44)\n \n map_area( m ) # ploting background\n path = \"gribs/\"\n file = path +\"DT_var.grib\"\n obj = pygrib.open( file )\n \n #-FETCHING ALL THE VALUES----------------------------------------\n #-----Potential temperature---------------------------------------\n lat, lon, data = get_data( obj,'Potential temperature', 2000, date, timelevel = time_lvl )\n contour_val = np.linspace( 264, 384, 22 ) #contours for potential tempeature\n plot_contourf( m, lat, lon, data, C, contour_val )\n \n #-----Relative vorticity, diff level------------------------------\n contour=[ 2.8E-4, 3.5E-4, 4.5E-4, 6.5E-4, 7.E-4, 7.5E-4, 8.E-4 ] #1.5E-4,2.5E-4]#\n lat, lon, data925 = get_data( obj, 'Vorticity (relative)', 925, date, timelevel = time_lvl )\n lat, lon, data900 = get_data( obj, 'Vorticity (relative)', 900, date, timelevel = time_lvl )\n lat, lon, data850 = get_data( obj, 'Vorticity (relative)', 850, date, timelevel = time_lvl )\n \n #->--->---->--mean value over height and filtering----------------\n data = np.sqrt( data900**2 + 2*data850**2 + data925**2 ) #Vertical \"average\", weightet values at 850hpa double.\n footprint = np.array([[0,0,0,1,1,1,1,0,0,0], #footprint=np.ones((3,10))\n [0,0,1,1,1,2,1,1,0,0],\n [1,1,1,2,2,1,2,1,1,1],\n [0,1,1,1,1,2,1,1,1,0],\n [0,0,1,1,1,1,1,1,0,0]])\n \n data = ndimage.generic_filter( data, np.mean, footprint = footprint, mode='wrap' )\n plot_contour( m, lat,lon, data,contour, clr = 'k' )\n \n #-----Wind barbs----------------------------------------------------\n lat, lon, data_u = get_data( obj , 'U component of wind', 2000, date, timelevel = time_lvl )\n lat, lon, data_v = get_data( obj , 'V component of wind', 2000, date, timelevel = time_lvl )\n plot_wind_bar( m, lat, lon, data_u, data_v )\n #-----------------------------------------------\n #-----------------------------------------------\n \n \n \n #-SAVE AND CLOSE----------------------------------------------------\n #------------------------------------------------------------------\n obj.close()\n if time_lvl == 0:\n t = \"0000\"\n elif time_lvl == 1:\n t = \"1200\"\n elif time_lvl == 2:\n t = \"1800\"\n else: \n t = \"t_not_set\"\n \n fig_name = \"DT/DT_\" + str( date ) + \"_\" + str( t )+ \".TIFF\" \n \n ax = plt.gca( )\n plt.rc( 'font', size = 6 )\n fig.set_size_inches( 12.80, 7.15 )\n \n fig.savefig( fig_name, dpi = 600 )\n plt.close( )\n #plt.show()\n #--------------------------\n #----------------------------","def showCl(ell,temps,title='CAMB ISWout power spectrum'):\n plt.plot(ell,temps*ell*(ell+1)/(2*np.pi) *1e12) #1e12 to convert to microK**2\n plt.xlabel('multipole moment l')\n plt.ylabel('l(l+1)C_l/(2pi) [microK**2]')\n plt.title(title)\n plt.show()","def oceansim(sun_az,sun_zen,cam_head,cam_elev=0,m2=1.33,npart=1.08,mu=3.483, debug=True):\n\n #Water surface norm\n n = np.array([0,0,1])\n m1 = 1.0\n #vector from sun:\n ki = -np.asarray([np.sin(sun_az)*np.sin(sun_zen),\n np.cos(sun_az)*np.sin(sun_zen),\n np.cos(sun_zen)])\n xi = norm_cross(n,ki)\n #transmitted sunlight\n #tx, ty are the transmission amplitude coefficients in the xt, yt directions\n kt,tx,ty = Fresnel.transmission(ki,n,m1,m2)\n xt = xi\n #vector to camera\n kc = -np.asarray([np.sin(cam_head)*np.cos(cam_elev),\n np.cos(cam_head)*np.cos(cam_elev),\n np.sin(cam_elev)])*np.linalg.norm(kt)\n xc = norm_cross(n, kc) #right\n yc = norm_cross(kc, xc) #up\n #vectors for scattering\n ys = norm_cross(kt, kc) # y-axis of scattering event\n xst = norm_cross(ys, kt) # x-axis of scattering event relative to transmitted sunlight\n xsc = norm_cross(ys, kc) # x-axis of scattering event relative to camera\n #Mueller matrices\n # transmission through water surface:\n mm1 = Mueller.polarizer(tx,ty)\n # rotate to scattering plane\n mm2 = Mrotv(kt,xt,xst)\n # scatter\n th_s = vector_angle(kt,kc)\n #mm3 = Mocean(rad2deg(th_s)) #using Empirical ocean scattering\n mm3 = Mueller.rayleigh_norm(th_s) #normalized Rayleigh scattering matrix\n #b = Scattering.bsf_fournier(npart,mu)\n b = Scattering.vspf_fournier(th_s,npart,mu)\n # transform to camera's horizontal and up vectors\n mm4 = Mxform(xsc,ys, xc,yc)\n #Combined: mm4 . (b*mm3) . mm2 . mm1\n m = mm4.dot(b*mm3.dot(mm2.dot(mm1)))\n #stokes vector\n s = m.dot([1,0,0,0])\n if debug:\n return s,m,(ki,xi),(kt,xt,xst),(kc,xc,xsc),(mm1,mm2,mm3,b,mm4)\n else:\n return s,m","def plot5(self):\n\n cond = ((self.ds.freq<32.6) & (self.ds.freq>17))\n freq = self.ds.freq[cond]\n power = self.ds.power[cond]\n\n # the modes for KIC 9205705\n m = pd.read_csv('/home/mxs191/Desktop/MathewSchofield/TRG/GetData/Modes/modes_9205705.csv')\n m1 = [17.65, 20.6, 23.7, 26.9, 30.1] # l=1\n\n plt.rc('font', size=18)\n fig, ax = plt.subplots()\n plt.plot(freq, power, zorder=1, alpha=0.4)\n\n # NOTE: annotate mode angular degrees\n plt.scatter(m['f0'].as_matrix(), np.full(len(m), 150000), c='k', zorder=2, s=80)\n plt.scatter(m['f2'].as_matrix(), np.full(len(m), 130000), c='mediumseagreen', zorder=2, s=80, marker='^')\n plt.scatter(m1, np.full(len(m1), 140000), c='grey', zorder=2, s=80, marker='v')\n\n # NOTE: plot envelope\n numax = info['numax'].as_matrix() # mu Hz\n env_width = 0.66 * numax**0.88\n plt.plot(freq, 40004*np.exp( -( (freq-24.7)**2 / (2*7.**2) ) ), c='k', linestyle='--')\n\n # NOTE: annotate envelope\n style = dict(size=16, color='k')\n ax.text(24.1, 49167, r\"$\\nu_{\\rm max}$\", color='k', size=18)\n ax.text(24.1, 20994, r\"$\\Gamma_{\\rm env}$\", color='k', size=18)\n ax.text(23, 162944, r\"$\\Delta \\nu$\", **style)\n plt.annotate(s='', xy=(25.3, 158610), xytext=(21.91, 158610),\n arrowprops=dict(arrowstyle='<->')) # dnu\n plt.annotate(s='', xy=((24.7-env_width/2.), 15861), xytext=((24.7+env_width/2.), 15861),\n arrowprops=dict(arrowstyle='<->')) # env width\n\n ax.set_xlabel(r'Frequency ($\\rm \\mu Hz$)')\n ax.set_ylabel(r'PSD ($\\rm ppm^{2} \\, \\mu Hz^{-1}$)')\n plt.xlim(17, 32.6)\n plt.ylim(17, 195181)\n plt.tight_layout()\n plt.show()\n fig.savefig(os.getcwd() + '/DetTest1_plots/Plot5_ps_' + str(self.ds.epic) + '.pdf')","def oifits_show(dic, unit='arcsec', setlog=False, vmin=0, vmax=1.05, cmin=-4, cmax=4, unit_cp='rad'):\n unit = 'arcsec'\n uv_scale = {'m': 1,\n 'rad': 1/dic['OI_WAVELENGTH']['EFF_WAVE'],\n 'arcsec': 1/dic['OI_WAVELENGTH']['EFF_WAVE']/rad2mas(1e-3),\n 'lambda': 1/dic['OI_WAVELENGTH']['EFF_WAVE']/1e6}\n\n U = dic['OI_VIS2']['UCOORD']*uv_scale[unit]\n V = dic['OI_VIS2']['VCOORD']*uv_scale[unit]\n\n sp_freq_vis = dic['OI_VIS2']['FREQ'] * uv_scale[unit]\n\n V2 = dic['OI_VIS2']['VIS2DATA']\n e_V2 = dic['OI_VIS2']['VIS2ERR'] * 1\n\n sp_freq_cp = dic['OI_T3']['FREQ'] * uv_scale[unit] # Anand KeyError: 'FREQ' \n cp = dic['OI_T3']['T3PHI']\n e_cp = dic['OI_T3']['T3PHIERR']\n\n bmax = 1.2*np.max(np.sqrt(U**2+V**2))\n\n # Configuration fenetre\n fig = plt.figure(figsize=(16, 5.5))\n ax1 = plt.subplot2grid((2, 6), (0, 0), rowspan=2, colspan=2)\n ax2 = plt.subplot2grid((2, 6), (0, 2), colspan=4)\n ax3 = plt.subplot2grid((2, 6), (1, 2), colspan=4)\n\n # Plot plan UV\n # -------\n fig.subplots_adjust(top=0.974,\n bottom=0.091,\n left=0.038,\n right=0.996,\n hspace=0.127,\n wspace=0.35)\n\n #ax1.set_title('(u-v) plan', fontsize=12, color = 'grey', weight = 'bold')\n\n ax1.scatter(U, V, s=50, c='#00adb5',\n edgecolors='#364f6b', marker='o', alpha=1)\n ax1.scatter(-1*np.array(U), -1*np.array(V), s=50, c='#fc5185',\n edgecolors='#364f6b', marker='o', alpha=1)\n ax1.axis([bmax, -bmax, -bmax, bmax])\n ax1.spines['left'].set_visible(False)\n ax1.spines['right'].set_visible(False)\n ax1.spines['bottom'].set_visible(False)\n ax1.spines['top'].set_visible(False)\n ax1.patch.set_facecolor('#f7f9fc')\n ax1.patch.set_alpha(1)\n ax1.xaxis.set_ticks_position('none')\n ax1.yaxis.set_ticks_position('none')\n # ax1.yaxis.set_ticks_position('left')\n\n unitlabel = {'m': 'm',\n 'rad': 'rad$^{-1}$',\n 'arcsec': 'arcsec$^{-1}$',\n 'lambda': 'M$\\lambda$'}\n\n ax1.set_xlabel(r'U [%s]' % unitlabel[unit])\n ax1.set_ylabel(r'V [%s]' % unitlabel[unit])\n ax1.grid(alpha=0.2)\n\n # Plot V2\n # -------\n #ax2.set_title('Visibility and closure phase', fontsize=12,color = 'grey', weight = 'bold')\n ax2.errorbar(sp_freq_vis, V2, yerr=e_V2, linestyle=\"None\", capsize=1, ecolor='#364f6b', mfc='#00adb5', mec='#364f6b',\n marker='.', elinewidth=0.5, alpha=1, ms=8)\n\n ax2.hlines(1, 0, 1.2*np.max(sp_freq_vis),\n lw=1, color='k', alpha=.2, linestyle='--')\n\n ax2.set_ylim([vmin, vmax])\n ax2.set_xlim([0, 1.2*np.max(sp_freq_vis)])\n ax2.set_ylabel(r'$V^2$')\n ax2.spines['left'].set_visible(False)\n ax2.spines['right'].set_visible(False)\n ax2.spines['bottom'].set_visible(False)\n ax2.spines['top'].set_visible(False)\n ax2.patch.set_facecolor('#f7f9fc') \n ax2.patch.set_alpha(1)\n ax2.xaxis.set_ticks_position('none')\n ax2.yaxis.set_ticks_position('none')\n #ax2.set_xticklabels([])\n\n if setlog:\n ax2.set_yscale('log')\n ax2.grid(which='both', alpha=.2)\n\n # Plot CP\n # -------\n\n if unit_cp == 'rad':\n h1 = np.pi\n pass\n else:\n cp = np.rad2deg(cp).copy()\n e_cp = np.rad2deg(e_cp).copy()\n h1 = np.rad2deg(np.pi)\n \n cmin = -cmax\n\n ax3.errorbar(sp_freq_cp, cp, yerr=e_cp, linestyle=\"None\", capsize=1, ecolor='#364f6b', mfc='#00adb5', mec='#364f6b',\n marker='.', elinewidth=0.5, alpha=1, ms=8)\n ax3.hlines(h1, 0, 1.2*np.max(sp_freq_vis),\n lw=1, color='k', alpha=.2, ls='--')\n ax3.hlines(-h1, 0, 1.2*np.max(sp_freq_vis),\n lw=1, color='k', alpha=.2, ls='--')\n ax3.spines['left'].set_visible(False)\n ax3.spines['right'].set_visible(False)\n ax3.spines['bottom'].set_visible(False)\n ax3.spines['top'].set_visible(False)\n ax3.patch.set_facecolor('#f7f9fc')\n ax3.patch.set_alpha(1)\n ax3.xaxis.set_ticks_position('none')\n ax3.yaxis.set_ticks_position('none')\n ax3.set_xlabel('Spatial frequency [cycle/arcsec]')\n ax3.set_ylabel('Clos. $\\phi$ [%s]'%unit_cp)\n ax3.axis([0, 1.2*np.max(sp_freq_vis), cmin, cmax])\n ax3.grid(which='both', alpha=.2)\n plt.show()\n return fig","def n27_and_stark():\n fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(4.5, 4))\n # n=27 without static field.\n folder = os.path.join(\"..\", \"..\", \"2018-09-09\")\n fname = \"11_freq_diode.txt\"\n fname = os.path.join(folder, fname)\n data = pmu.fscan_import(fname)\n data['afpoly'] = data['fpoly'] + 4511\n ax.axhline(0, color='grey')\n data.plot(x='afpoly', y='sig', c='k', ax=ax)\n # n=27 with static field.\n fname = \"10_freq_diode.txt\"\n fname = os.path.join(folder, fname)\n data = pmu.fscan_import(fname)\n data['afpoly'] = data['fpoly'] + 4511\n data['asig'] = data['sig'] + 0.15\n ax.axhline(0.15, color='grey')\n data.plot(x='afpoly', y='asig', c='k', ax=ax)\n # text\n ax.text(-5.5, 0.2, \"3 V/cm\", horizontalalignment='right')\n ax.text(-5.5, 0.01, \"0 V/cm\", horizontalalignment='right')\n # pretty figure\n ax.legend().remove()\n ax.set_ylabel(r\"$e^-$ Signal\")\n ax.set_yticks([])\n ax.set_xlabel(r\"Frequency (GHz from $3d_{5/2} \\rightarrow 27f$)\")\n ax.set_xlim(-8, 7)\n # save\n fig.tight_layout()\n fig.savefig('n27_and_stark.pdf')\n return","def example():\n # --- input data filename ---\n infile = os.path.join(os.path.dirname(__file__),\n '../../ExampleDataFiles/MarsTopo719.shape')\n coeffs, lmax = pysh.shio.shread(infile)\n\n # --- plot grid ---\n grid = pysh.expand.MakeGridDH(coeffs, csphase=-1)\n fig_map = plt.figure()\n plt.imshow(grid)\n\n # ---- compute spectrum ----\n ls = np.arange(lmax + 1)\n pspectrum = pysh.spectralanalysis.spectrum(coeffs, unit='per_l')\n pdensity = pysh.spectralanalysis.spectrum(coeffs, unit='per_lm')\n\n # ---- plot spectrum ----\n fig_spectrum, ax = plt.subplots(1, 1)\n ax.set_xscale('log')\n ax.set_yscale('log')\n ax.set_xlabel('degree l')\n ax.grid(True, which='both')\n\n ax.plot(ls[1:], pspectrum[1:], label='power per degree l')\n ax.plot(ls[1:], pdensity[1:], label='power per degree l and order m')\n\n ax.legend()\n\n fig_map.savefig('SHRtopography_mars.png')\n fig_spectrum.savefig('SHRspectrum_mars.png')\n print('mars topography and spectrum saved')\n\n # plt.show()","def setplot(plotdata):\n#-------------------------- \n\n\n from pyclaw.plotters import colormaps, geoplot\n\n plotdata.clearfigures() # clear any old figures,axes,items data\n\n def set_drytol(current_data):\n # The drytol parameter is used in masking land and water and\n # affects what color map is used for cells with small water depth h.\n # The cell will be plotted as dry if h < drytol.\n # The best value to use often depends on the application and can\n # be set here (measured in meters):\n current_data.user.drytol = 1.e-4\n\n\n plotdata.beforeframe = set_drytol\n\n # To plot gauge locations on pcolor or contour plot, use this as\n # an afteraxis function:\n\n def addgauges(current_data):\n from pyclaw.plotters import gaugetools\n gaugetools.plot_gauge_locations(current_data.plotdata, \\\n gaugenos='all', format_string='ko', add_labels=True)\n \n\n #-----------------------------------------\n # Figure for imshow plot\n #-----------------------------------------\n plotfigure = plotdata.new_plotfigure(name='imshow', figno=0)\n plotfigure.show = False\n\n # Set up for axes in this figure:\n plotaxes = plotfigure.new_plotaxes('imshow')\n plotaxes.title = 'Surface'\n plotaxes.scaled = True\n\n # Water\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\n #plotitem.plot_var = geoplot.surface\n plotitem.plot_var = geoplot.surface_or_depth\n plotitem.imshow_cmap = geoplot.tsunami_colormap\n plotitem.imshow_cmin = -0.02\n plotitem.imshow_cmax = 0.02\n plotitem.add_colorbar = True\n plotitem.amr_gridlines_show = [0,0,0]\n plotitem.amr_gridedges_show = [1]\n\n # Land\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\n plotitem.plot_var = geoplot.land\n plotitem.imshow_cmap = geoplot.land_colors\n plotitem.imshow_cmin = 0.0\n plotitem.imshow_cmax = 0.05\n plotitem.add_colorbar = False\n plotitem.amr_gridlines_show = [0,0,0]\n plotaxes.xlimits = 'auto'\n plotaxes.ylimits = 'auto'\n\n \n\n #-----------------------------------------\n # Figure for imshow plot\n #-----------------------------------------\n plotfigure = plotdata.new_plotfigure(name='Surface and Gauge 1', figno=20)\n\n # Set up for axes in this figure:\n plotaxes = plotfigure.new_plotaxes('imshow')\n plotaxes.axescmd = \"axes([.1,.5,.8,.4])\"\n plotaxes.title = 'Surface'\n plotaxes.scaled = True\n plotaxes.afteraxes = addgauges\n\n # Water\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\n #plotitem.plot_var = geoplot.surface\n plotitem.plot_var = geoplot.surface_or_depth\n plotitem.imshow_cmap = geoplot.tsunami_colormap\n plotitem.imshow_cmin = -0.03\n plotitem.imshow_cmax = 0.03\n plotitem.add_colorbar = True\n plotitem.amr_gridlines_show = [0,0,0]\n plotitem.amr_gridedges_show = [1]\n\n # Land\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\n plotitem.plot_var = geoplot.land\n plotitem.imshow_cmap = geoplot.land_colors\n plotitem.imshow_cmin = 0.0\n plotitem.imshow_cmax = 0.05\n plotitem.add_colorbar = False\n plotitem.amr_gridlines_show = [0,0,0]\n plotaxes.xlimits = 'auto'\n plotaxes.ylimits = 'auto'\n\n\n # Gauge trace:\n plotaxes = plotfigure.new_plotaxes()\n plotaxes.show = False\n plotaxes.axescmd = \"axes([.1,.1,.8,.3])\"\n plotaxes.xlimits = 'auto'\n plotaxes.ylimits = [-0.02, 0.05]\n plotaxes.title = 'Gauge 1'\n\n # Plot surface as blue curve:\n plotitem = plotaxes.new_plotitem(plot_type='1d_gauge_trace')\n plotitem.plot_var = 3\n plotitem.plotstyle = 'b-'\n plotitem.gaugeno = 1\n\n\n #-----------------------------------------\n # Figure for zoom\n #-----------------------------------------\n plotfigure = plotdata.new_plotfigure(name='Zoom', figno=10)\n #plotfigure.show = False\n plotfigure.kwargs = {'figsize':[7,7]}\n\n # Set up for axes in this figure:\n plotaxes = plotfigure.new_plotaxes('monai')\n #plotaxes.axescmd = 'axes([0.0,0.1,0.6,0.6])'\n plotaxes.title = 'Monai Valley'\n plotaxes.scaled = True\n #plotaxes.xlimits = [4.0, 5.2]\n #plotaxes.ylimits = [1.3, 2.5]\n plotaxes.xlimits = [4.7, 5.2]\n plotaxes.ylimits = [1.5, 2.2]\n\n # Water\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\n #plotitem.plot_var = geoplot.surface\n plotitem.plot_var = geoplot.surface_or_depth\n plotitem.imshow_cmap = geoplot.tsunami_colormap\n plotitem.imshow_cmin = -0.02\n plotitem.imshow_cmax = 0.02\n plotitem.add_colorbar = False\n plotitem.amr_gridlines_show = [0]\n plotitem.amr_gridedges_show = [1]\n\n # Land\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\n plotitem.plot_var = geoplot.land\n plotitem.imshow_cmap = geoplot.land_colors\n plotitem.imshow_cmin = 0.0\n plotitem.imshow_cmax = 0.05\n plotitem.add_colorbar = False\n plotitem.amr_gridlines_show = [0]\n\n # Add contour lines of bathymetry:\n plotitem = plotaxes.new_plotitem(plot_type='2d_contour')\n plotitem.plot_var = geoplot.topo\n from numpy import arange, linspace\n plotitem.contour_levels = arange(-0.02, 0., .0025)\n plotitem.amr_contour_colors = ['k'] # color on each level\n plotitem.kwargs = {'linestyles':'solid'}\n plotitem.amr_contour_show = [1] # show contours only on finest level\n plotitem.gridlines_show = 0\n plotitem.gridedges_show = 0\n plotitem.show = True\n \n # Add contour lines of topography:\n plotitem = plotaxes.new_plotitem(plot_type='2d_contour')\n plotitem.plot_var = geoplot.topo\n from numpy import arange, linspace\n plotitem.contour_levels = arange(0., .2, .01)\n plotitem.amr_contour_colors = ['w'] # color on each level\n plotitem.kwargs = {'linestyles':'solid'}\n plotitem.amr_contour_show = [1] # show contours only on finest level\n plotitem.gridlines_show = 0\n plotitem.gridedges_show = 0\n plotitem.show = True\n\n # Add dashed contour line for current shoreline\n plotitem = plotaxes.new_plotitem(plot_type='2d_contour')\n plotitem.plot_var = 0\n plotitem.contour_levels = [0.002]\n plotitem.amr_contour_colors = ['k'] # color on each level\n plotitem.kwargs = {'linestyles':'dashed','linewidths':2}\n plotitem.amr_contour_show = [1] # show contours only on finest level\n plotitem.gridlines_show = 0\n plotitem.gridedges_show = 0\n plotitem.show = True\n\n\n\n\n #-----------------------------------------\n # Figures for gauges\n #-----------------------------------------\n plotfigure = plotdata.new_plotfigure(name='Surface & topo', figno=300, \\\n type='each_gauge')\n\n # Set up for axes in this figure:\n plotaxes = plotfigure.new_plotaxes()\n plotaxes.xlimits = [0,25]\n plotaxes.ylimits = [-0.02, 0.05]\n plotaxes.title = 'Surface'\n\n # Plot surface as blue curve:\n plotitem = plotaxes.new_plotitem(plot_type='1d_plot')\n plotitem.plot_var = 3\n plotitem.plotstyle = 'b-'\n\n # Plot topo as green curve:\n plotitem = plotaxes.new_plotitem(plot_type='1d_plot')\n\n def gaugetopo(current_data):\n q = current_data.q\n h = q[:,0]\n eta = q[:,3]\n topo = eta - h\n return topo\n \n plotitem.plot_var = gaugetopo\n plotitem.clf_each_gauge = False\n plotitem.plotstyle = 'g-'\n def afteraxes(current_data):\n from pylab import plot, legend, loadtxt\n t = current_data.t\n plot(t, 0*t, 'k')\n gaugeno = current_data.gaugeno\n \n if gaugeno in [5,7,9]:\n col = (gaugeno-3)/2\n plot(labgage[:,0],0.01*labgage[:,col],'r')\n legend(('GeoClaw','topography','sea level','lab data'),loc='upper left')\n else:\n legend(('GeoClaw','topography','sea level'),loc='upper right')\n \n \n\n plotaxes.afteraxes = afteraxes\n\n\n #-----------------------------------------\n # Figure for grids alone\n #-----------------------------------------\n plotfigure = plotdata.new_plotfigure(name='grids', figno=2)\n plotfigure.show = False\n\n # Set up for axes in this figure:\n plotaxes = plotfigure.new_plotaxes()\n plotaxes.xlimits = [0,1]\n plotaxes.ylimits = [0,1]\n plotaxes.title = 'grids'\n plotaxes.scaled = True\n\n # Set up for item on these axes:\n plotitem = plotaxes.new_plotitem(plot_type='2d_grid')\n plotitem.amr_grid_bgcolor = ['#ffeeee', '#eeeeff', '#eeffee']\n plotitem.amr_gridlines_show = [1,1,0] \n plotitem.amr_gridedges_show = [1] \n\n #-----------------------------------------\n \n # Parameters used only when creating html and/or latex hardcopy\n # e.g., via pyclaw.plotters.frametools.printframes:\n\n plotdata.printfigs = True # print figures\n plotdata.print_format = 'png' # file format\n #plotdata.print_framenos = [4,6,8,10,12]\n plotdata.print_framenos = [5,7,9,11,13]\n plotdata.print_gaugenos = [0,5,7,9] # list of gauges to print\n plotdata.print_fignos = 'all' # list of figures to print\n plotdata.html = True # create html files of plots?\n plotdata.html_homelink = '../README.html' # pointer for top of index\n plotdata.latex = True # create latex file of plots?\n plotdata.latex_figsperline = 2 # layout of plots\n plotdata.latex_framesperline = 1 # layout of plots\n plotdata.latex_makepdf = False # also run pdflatex?\n\n return plotdata","def plot(self):\n\t\t\n\t\ttf=tfData(self.shotno,tStart=None,tStop=None)\n\t\t\n\t\t_plt.figure()\n\t\tax1 = _plt.subplot2grid((3,2), (0,1), rowspan=3) #tf\n\t\tax2 = _plt.subplot2grid((3,2), (0,0)) #vf\n\t\tax3 = _plt.subplot2grid((3,2), (1,0),sharex=ax2) #oh\n\t\tax4 = _plt.subplot2grid((3,2), (2, 0),sharex=ax2) #sh\n\t\tfig=_plt.gcf()\n\t\tfig.set_size_inches(10,5)\n\t\t\t\t\n\t\ttStart=-2\n\t\ttStop=20\n\t\t\n\t\tax1.plot(tf.time*1e3,tf.tfBankField)\n\t\tax1.axvspan(tStart,tStop,color='r',alpha=0.3)\n\t\t_plot.finalizeSubplot(ax1,xlabel='Time (s)',xlim=[-150,450],ylabel='TF Field (T)')#,title=self.title\n\t\t\n\t\tax2.plot(self.vfTime*1e3,self.vfBankCurrent*1e-3)\n\t\t_plot.finalizeSubplot(ax2,ylabel='VF Current\\n(kA)')\n\t\t\n\t\tax3.plot(self.ohTime*1e3,self.ohBankCurrent*1e-3)\n\t\t_plot.finalizeSubplot(ax3,ylim=[-20,30],ylabel='OH Current\\n(kA)')\n\t\t\n\t\tax4.plot(self.shTime*1e3,self.shBankCurrent*1e-3)\n\t\t_plot.finalizeSubplot(ax4,ylim=[tStart,tStop],xlabel='Time (s)',ylabel='SH Current\\n(kA)')\n\t\t\n\t\t_plot.finalizeFigure(fig,title=self.title)\n#\t\tfig.set_tight_layout(True)\n\t\t\n\t\treturn fig","def make_hexplot(XX,VV,gs=100):\n coord = [[0,0,0],[0,400,-400],[-400,400,0],[-400,0,400],[0,-400,400],[400,-400,0],[400,0,-400],[0,800,-800],[-800,800,0],[-800,0,800],[0,-800,800],[800,-800,0],[800,0,-800],[800,0,0],[-400,800,-400],[-400,-800,400],[-800,0,0],[400,-800,400],[400,800,-400]]\n\n # Horizontal cartesian coords\n hcoord = [c[0] for c in coord]\n\n # Vertical cartersian coords\n vcoord = [2. * np.sin(np.radians(60)) * (c[1] - c[2]) /3. for c in coord]\n\n fig, ax = plt.subplots(1,figsize=(20,20))\n ax.set_aspect('equal')\n\n nhex=len(coord)\n # Add some coloured hexagons\n for i in range(0,nhex):\n xi=(XX[:,0])+hcoord[i]/1000.\n yi=(YY[:,1])+vcoord[i]/1000.\n idist=np.sqrt(xi**2+yi**2)\n iindx=(idist<0.2)*(np.fabs(XX[:,2])<0.2)\n hex = RegularPolygon((hcoord[i], vcoord[i]), numVertices=6, radius=800./3., \n orientation=np.radians(30), \n facecolor='white', alpha=1., edgecolor='k',zorder=i*2)\n ax.add_patch(hex)\n ax.hist2d(VV[:,0][iindx]*1.5+hcoord[i],VV[:,1][iindx]*2.-375.+220.+vcoord[i],range=[[hcoord[i]-220.,hcoord[i]+220],[vcoord[i]-220,vcoord[i]+220]],bins=gs,cmin=1.0e-50,rasterized=True,density=True,zorder=i*2+1)\n ax.set_xlim(-1200,1200)\n ax.set_ylim(-1200,1200)\n ax.set_xlabel(r'$x\\ (\\mathrm{pc})$',fontsize=20)\n ax.set_ylabel(r'$y\\ (\\mathrm{pc})$',fontsize=20)\n ax.tick_params(axis='both', labelsize=20)\n\n #hex2 = RegularPolygon((800,2.*np.sin(np.radians(60))*(1600) /3.), numVertices=6, radius=800./3.,orientation=np.radians(30), \n # facecolor='white', alpha=1., edgecolor='k',zorder=0)\n #ax.add_patch(hex2)\n plt.savefig('Hexgrid.pdf',bbox_inches='tight')\n #plt.show()\n plt.close()","def view_datashade(self):\n # Select only sufficient data\n if self.x in self.y:\n self.y.remove(self.x)\n if self.y == []:\n return self.gif\n\n df = self.dataframe[[self.x] + self.y].copy()\n plot_opts = {\n 'Scatter': {'color': self.color_key, 'marker': self.marker_keys, 'size':10},\n 'Curve': {'color': self.color_key}\n }\n lines_overlay = df.hvplot.scatter(**self.plot_options).options(plot_opts)\n\n def hover_curve(x_range=[df.index.min(), df.index.max()]): # , y_range):\n # Compute\n dataframe = df.copy()\n if x_range is not None:\n dataframe = dataframe[(dataframe[self.x] > x_range[0]) & (dataframe[self.x] < x_range[1])]\n data_length = len(dataframe) * len(dataframe.columns)\n step = 1 if data_length < self.max_step else data_length // self.max_step\n \n plot_df = dataframe[::step].hvplot.line(**self.plot_options) * \\\n dataframe[::step*60].hvplot.scatter(**self.plot_options) \n plot_opts = {\n 'Scatter': {'color': 'k', 'marker': self.marker_keys, 'size':10},\n 'Curve': {'color': self.color_key}\n }\n if len(self.y) != 1:\n plot_opts['Scatter']['color'] = self.color_key\n return plot_df.options(plot_opts)\n\n # Define a RangeXY stream linked to the image\n rangex = hv.streams.RangeX(source=lines_overlay)\n data_shade_plot = hv.DynamicMap(hover_curve, streams=[rangex])\n if len(self.y) == 1:\n data_shade_plot *= datashade(lines_overlay)\n else:\n data_shade_plot *= datashade(lines_overlay, aggregator=ds.count_cat('Variable'))\n return pn.panel(data_shade_plot)","def plot_field_uncertainties():\n\n resize_size = (1000, 1000)\n\n\n dirs = [os.path.join(path_to_here, '../data/landscape_visualizations/{}/{}/'.format(drug_name, j)) for j in ['original', 'repeat_a', 'repeat_b']]\n if drug_name == 'DMSO':\n dirs = [os.path.join(path_to_here, '../data/landscape_visualizations/{}/{}/30_hours/'.format(drug_name, j)) for j in ['original', 'repeat_a', 'repeat_b']]\n\n def transform(x):\n if type(x) is np.ndarray:\n x = change_array_lims(x)\n x = np.log(x)\n return x\n\n F_unc_vmin = -7\n F_unc_vmax = -4\n sigma_vmin = -5\n sigma_vmax = 0 #0.4\n sigma_unc_vmin = -6\n sigma_unc_vmax = -2\n\n fig_Fs = [plt.figure() for _ in range(3)]\n fig_uncertainty = plt.figure()\n sigma_lists, F_arrays = [], []\n for idx_fig, dir in enumerate(dirs):\n\n p_list = _load_and_resize_list(dir+'p_list_0.pickle')\n D_list = _load_and_resize_list(dir+'D_list_0.pickle')\n U_array = pickle.load(open(dir+'U.pickle', 'rb'))\n U_array = cv2.resize(U_array, resize_size, interpolation = cv2.INTER_LINEAR)\n Gx, Gy = np.gradient(U_array, 26./resize_size[0], 26./resize_size[0]) # gradients with respect to x and y\n F_array = (Gx**2+Gy**2)**.5 # gradient magnitude\n F_array[np.isinf(F_array)] = np.nan\n F_array[p_list[-1]<1e-3]=np.nan # final PDF\n sigma_list = []\n for j in range(9):\n arr = D_list[2*j] # current PDF\n arr[p_list[j]<1e-3]=np.nan\n sigma_list.append(np.sqrt(2*arr))\n\n\n sigma_lists.append(sigma_list)\n F_arrays.append(F_array)\n\n ax = fig_Fs[idx_fig].add_subplot(111)\n ax.imshow(transform(F_array)[::-1, :], cmap = cmap, vmin = -4.6, vmax = -2)\n ax.set_title(dir)\n\n all_axes = [i for j in fig_Fs for i in j.axes]\n for ax in all_axes:\n ax.axis('off')\n\n # uncertainties\n\n std = np.std(F_arrays, axis = 0)\n ax = fig_uncertainty.add_subplot(121)\n ax.imshow(transform(std)[::-1, :], cmap = cmap, vmin = F_unc_vmin, vmax = F_unc_vmax)\n ax.set_title('F_uncertainty')\n\n fig_sigma = plt.figure()\n ax = fig_sigma.add_subplot(111)\n ax.imshow(transform(np.nanmean(sigma_lists[0], axis = 0))[::-1, :], cmap = cmap, vmin = sigma_vmin, vmax = sigma_vmax) # index 0 (i.3 'original' is corresponds to the landscapes in other figures)\n ax.set_title('sigma_mean')\n\n sigma_means = [np.nanmean(sigma_list, axis = 0) for sigma_list in sigma_lists]\n std_array = np.nanstd(sigma_means, axis = 0)\n ax = fig_uncertainty.add_subplot(122)\n ax.imshow(transform(std_array)[::-1, :], cmap = cmap, vmin = sigma_unc_vmin, vmax = sigma_unc_vmax)\n ax.set_title('sigma_uncertainty')\n\n fig_sigma.savefig(path_to_here+'/../outputs/{}_mean_sigma.png'.format(drug_name), dpi = 1200)\n fig_uncertainty.savefig(path_to_here+'/../outputs/{}_uncertainties.png'.format(drug_name), dpi = 1200)","def plot_all(self) -> None:\n self.__plot_si_cf_plane()\n self.__plot_convex_hull()\n self.__plot_fixed_radius()\n self.__plot_delaunay()"],"string":"[\n \"def plot_Ae_HDR10_exr_nl_out_vari_prj_white(graph_name=\\\"./img/out.png\\\"):\\n width = 1920\\n\\n fname_list = [\\n \\\"./AfterEffects/Comp 1/prj_w_W-none _00000.exr\\\",\\n \\\"./AfterEffects/Comp 1/prj_w_W-100 _00000.exr\\\",\\n \\\"./AfterEffects/Comp 1/prj_w_W-203 _00000.exr\\\",\\n \\\"./AfterEffects/Comp 1/prj_w_W-10000 _00000.exr\\\",\\n ]\\n profile_list = [\\n \\\"Rec.2100 PQ\\\",\\n \\\"Rec.2100 PQ W100\\\",\\n \\\"Rec.2100 PQ W203\\\",\\n \\\"Rec.2100 PQ W10000\\\"\\n ]\\n\\n def get_linear(fname):\\n img = read_image(fname)\\n x_ae = img[0, :, 1] # extract Green line data\\n ae_luminance = tf.eotf_to_luminance(x_ae, tf.ST2084)\\n return ae_luminance\\n\\n chara_list = [get_linear(fname) for fname in fname_list]\\n\\n x = np.linspace(0, 1, width)\\n ref_luminance = tf.eotf_to_luminance(x, tf.ST2084)\\n\\n fig, ax1 = pu.plot_1_graph(\\n fontsize=20,\\n figsize=(10, 8),\\n bg_color=(0.96, 0.96, 0.96),\\n graph_title=\\\"Transfer characteristics of the working color space\\\",\\n graph_title_size=None,\\n xlabel=\\\"Input Luminance [cd/m2]\\\",\\n ylabel=\\\"Output LUminance [cd/m2]\\\",\\n axis_label_size=None,\\n legend_size=17,\\n xlim=[0.009, 15000],\\n ylim=[0.009, 15000],\\n xtick=None,\\n ytick=None,\\n xtick_size=None, ytick_size=None,\\n linewidth=3,\\n minor_xtick_num=None,\\n minor_ytick_num=None)\\n pu.log_scale_settings(ax1=ax1)\\n for idx, y in enumerate(chara_list):\\n ax1.plot(ref_luminance, y, label=profile_list[idx])\\n pu.show_and_save(\\n fig=fig, legend_loc='upper left', save_fname=graph_name,\\n show=False)\",\n \"def plotblackbody(_zband, _yband, _jband, _hband, _kband, _parallax, _perr):\\n # Set pyplot style to be consistent within the program\\n plt.style.use('seaborn-whitegrid')\\n # Import raw data to plot Hertzsprung-Russell diagram\\n _hrdata = inithr('hr.dat')\\n # Determine distance in parsecs\\n _distance = 1 / np.tan(_parallax * 10**-3)\\n _derr = (_perr * 10**-3) / ((_parallax * 10**-3)**2)\\n # Create single data array with all bands\\n _bands = [_zband, _yband, _jband, _hband, _kband]\\n _lambda = [0.9, 1.02, 1.22, 1.63, 2.2]\\n # Set up empty arrays for each star\\n _largestar = np.zeros((1, 2))\\n _smallstar = np.zeros((1, 2))\\n\\n # Determine the spectral flux density from the large star\\n i = 0\\n while i < 5:\\n # Determine the maximum and minimum values of the observed band\\n _max, _min = lightcurve.maxminvals(_bands[i])\\n # The large star uses the maximum flux value (smallest magnitude)\\n _largestar = np.append(_largestar, np.array([_lambda[i], (magtoflux(_min, i))], ndmin=2), axis=0)\\n i += 1\\n # Delete first empty row of the array\\n _largestar = np.delete(_largestar, 0, axis=0)\\n\\n # Determine the spectral flux density from the small star\\n i = 0\\n while i < 5:\\n # Determine the maximum and minimum values of the observed band\\n _max, _min = lightcurve.maxminvals(_bands[i])\\n # Smaller star flux value is combined value minus the large star\\n _smallstar = np.append(_smallstar, np.array([_lambda[i], (magtoflux(_max, i) -\\n magtoflux(_min, i))], ndmin=2), axis=0)\\n i += 1\\n # Delete the first empty row of the array\\n _smallstar = np.delete(_smallstar, 0, axis=0)\\n\\n # Determine the luminosity and effective temperature of each star\\n _luma, _lumaerr, _wiena = getwientemp(_largestar, _distance, _derr, 1)\\n _lumb, _lumberr, _wienb = getwientemp(_smallstar, _distance, _derr, 2)\\n\\n # Calculate luminosities in solar units\\n _solluma = _luma / (3.828*10**26)\\n _sollumb = _lumb / (3.828*10**26)\\n _lumaerr = _lumaerr / (3.828*10**26)\\n _lumberr = _lumberr / (3.828*10**26)\\n\\n # Calculate masses using the mass/luminosity relation in solar mass units\\n # N.B. only works as an approximation for main sequence stars, giants and dwarfs are not sutiable for this\\n # approximation\\n _solmassa = np.power(_solluma, 1/3.5)\\n _solmassaerr = ((_solmassa * (1/3.5) * _lumaerr) / _solluma)**2\\n _solmassb = np.power(_sollumb, 1/3.5)\\n _solmassberr = ((_solmassb * (1 / 3.5) * _lumberr) / _sollumb) ** 2\\n\\n # Calculate stellar radius in solar radii using the relationship between luminosity, surface area and temperature\\n _solrada = np.sqrt(_solluma / np.power(_wiena / 5778, 4))\\n _solradb = np.sqrt(_sollumb / np.power(_wienb / 5778, 4))\\n _solradaerr = ((_solrada * 0.5 * _lumaerr) / _solluma)**2\\n _solradberr = ((_solradb * 0.5 * _lumberr) / _sollumb)**2\\n\\n # Output determined values to the screen and write to file\\n print('Values for the large star:')\\n print('Effective temperature: ' + str(round_sig(_wiena)))\\n print('Solar luminosities: ' + str(round_sig(_solluma)) + ', error: ' + str(round_sig(_lumaerr)))\\n print('Solar radii: ' + str(round_sig(_solrada)) + ', error: ' + str(round_sig(_solradaerr)))\\n print('Solar masses: ' + str(round_sig(_solmassa)) + ', error: ' + str(round_sig(_solmassaerr)))\\n print('-----------------------------------------------------')\\n print('Values for the small star:')\\n print('Effective temperature: ' + str(round_sig(_wienb)))\\n print('Solar luminosities: ' + str(round_sig(_sollumb)) + ', error: ' + str(round_sig(_lumberr)))\\n print('Solar radii: ' + str(round_sig(_solradb)) + ', error: ' + str(round_sig(_solradberr)))\\n print('Solar masses: ' + str(round_sig(_solmassb)) + ', error: ' + str(round_sig(_solmassberr)))\\n\\n # Convert from luminosity to magnitude in solar units\\n _luma = -2.5 * np.log10(_luma / (3.0128 * 10**28))\\n _lumb = -2.5 * np.log10(_lumb / (3.0128 * 10**28))\\n\\n # Plot Hertzsprung-Russell diagram using provided array\\n plt.scatter(_hrdata[:, 1], _hrdata[:, 0], s=0.5)\\n # Plot determined values for each star\\n plt.scatter(_wiena, _luma, s=16, c='red', label='Larger Star')\\n plt.scatter(_wienb, _lumb, s=16, c='green', label='Smaller Star')\\n # Set the x and y axis limits to sensible values\\n plt.legend()\\n plt.xlim(3000, 10000)\\n plt.ylim(-10, 20)\\n # Invert both axes as convention\\n plt.gca().invert_xaxis()\\n plt.gca().invert_yaxis()\\n # Save figure to current folder\\n plt.savefig('hr.png')\\n # Display to screen\\n plt.show()\",\n \"def dem_jpeg(dem_file):\\n out_file = dem_file+'.jpeg'\\n rsc_file = out_file+'.rsc'\\n shutil.copy2(dem_file+'.rsc', rsc_file)\\n # read data\\n dem = readfile.read(dem_file)[0]\\n print('dem.shape:',dem.shape)\\n # figure size\\n ds_shape = tuple(reversed(dem.shape))\\n fig_dpi = 300\\n fig_size = [i / fig_dpi for i in ds_shape]\\n print('fig_size:',fig_size)\\n # color range\\n disp_min = np.nanmin(dem) - 4000\\n disp_max = np.nanmax(dem) + 2000\\n # prepare shaded relief\\n ls = LightSource(azdeg=315, altdeg=45)\\n dem_shade = ls.shade(dem, vert_exag=0.3, cmap=plt.get_cmap('gray'), vmin=disp_min, vmax=disp_max)\\n dem_shade[np.isnan(dem_shade[:, :, 0])] = np.nan\\n print('dem_shade.shape:',dem_shade.shape)\\n # plot\\n fig, ax = plt.subplots(figsize=fig_size)\\n ax.imshow(dem_shade, interpolation='spline16', origin='upper')\\n # get rid of whitespace on the side\\n ax.axis('off')\\n ax.get_xaxis().set_ticks([])\\n ax.get_yaxis().set_ticks([])\\n fig.subplots_adjust(left=0,right=1,bottom=0,top=1)\\n # output\\n print('save figure to file {}'.format(out_file))\\n plt.savefig(out_file, transparent=True, dpi=300, pad_inches=0.0)\\n \\n #resize to desired size(FA 8/19, unclear why size is wrong)\\n im = Image.open(out_file)\\n im_out = im.resize(dem.shape, Image.NEAREST)\\n im_out.save(out_file)\\n \\n #plt.show()\",\n \"def get_ptf10iuv(colorplt = False):\\n z = 0.0251485\\n ebv = 0.0371 # SFD\\n D = cosmo.luminosity_distance([z])[0].value * 1e+6 # in pc\\n dis_mod = 5*np.log10(D / 10)\\n print (\\\"adopt g band t_max estimated by myself\\\")\\n t_max = 55357.387 \\n tb = pd.read_csv('../data/otherSN/Kasliwal2012/PTF10iuv', sep='\\\\t')\\n tb = tb.drop(columns=[\\\"Unnamed: 4\\\"])\\n tb = tb.rename(columns={'Filter' : 'filter',\\n 'MJD': 'mjd'})\\n tb = tb[~np.array([x[0]=='>' for x in tb['Mag'].values])]\\n tb['mag'] = np.array([float(x.split(\\\" +or-\\\")[0]) for x in tb['Mag'].values])\\n tb['emag'] = np.array([float(x.split(\\\" +or-\\\")[1]) for x in tb['Mag'].values])\\n tb = tb.drop(columns=[\\\"Mag\\\"])\\n \\n ixg = tb['filter'].values == \\\"g\\\"\\n ixr = tb['filter'].values == \\\"r\\\"\\n ixi = tb['filter'].values == \\\"i\\\"\\n ixz = tb['filter'].values == \\\"z\\\"\\n ixB = tb['filter'].values == \\\"B\\\"\\n tb['wave'] = np.zeros(len(tb))\\n tb['wave'].values[ixB] = 4359\\n tb['wave'].values[ixg] = 4814\\n tb['wave'].values[ixr] = 6422\\n tb['wave'].values[ixi] = 7883\\n tb['wave'].values[ixz] = 9670\\n \\n tb['mag0'] = tb['mag'] - extinction.ccm89(tb['wave'].values, 3.1*ebv, 3.1)\\n tb['mag0_abs'] = tb['mag0'] - dis_mod\\n tb['tmax_rf'] = (tb['mjd'] - t_max) / (1+z)\\n tb = tb.sort_values(by = \\\"mjd\\\")\\n if colorplt==False:\\n return tb\\n \\n else:\\n tb = add_datecol(tb)\\n ix = np.in1d(tb[\\\"filter\\\"].values, np.array(['g', 'r', 'i']))\\n tb = tb[ix]\\n tb = tb[tb.mjd > 55352.5]\\n tb = tb[tb.mjd < 55593.5]\\n \\n dates = get_date_span(tb)\\n datesave = []\\n for i in range(len(dates)):\\n x = dates[i]\\n ix = tb[\\\"date\\\"].values == x\\n tbsub = tb[ix]\\n if len(tbsub)!=0:\\n flts = tbsub['filter'].values\\n if \\\"r\\\" in flts and np.sum(np.unique(flts))!=1:\\n datesave.append(x)\\n datesave = np.array(datesave)\\n \\n mcolor = []\\n mcolor_unc = []\\n mjds = []\\n colorname = []\\n for i in range(len(datesave)):\\n x = datesave[i]\\n ix = tb[\\\"date\\\"].values == x\\n tbsub = tb[ix]\\n gtb = tbsub[tbsub[\\\"filter\\\"].values==\\\"g\\\"]\\n rtb = tbsub[tbsub[\\\"filter\\\"].values==\\\"r\\\"]\\n itb = tbsub[tbsub[\\\"filter\\\"].values==\\\"i\\\"]\\n if len(gtb)!=0:\\n gmjds = gtb[\\\"mjd\\\"].values\\n gmags = gtb[\\\"mag0\\\"].values\\n gemags = gtb[\\\"emag\\\"].values\\n gwtgs = 1/gemags**2\\n gmag = np.sum(gmags * gwtgs) / np.sum(gwtgs)\\n gmjd = np.sum(gmjds * gwtgs) / np.sum(gwtgs)\\n gemag = 1/ np.sqrt(np.sum(gwtgs))\\n if len(rtb)!=0:\\n rmjds = rtb[\\\"mjd\\\"].values\\n rmags = rtb[\\\"mag0\\\"].values\\n remags = rtb[\\\"emag\\\"].values\\n rwtgs = 1/remags**2\\n rmag = np.sum(rmags * rwtgs) / np.sum(rwtgs)\\n rmjd = np.sum(rmjds * rwtgs) / np.sum(rwtgs)\\n remag = 1/ np.sqrt(np.sum(rwtgs))\\n if len(itb)!=0:\\n imjds = itb[\\\"mjd\\\"].values\\n imags = itb[\\\"mag0\\\"].values\\n iemags = itb[\\\"emag\\\"].values\\n iwtgs = 1/iemags**2\\n imag = np.sum(imags * iwtgs) / np.sum(iwtgs)\\n imjd = np.sum(imjds * iwtgs) / np.sum(iwtgs)\\n iemag = 1/ np.sqrt(np.sum(iwtgs))\\n if len(gtb)!=0 and len(rtb)!=0:\\n mcolor.append(gmag - rmag)\\n mjds.append( 0.5 * (gmjd + rmjd) )\\n mcolor_unc.append( np.sqrt(gemag**2 + remag**2) )\\n colorname.append(\\\"gmr\\\")\\n if len(rtb)!=0 and len(itb)!=0:\\n mcolor.append(rmag - imag)\\n mjds.append( 0.5 * (rmjd + imjd) )\\n mcolor_unc.append( np.sqrt(remag**2 + iemag**2) )\\n colorname.append(\\\"rmi\\\")\\n \\n ctb = Table(data = [mjds, mcolor, mcolor_unc, colorname],\\n names = [\\\"mjd\\\", \\\"c\\\", \\\"ec\\\", \\\"cname\\\"])\\n \\n ctb['tmax_rf'] = (ctb['mjd'] - t_max) / (1+z)\\n ctb = ctb.to_pandas()\\n return ctb\",\n \"def visualize(z_in, azimuth=25., elevation=30.,\\n thresholds=[0.95, .9, .75, .5, .25, .125], opacities=[1, .9, .7, .5, .2, .1],\\n# thresholds=[0.94, .89, .75, .5, .25, .1], opacities=[.9, .8, .7, .5, .2, .1],\\n# thresholds=[0.94, .89, .75], opacities=[.99, .7, .2],\\n# thresholds=[0.7, .5, .2], opacities=[.95, .5, .2],\\n fourier_label = {'f_x':'f_x', 'f_y':'f_y', 'f_t':'f_t'},\\n filename=None, do_axis=True, do_grids=False, draw_projections=True,\\n colorbar=False, f_N=2., f_tN=2., figsize=figsize, dpi=300, figpath=figpath, **kwargs):\\n z = z_in.copy()\\n N_X, N_Y, N_frame = z.shape\\n fx, fy, ft = get_grids(N_X, N_Y, N_frame)\\n\\n # Normalize the amplitude.\\n z /= z.max()\\n\\n from vispy import app, scene, use\\n try:\\n AffineTransform = scene.transforms.AffineTransform\\n except:\\n AffineTransform = scene.transforms.MatrixTransform\\n\\n use(app='pyglet', gl='pyopengl2')\\n #from vispy.util.transforms import perspective, translate, rotate\\n from vispy.color import Color\\n transparent = Color(color='black', alpha=0.)\\n import colorsys\\n canvas = scene.SceneCanvas(size=figsize, bgcolor='white', dpi=dpi)\\n view = canvas.central_widget.add_view()\\n\\n vol_data = np.rollaxis(np.rollaxis(z, 1), 2)\\n# volume = scene.visuals.Volume(vol_data, parent=view.scene)#frame)\\n center = scene.transforms.STTransform(translate=( -N_X/2, -N_Y/2, -N_frame/2))\\n# volume.transform = center\\n# volume.cmap = 'blues'\\n\\n if draw_projections:\\n from vispy.color import Colormap\\n cm = Colormap([(1.0, 1.0, 1.0, 1.0), 'k'])\\n opts = {'parent':view.scene, 'cmap':cm, 'clim':(0., 1.)}\\n\\n energy_xy = np.rot90(np.max(z, axis=2)[:, ::-1], 3)#[:, ::-1]\\n fourier_xy = scene.visuals.Image(np.rot90(energy_xy), **opts)\\n tr_xy = AffineTransform()\\n tr_xy.rotate(90, (0, 0, 1))\\n tr_xy.translate((N_X/2, -N_Y/2, -N_frame/2))\\n fourier_xy.transform = tr_xy\\n\\n energy_xt = np.rot90(np.max(z, axis=1)[:, ::-1], 3)[::-1, ::-1]\\n fourier_xt = scene.visuals.Image(energy_xt, **opts)\\n tr_xt = AffineTransform()\\n tr_xt.rotate(90, (1, 0, 0))\\n tr_xt.translate((-N_X/2, N_Y/2, -N_frame/2))\\n fourier_xt.transform = tr_xt\\n\\n energy_yt = np.max(z, axis=0)[:, ::-1]\\n fourier_yt = scene.visuals.Image(energy_yt, **opts)\\n tr_yt = AffineTransform()\\n tr_yt.rotate(90, (0, 1, 0))\\n tr_yt.translate((-N_X/2, -N_Y/2, N_frame/2))\\n fourier_yt.transform = tr_yt\\n\\n # Generate iso-surfaces at different energy levels\\n surfaces = []\\n for i_, (threshold, opacity) in enumerate(zip(thresholds, opacities)):\\n surfaces.append(scene.visuals.Isosurface(z, level=threshold,\\n# color=Color(np.array(colorsys.hsv_to_rgb(1.*i_/len(thresholds), 1., 1.)), alpha=opacity),\\n color=Color(np.array(colorsys.hsv_to_rgb(.66, 1., 1.)), alpha=opacity),\\n shading='smooth', parent=view.scene)\\n )\\n surfaces[-1].transform = center\\n\\n # Draw a sphere at the origin\\n axis = scene.visuals.XYZAxis(parent=view.scene)\\n for p in ([1, 1, 1, -1, 1, 1], [1, 1, -1, -1, 1, -1], [1, -1, 1, -1, -1, 1],[1, -1, -1, -1, -1, -1],\\n [1, 1, 1, 1, -1, 1], [-1, 1, 1, -1, -1, 1], [1, 1, -1, 1, -1, -1], [-1, 1, -1, -1, -1, -1],\\n [1, 1, 1, 1, 1, -1], [-1, 1, 1, -1, 1, -1], [1, -1, 1, 1, -1, -1], [-1, -1, 1, -1, -1, -1]):\\n line = scene.visuals.Line(pos=np.array([[p[0]*N_X/2, p[1]*N_Y/2, p[2]*N_frame/2], [p[3]*N_X/2, p[4]*N_Y/2, p[5]*N_frame/2]]), color='black', parent=view.scene)\\n\\n axisX = scene.visuals.Line(pos=np.array([[0, -N_Y/2, 0], [0, N_Y/2, 0]]), color='red', parent=view.scene)\\n axisY = scene.visuals.Line(pos=np.array([[-N_X/2, 0, 0], [N_X/2, 0, 0]]), color='green', parent=view.scene)\\n axisZ = scene.visuals.Line(pos=np.array([[0, 0, -N_frame/2], [0, 0, N_frame/2]]), color='blue', parent=view.scene)\\n\\n if do_axis:\\n t = {}\\n for text in ['f_x', 'f_y', 'f_t']:\\n t[text] = scene.visuals.Text(fourier_label[text], parent=canvas.scene, face='Helvetica', color='black')\\n t[text].font_size = 8\\n t['f_x'].pos = canvas.size[0] // 3, canvas.size[1] - canvas.size[1] // 8\\n t['f_y'].pos = canvas.size[0] - canvas.size[0] // 8, canvas.size[1] - canvas.size[1] // 6\\n t['f_t'].pos = canvas.size[0] // 8, canvas.size[1] // 2\\n\\n cam = scene.TurntableCamera(elevation=elevation, azimuth=azimuth, up='z')\\n cam.fov = 48\\n cam.scale_factor = N_X * 1.8\\n if do_axis: margin = 1.35\\n else: margin = 1\\n cam.set_range((-N_X/2*margin, N_X/2/margin), (-N_Y/2*margin, N_Y/2/margin), (-N_frame/2*margin, N_frame/2/margin))\\n view.camera = cam\\n\\n render_im = canvas.render()\\n app.quit()\\n if not(filename is None):\\n import vispy.io as io\\n io.write_png(filename, render_im)\\n else:\\n return render_im\",\n \"def plot_uwrz_field(f=False,ax=False, oro='h500a7', vm=[-2,2],tinst=18,var='QVrz',ik=0,jk=0):\\n\\n tinst = int(tinst)\\n \\n # in case f is not passed, f and ax are created\\n if not f:\\n f,ax=plt.subplots()\\n\\n # Name the axes \\n decorate_ax(ax,'',daytime(tinst),'')\\n \\n\\n # specify full path of the data\\n\\n iensmean = 1\\n \\n if iensmean:\\n srcpath = BASE3D + oro + '/' + sm +'/' + CIRCMEAN\\n print srcpath\\n else: # 1 single ensemble member first day\\n srcpath = BASE3D + oro + '/' + sm +'/'\\n seedname= filter(lambda x: x.startswith('circmean_seed'), os.listdir(srcpath))[0]\\n srcpath +=seedname\\n\\n # Open the data in netcdf format and read it only \\n ncfl = Dataset(srcpath,'r')\\n \\n # Load the fields of interest\\n # COSMO fields dimensions are (time, z,rlat,rlon)\\n #\\n # Field dimensions in the following are (time,z,r)\\n #\\n # By specifing '::-1' the second timension is inverted\\n urz = ncfl.variables['Urz'][tinst,::-1,:] # U component of wind\\n wrz = ncfl.variables['Wrz'][tinst,::-1,:] # W component of wind\\n\\n speedrz = ncfl.variables['Speedrz'][tinst,::-1,:] # wind speed\\n rhorz = ncfl.variables['RHOrz'][:,::-1,:] # density in rz coordinates\\n TOTP = ncfl.variables['TOT_PRECr'][:,:]/2. # half-hourly output\\n \\n LCLr= ncfl.variables['LCL_MLr'][tinst,:]/1000. # LCL\\n LFCr = ncfl.variables['LFC_MLr'][tinst,:]/1000. # LFC\\n hPBLr = ncfl.variables['HPBLr'][tinst,:]/1000. \\n \\n CAPEr = ncfl.variables['CAPE_MLr'][tinst,:] # CAPE\\n CINr = ncfl.variables['CIN_MLr'][tinst,:] # CIN\\n \\n TOTPsum = np.sum(TOTP[:tinst,:],axis=0)\\n TOTPsum = TOTP[tinst,:]\\n \\n TPthres = 0.5\\n rainyr=np.where(TOTPsum>TPthres)\\n\\n\\n if var: #select a specific humidity var\\n qvrz = ncfl.variables[var][:,::-1,:] # specficif humidity\\n qcrz = ncfl.variables['QCrz'][:,::-1,:]\\n else: # otherwise sum it all up:\\n qxrzvars = filter(lambda x: x.startswith('Q'),ncfl.variables.keys())\\n \\n qvrz = np.zeros(ncfl.variables['QVrz'].shape)\\n for var in qxrzvars:\\n print var\\n qvrz+=ncfl.variables[var][:,::-1,:]\\n \\n tref = 12 # 06:00\\n ipltdiff= 0\\n if ipltdiff:\\n plotvar = rhorz[tinst,:]*qvrz[tinst,:]-rhorz[tref,:]*qvrz[tref,:]\\n qcrz = rhorz[tinst,:]*qcrz[tinst,:]-rhorz[tref,:]*qcrz[tref,:]\\n else:\\n plotvar = rhorz[tinst,:]*qvrz[tinst,:]\\n \\n\\n rhorz = rhorz[tinst,:]\\n \\n \\n # Load the grid in r, z coordinate\\n X = ncfl.variables['X'][:]\\n \\n \\n # nasty and temporary workaround as Z is empty in single seed data - just\\n # take it from the circmean field\\n srcpath2 = BASE3D + oro + '/' + sm +'/' + CIRCMEAN\\n ncfl2=Dataset(srcpath2)\\n Z = ncfl2.variables['Z'][::-1,:]/1000. # highest index <-> ground\\n ncfl2.close() \\n \\n # Add mountain contour\\n r=X[0,:]\\n ax.plot(r,Z[0,:],color='grey',linewidth=2)\\n \\n# ax.plot(r,hPBLr,'k-.',linewidth=1)\\n# ax.plot(r,LCLr,'k-',linewidth=1) \\n \\n ax.fill_between(X[0,:],Z[0,:],0,color='lightgrey')\\n \\n #indicate rainy region\\n \\n ifillrainy = False\\n if ifillrainy:\\n ax.fill_between(X[0,rainyr][0],Z[0,rainyr][0],color='lightblue',alpha=0.8) \\n ax.plot(X[0,rainyr][0],Z[0,rainyr][0],color='lightblue',linewidth=2)\\n else:\\n pass#ax.plot(X[0,rainyr][0],Z[0,rainyr][0],color='blue',linewidth=2,linestyle='dashed')\\n \\n # Velocity vectors with speed (length) smaller than speedthres are not \\n # shown\\n oroorig = oro\\n if oro.endswith('bell') or oro.endswith('cos2'):\\n \\n oro = oro[:-5]\\n print oro\\n \\n i,j=np.where(expnames==oro)\\n\\n if i==[]:\\n print 'HH'\\n \\n oro = oro.split('_')[0]\\n h,a = getha(oro)\\n #h,a = hrange[i],arange[j]\\n print h,a\\n xrang = [0,40]\\n yrang = [0,10.]\\n delx = xrang[1]-xrang[0]\\n dely = yrang[1]-yrang[0]\\n \\n speedthres = 0.1# m/s\\n M = speedrz[:] < speedthres\\n U = ma.masked_array(urz[:,:],mask=M)\\n scalefac_w = 1. #delx/dely\\n W = ma.masked_array(scalefac_w*wrz[:,:],mask=M) \\n \\n \\n \\n if 0: # REMOVE\\n fact_agl = -dely/delx\\n sin = np.arcsin(fact_agl)\\n cos = np.arccos(fact_agl)\\n U=cos*U-sin*W\\n W=sin*U+cos*W\\n # Plot radial velocity\\n urzlevs = np.linspace(vm[0],vm[1],10)\\n\\n\\n levs = np.array([2,4,6,8,10,12,14,16])\\n #levs = np.array([0.25,0.5,1,2,4,8,16,32])\\n #levs = np.array([0.5,1,2,4,8,16,32])\\n if ipltdiff:\\n levs=levs/8. #np.linspace(0.001,0.004,11)d\\n #else:\\n # levs=np.array([0.001,0.0015,0.002,0.0025,0.003,0.0035,0.004])*50\\n #if var.startswith('QC'): levs=np.linspace(0.1,1.5,9)/1000.\\n \\n #cf = ax.contourf(X,Z,plotvar*1000., levels=levs*1000.,cmap=viridis_inv,extend='both')\\n \\n ipltmoistening = False \\n if ipltmoistening:\\n cf = ax.contourf(X,Z,plotvar*1000.,cmap=viridis_inv,extend='both',\\n levels=levs)\\n else:\\n cf = 0\\n \\n #cfc = ax.contourf(X,Z,qvrz*1000.,cmap='Blues',extend='both', alpha=1,\\n # levels=levs/4.) \\n\\n iplt_thermodynvar = False\\n if iplt_thermodynvar:\\n for var in [LFCr]:\\n print var.shape\\n print X.shape\\n ax.plot(var)\\n \\n \\n qstx = 2\\n qstz = 2\\n Q=ax.quiver(X[::qstz,::qstx],(Z+0.02)[::qstz,::qstx],U[::qstz,::qstx],W[::qstz,::qstx],\\n units='inches',scale=10,angles='xy', color='red',pivot='mid',\\n headwidth=4,width=0.009)\\n #Q=ax.quiverkey(Q,a/2,h/2000.,1,r'$1\\\\frac{m}{s}$',labelpos='N',coordinates='data')\\n\\n if jk==2 or oroorig.endswith('cos2'):#(ik,jk)==(1,0):\\n ax.quiverkey(Q,-2,0.05,1,r'$1 \\\\frac{m}{s}$',labelsep=0.05,\\n labelpos='N',coordinates='data')\\n\\n\\n ax.set_xticks(np.arange(0,80,20)) \\n\\n ax.set_xlim(xrang)\\n ax.set_ylim(yrang)\\n\\n if ik==2:\\n ax.set_xlabel('r in km')\\n if jk==0:\\n ax.set_ylabel('z in km') \\n \\n ax.grid(True)\\n\\n ncfl.close()\\n \\n return f,ax ,cf # plot_uwrz_field\",\n \"def get_iPTF16hgs(colorplt = False):\\n z = 0.017\\n ebv = 0\\n D = cosmo.luminosity_distance([z])[0].value * 1e+6 # in pc\\n dis_mod = 5*np.log10(D / 10)\\n \\n tb = pd.read_csv('../data/otherSN/iPTF16hgs/table1.txt', sep=\\\"\\\\t\\\")\\n tb = tb.drop(columns=[\\\"Unnamed: 5\\\"])\\n tb = tb.rename(columns={'Filter' : 'filter',\\n 'MJD': 'mjd'})\\n tb = tb[~np.array([x[0]=='>' for x in tb['Magnitude'].values])]\\n tb['mag'] = np.array([float(x.split(\\\" +or-\\\")[0]) for x in tb['Magnitude'].values])\\n tb['emag'] = np.array([float(x.split(\\\" +or-\\\")[1]) for x in tb['Magnitude'].values])\\n tb = tb.drop(columns=[\\\"Magnitude\\\"])\\n \\n ixg = tb['filter'].values == \\\"g\\\"\\n ixr = tb['filter'].values == \\\"r\\\"\\n ixi = tb['filter'].values == \\\"i\\\"\\n tb['wave'] = np.zeros(len(tb))\\n tb['wave'].values[ixg] = 4814\\n tb['wave'].values[ixr] = 6422\\n tb['wave'].values[ixi] = 7883\\n tb['mag0'] = tb['mag'] - extinction.ccm89(tb['wave'].values, 3.1*ebv, 3.1)\\n tb['mag0_abs'] = tb['mag0'] - dis_mod\\n t_max = 57691.59 # from the paper\\n tb['tmax_of'] = tb['mjd'] - t_max\\n tb['tmax_rf'] = (tb['mjd'] - t_max) / (1+z)\\n \\\"\\\"\\\"\\n plt.errorbar(tb[\\\"tmax_rf\\\"].values[ixg], tb[\\\"mag\\\"].values[ixg], tb[\\\"emag\\\"].values[ixg], fmt=\\\".g\\\")\\n plt.errorbar(tb[\\\"tmax_rf\\\"].values[ixr], tb[\\\"mag\\\"].values[ixr], tb[\\\"emag\\\"].values[ixr], fmt=\\\".r\\\")\\n plt.errorbar(tb[\\\"tmax_rf\\\"].values[ixi], tb[\\\"mag\\\"].values[ixi], tb[\\\"emag\\\"].values[ixi], fmt=\\\".y\\\")\\n \\\"\\\"\\\"\\n tb = add_datecol(tb)\\n tb = add_physcol(tb)\\n #tb = tb.drop(columns=[\\\"datetime64\\\"])\\n if colorplt==False:\\n return tb\\n else:\\n #tb = tb[tb.mjd > 55352.5]\\n #tb = tb[tb.mjd < 55593.5]\\n \\n dates = get_date_span(tb)\\n datesave = []\\n for i in range(len(dates)):\\n x = dates[i]\\n ix = tb[\\\"date\\\"].values == x\\n tbsub = tb[ix]\\n if len(tbsub)!=0:\\n flts = tbsub['filter'].values\\n if \\\"r\\\" in flts and np.sum(np.unique(flts))!=1:\\n datesave.append(x)\\n datesave = np.array(datesave)\\n \\n mcolor = []\\n mcolor_unc = []\\n mjds = []\\n colorname = []\\n for i in range(len(datesave)):\\n x = datesave[i]\\n ix = tb[\\\"date\\\"].values == x\\n tbsub = tb[ix]\\n gtb = tbsub[tbsub[\\\"filter\\\"].values==\\\"g\\\"]\\n rtb = tbsub[tbsub[\\\"filter\\\"].values==\\\"r\\\"]\\n itb = tbsub[tbsub[\\\"filter\\\"].values==\\\"i\\\"]\\n if len(gtb)!=0:\\n gmjds = gtb[\\\"mjd\\\"].values\\n gmags = gtb[\\\"mag0\\\"].values\\n gemags = gtb[\\\"emag\\\"].values\\n gwtgs = 1/gemags**2\\n gmag = np.sum(gmags * gwtgs) / np.sum(gwtgs)\\n gmjd = np.sum(gmjds * gwtgs) / np.sum(gwtgs)\\n gemag = 1/ np.sqrt(np.sum(gwtgs))\\n if len(rtb)!=0:\\n rmjds = rtb[\\\"mjd\\\"].values\\n rmags = rtb[\\\"mag0\\\"].values\\n remags = rtb[\\\"emag\\\"].values\\n rwtgs = 1/remags**2\\n rmag = np.sum(rmags * rwtgs) / np.sum(rwtgs)\\n rmjd = np.sum(rmjds * rwtgs) / np.sum(rwtgs)\\n remag = 1/ np.sqrt(np.sum(rwtgs))\\n if len(itb)!=0:\\n imjds = itb[\\\"mjd\\\"].values\\n imags = itb[\\\"mag0\\\"].values\\n iemags = itb[\\\"emag\\\"].values\\n iwtgs = 1/iemags**2\\n imag = np.sum(imags * iwtgs) / np.sum(iwtgs)\\n imjd = np.sum(imjds * iwtgs) / np.sum(iwtgs)\\n iemag = 1/ np.sqrt(np.sum(iwtgs))\\n if len(gtb)!=0 and len(rtb)!=0:\\n mcolor.append(gmag - rmag)\\n mjds.append( 0.5 * (gmjd + rmjd) )\\n mcolor_unc.append( np.sqrt(gemag**2 + remag**2) )\\n colorname.append(\\\"gmr\\\")\\n if len(rtb)!=0 and len(itb)!=0:\\n mcolor.append(rmag - imag)\\n mjds.append( 0.5 * (rmjd + imjd) )\\n mcolor_unc.append( np.sqrt(remag**2 + iemag**2) )\\n colorname.append(\\\"rmi\\\")\\n \\n ctb = Table(data = [mjds, mcolor, mcolor_unc, colorname],\\n names = [\\\"mjd\\\", \\\"c\\\", \\\"ec\\\", \\\"cname\\\"])\\n \\n ctb['tmax_rf'] = (ctb['mjd'] - t_max) / (1+z)\\n ctb = ctb.to_pandas()\\n return ctb\",\n \"def flatNoiseCGH():\\n #Get data\\n wdir = '/home/rallured/Dropbox/AXRO/Metrology/NoiseStudy/FlatMeasurements/'\\n d1,dx1 = met.read4DFits(wdir+'161205_RefFlat_Avg8_Meas1.fits')\\n d2,dx2 = met.read4DFits(wdir+'161205_RefFlat_Avg8_Meas2.fits')\\n p1,px1 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestPitch_Meas1.fits')\\n p2,px2 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestPitch_Meas2.fits')\\n p3,px3 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestRoll_Meas1.fits')\\n p4,px4 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestRoll_Meas2.fits')\\n\\n #Construct baseline power spectra\\n f1,pow1 = fourier.meanPSD(d1-d2,win=np.hanning,dx=dx1)\\n f2,pow2 = fourier.meanPSD(d1-d2,win=np.hanning,dx=dx1,axis=1)\\n \\n #Construct parroted power spectra\\n f3,pow3 = fourier.meanPSD(p1-p2,win=np.hanning,dx=dx1)\\n f4,pow4 = fourier.meanPSD(p1-p2,win=np.hanning,dx=dx2,axis=1)\\n f5,pow5 = fourier.meanPSD(p3-p4,win=np.hanning,dx=dx1)\\n f6,pow6 = fourier.meanPSD(p3-p4,win=np.hanning,dx=dx2,axis=1)\\n\\n #Plot\\n plt.loglog(f1,pow1/f1[0],label='Axial Baseline')\\n plt.loglog(f2,pow2/f2[0],label='Azimuthal Baseline')\\n plt.loglog(f3,pow3/f3[0],label='Pitch Axial')\\n plt.loglog(f4,pow4/f4[0],label='Pitch Azimuthal')\\n plt.loglog(f5,pow5/f5[0],label='Roll Axial')\\n plt.loglog(f6,pow6/f6[0],label='Roll Azimuthal')\\n plt.title('Residual Fringe Repeatability Impact')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n plt.legend(loc='lower left')\\n\\n return f1,pow1\",\n \"def plotTI():\\n min_dl = dlam[dlam != 0].min()\\n S = int(0.4/min_dl)\\n fig = pl.figure(figsize = (8,6))\\n ax = fig.add_subplot(1,1,1)\\n ax.spines['bottom'].set_position('zero')\\n ax.spines['top'].set_color('none')\\n ax.spines['right'].set_color('none')\\n ax.xaxis.set_ticks_position('bottom')\\n ax.yaxis.set_ticks_position('left')\\n\\n for k, spine in ax.spines.items():\\n spine.set_zorder(12.2)\\n\\n xs, ndx, dx = [0], 0, 0.001\\n colors = ['r', 'g', '#7F38EC', '#9F000F', 'b', 'y']\\n min_y, max_y = 0, 0\\n\\n lines = tuple()\\n ## lv_names2 = [r'$Coulomb$', r'$vdWaals$'] ## for the paper\\n lv_names2 = []\\n for j in range(n_components):\\n y = ave_dhdl[:,j]\\n if not (y == 0).all():\\n lv_names2.append(r'$%s$' % P.lv_names[j].capitalize())\\n\\n for j in range(n_components):\\n\\n y = ave_dhdl[:,j]\\n if not (y == 0).all():\\n\\n # Get the coordinates.\\n lj = lchange[:,j]\\n x = lv[:,j][lj]\\n y = y[lj]/P.beta_report\\n\\n if 'TI' in P.methods:\\n # Plot the TI integration area.\\n ss = 'TI'\\n for i in range(len(x)-1):\\n min_y = min(y.min(), min_y)\\n max_y = max(y.max(), max_y)\\n #pl.plot(x,y)\\n if i%2==0:\\n pl.fill_between(x[i:i+2]+ndx, 0, y[i:i+2], color=colors[ndx], alpha=1.0)\\n else:\\n pl.fill_between(x[i:i+2]+ndx, 0, y[i:i+2], color=colors[ndx], alpha=0.5)\\n xlegend = [-100*wnum for wnum in range(len(lv_names2))]\\n pl.plot(xlegend, [0*wnum for wnum in xlegend], ls='-', color=colors[ndx], label=lv_names2[ndx]) ## for the paper\\n\\n if 'TI-CUBIC' in P.methods and not cubspl[j]==0:\\n # Plot the TI-CUBIC interpolation curve.\\n ss += ' and TI-CUBIC'\\n xnew = numpy.arange(0, 1+dx, dx)\\n ynew = cubspl[j].interpolate(y, xnew)\\n min_y = min(ynew.min(), min_y)\\n max_y = max(ynew.max(), max_y)\\n pl.plot(xnew+ndx, ynew, color='#B6B6B4', ls ='-', solid_capstyle='round', lw=3.0)\\n\\n else:\\n # Plot the TI-CUBIC integration area.\\n ss = 'TI-CUBIC'\\n for i in range(len(x)-1):\\n xnew = numpy.arange(x[i], x[i+1]+dx, dx)\\n ynew = cubspl[j].interpolate(y, xnew)\\n ynew[0], ynew[-1] = y[i], y[i+1]\\n min_y = min(ynew.min(), min_y)\\n max_y = max(ynew.max(), max_y)\\n if i%2==0:\\n pl.fill_between(xnew+ndx, 0, ynew, color=colors[ndx], alpha=1.0)\\n else:\\n pl.fill_between(xnew+ndx, 0, ynew, color=colors[ndx], alpha=0.5)\\n\\n # Store the abscissa values and update the subplot index.\\n xs += (x+ndx).tolist()[1:]\\n ndx += 1\\n\\n # Make sure the tick labels are not overcrowded.\\n xs = numpy.array(xs)\\n dl_mat = numpy.array([xs-i for i in xs])\\n ri = range(len(xs))\\n\\n def getInd(r=ri, z=[0]):\\n primo = r[0]\\n min_dl=ndx*0.02*2**(primo>10)\\n if dl_mat[primo].max()<min_dl:\\n return z\\n for i in r:\\n for j in range(len(xs)):\\n if dl_mat[i,j]>min_dl:\\n z.append(j)\\n return getInd(ri[j:], z)\\n\\n xt = [i if (i in getInd()) else '' for i in range(K)]\\n pl.xticks(xs[1:], xt[1:], fontsize=10)\\n pl.yticks(fontsize=10)\\n #ax = pl.gca()\\n #for label in ax.get_xticklabels():\\n # label.set_bbox(dict(fc='w', ec='None', alpha=0.5))\\n\\n # Remove the abscissa ticks and set up the axes limits.\\n for tick in ax.get_xticklines():\\n tick.set_visible(False)\\n pl.xlim(0, ndx)\\n min_y *= 1.01\\n max_y *= 1.01\\n pl.ylim(min_y, max_y)\\n\\n for i,j in zip(xs[1:], xt[1:]):\\n pl.annotate(('%.2f' % (i-1.0 if i>1.0 else i) if not j=='' else ''), xy=(i, 0), xytext=(i, 0.01), size=10, rotation=90, textcoords=('data', 'axes fraction'), va='bottom', ha='center', color='#151B54')\\n if ndx>1:\\n lenticks = len(ax.get_ymajorticklabels()) - 1\\n if min_y<0: lenticks -= 1\\n if lenticks < 5:\\n from matplotlib.ticker import AutoMinorLocator as AML\\n ax.yaxis.set_minor_locator(AML())\\n pl.grid(which='both', color='w', lw=0.25, axis='y', zorder=12)\\n pl.ylabel(r'$\\\\mathrm{\\\\langle{\\\\frac{ \\\\partial U } { \\\\partial \\\\lambda }}\\\\rangle_{\\\\lambda}\\\\/%s}$' % P.units, fontsize=20, color='#151B54')\\n pl.annotate('$\\\\mathit{\\\\lambda}$', xy=(0, 0), xytext=(0.5, -0.05), size=18, textcoords='axes fraction', va='top', ha='center', color='#151B54')\\n if not P.software.title()=='Sire':\\n lege = ax.legend(prop=FP(size=14), frameon=False, loc=1)\\n for l in lege.legendHandles:\\n l.set_linewidth(10)\\n pl.savefig(os.path.join(P.output_directory, 'dhdl_TI.pdf'))\\n pl.close(fig)\\n return\",\n \"def plot_raft_map(data, img, TITLE, OUTDIR, vmin=None, vmax=None):\\n\\n map = np.zeros((6, 24))\\n for i, fli in enumerate(img):\\n x = (fli.dev_index / 3) * 2 # [0, 2, 4]\\n y = (fli.dev_index % 3) * 8 # [0, 8, 16]\\n for j in range(16):\\n xx = x + j / 8 # [0, 1,..., 5]\\n yy = y + j % 8 # [0, 1,..., 23]\\n map[xx, yy] = data[i, j]\\n\\n yseg = range(6)\\n ylab = [\\\"00-07\\\", \\\"10-17\\\", \\\"00-07\\\", \\\"10-17\\\", \\\"00-07\\\", \\\"10-17\\\"]\\n xseg = range(0, 24, 4)\\n xlab = [\\\"0\\\", \\\"4\\\", \\\"0\\\", \\\"4\\\", \\\"0\\\", \\\"4\\\"]\\n\\n fig = plt.figure(figsize=(10, 10))\\n ax1 = fig.add_subplot(111)\\n im = ax1.imshow(map, interpolation='nearest', cmap='jet', aspect=4, vmin=vmin, vmax=vmax)\\n plt.yticks(yseg, ylab)\\n plt.xticks(xseg, xlab)\\n plt.annotate('S22', xy=(0, 0), xytext=(4, -0.8), fontsize=15, ha='center', va='center')\\n plt.annotate('S12', xy=(0, 0), xytext=(12, -0.8), fontsize=15, ha='center', va='center')\\n plt.annotate('S02', xy=(0, 0), xytext=(20, -0.8), fontsize=15, ha='center', va='center')\\n plt.annotate('S02', xy=(0, 0), xytext=(24., 0.5), fontsize=15, ha='left', va='center')\\n plt.annotate('S01', xy=(0, 0), xytext=(24., 2.5), fontsize=15, ha='left', va='center')\\n plt.annotate('S00', xy=(0, 0), xytext=(24., 4.5), fontsize=15, ha='left', va='center')\\n ax1.vlines(7.5, -0.5, 5.5)\\n ax1.vlines(15.5, -0.5, 5.5)\\n ax1.hlines(1.5, -0.5, 23.5)\\n ax1.hlines(3.5, -0.5, 23.5)\\n plt.subplots_adjust(left=0.07, bottom=0.05, right=0.8, top=0.95, wspace=0, hspace=0)\\n #cbar_ax = fig.add_axes([0.15, 0.03, 0.7, 0.05])\\n #fig.colorbar(im, cax=cbar_ax, orientation=\\\"horizontal\\\")\\n cbar_ax = fig.add_axes([0.87, 0.15, 0.05, 0.7])\\n fig.colorbar(im, cax=cbar_ax)\\n fig.suptitle(TITLE, y=0.98, size=19)\\n plt.savefig(OUTDIR + TITLE + '.png')\\n plt.show()\\n plt.close(fig)\",\n \"def one_transition_spectrum_abs(self,tr):\\n \\n\\n ta = tr[\\\"ta\\\"] # TimeAxis\\n dd = tr[\\\"dd\\\"] # transition dipole strength\\n om = tr[\\\"om\\\"] # frequency - rwa\\n gg = tr[\\\"gg\\\"] # natural broadening (constant or time dependent)\\n fwhm = tr[\\\"fwhm\\\"] # Additional gaussian broadening of the spectra\\n sgm = fwhm/(2*numpy.sqrt(2*numpy.log(2)))\\n \\n # CD and fluorescence can be calculated in this step\\n # TODO if rotatory strength defined calculate also circular dichroism spectra\\n # TOOD calculate fluorescence spectra (for fluorescence there should be a switch because it should be calculated only for the first transition) \\n \\n \\n if self.system._has_system_bath_coupling:\\n# ct = tr[\\\"ct\\\"] # correlation function\\n \\n # convert correlation function to lineshape function\\n #gt = self._c2g(ta,ct.data)\\n gt = tr[\\\"gt\\\"]\\n # calculate time dependent response\\n at = numpy.exp(-gt -1j*om*ta.data)\\n else:\\n # calculate time dependent response\\n at = numpy.exp(-1j*om*ta.data) \\n# plt.figure()\\n# plt.title(\\\"Absorption\\\")\\n# plt.plot(ta.data,numpy.real(at))\\n# plt.plot(ta.data,numpy.imag(at))\\n \\n \\n if len(gg) == 1:\\n gam = gg[0]\\n rt = numpy.exp(gam*ta.data)\\n at *= rt\\n #print(\\\"Constant: \\\", rt[20], len(at))\\n else:\\n rt = numpy.exp((gg)*ta.data) \\n at *= rt\\n #print(\\\"Time dependent: len = \\\", rt[20], len(rt))\\n \\n if fwhm!=0.0:\\n gauss = numpy.exp(-2*(numpy.pi**2)*(sgm**2)*(ta.data**2))\\n at *= gauss\\n \\n # Fourier transform the result\\n ft = dd*numpy.fft.hfft(at)*ta.step\\n ft = numpy.fft.fftshift(ft)\\n # invert the order because hfft is a transform with -i\\n ft = numpy.flipud(ft) \\n # cut the center of the spectrum\\n Nt = ta.length #len(ta.data) \\n return ft[Nt//2:Nt+Nt//2]\",\n \"def main():\\n\\t#--------------------------------------------------------------------------#\\n\\t#\\t\\t\\t\\t\\t\\t Generate Polar Coordinates\\t\\t\\t\\t \\t #\\n\\t#--------------------------------------------------------------------------#\\n\\t#Mask - read in the fisheye mask center coordinates and radius\\n\\tmask = fits.open(p.mask,uint=False)[0].header\\n\\txc, yc, r0 = int(mask['CENTERX']), int(mask['CENTERY']), int(mask['RADIUS'])\\n\\tX, Y = n.meshgrid(n.arange(-r0,r0),n.arange(-r0,r0))\\n\\t\\n\\t#Polar coordinates\\n\\tr = n.sqrt(X**2+Y**2) / r0\\n\\ttheta = -n.arctan2(Y,X)\\n\\t\\n\\t#Fisheye takes r in degree\\n\\tr_deg = 90 * r\\n\\ttheta_f = theta + n.pi/2\\n\\t\\n\\t#Hammer plot requires the values to be sorted\\n\\tr_str = n.pi/2 - r * n.pi/2\\n\\tinds = n.argsort(theta[:,0])\\n\\ttheta_s = theta[inds,:] \\n\\tr_s = r_str[inds,:]\\n\\t\\n\\t\\n\\t#--------------------------------------------------------------------------#\\n\\t#\\t\\t\\t\\t\\t\\t Define Plot settings\\t\\t\\t\\t\\t\\t \\t #\\n\\t#--------------------------------------------------------------------------#\\n\\t#General plot settings\\n\\tplt.close('all')\\n\\tplt.style.use('dark_background')\\n\\tplt.rcParams['image.cmap'] = 'NPS_mag'\\n\\tcmap = copy.copy(mpl.cm.get_cmap(\\\"NPS_mag\\\"))\\n\\tcmap.set_bad(color='black')\\n\\t\\n\\t#Fisheye plot setting\\n\\tfig0 = plt.figure('fisheye') \\n\\tax0 = fig0.add_subplot(111, projection='polar')\\n\\tax0.set_rlim(0,90)\\n\\tax0.set_yticklabels([])\\n\\tax0.tick_params(colors='darkgray')\\n\\tax0.set_theta_zero_location('N') \\n\\t\\n\\t#Hammer plot setting\\n\\tfig1 = plt.figure('hammer',figsize=(15,5.2))\\n\\tax1 = fig1.add_subplot(111, projection=\\\"upper_hammer\\\")\\n\\tfig1.tight_layout(rect=(0.03,-0.6,0.98,0.97))\\n\\t\\n\\t#Suppressing a MatPlotLib benign warning about pcolormesh shading\\n\\twarnings.filterwarnings(\\\"ignore\\\",category=UserWarning)\\n\\n\\t#--------------------------------------------------------------------------#\\n\\t#\\t\\t\\t\\tPlot the image in fisheye and Hammer projections\\t\\t #\\n\\t#--------------------------------------------------------------------------#\\n\\tfor f in glob(p.data_cal+'*sky*.fit'):\\n\\t\\tprint('projecting ' + f[len(p.data_cal):])\\n\\t\\timg = fits.open(f,uint=False)[0].data[yc-r0:yc+r0,xc-r0:xc+r0]\\n\\t\\timg_hammer = rotate(img.astype('float32'),-90,cval=n.nan)[inds,:]\\n\\t\\t\\n\\t\\t#plot fisheye\\n\\t\\tax0.pcolormesh(theta_f,r_deg,img,shading='auto',vmin=14,vmax=24)\\n\\t\\tax0.grid(True, color='gray', linestyle='dotted', linewidth=.5)\\n\\t\\tfig0.savefig(f[:-4]+'_fisheye.png', dpi=250)\\n\\t\\t\\n\\t\\t#plot hammer\\n\\t\\tax1.pcolormesh(theta_s,r_s,img_hammer,shading='auto',vmin=14,vmax=24)\\n\\t\\tax1.grid(True)\\n\\t\\tfig1.savefig(f[:-4]+'_hammer.png')\",\n \"def P_AI_Rocky2(in_dict):\\n # START\\n fs = 16\\n plt.rc('font', size=fs)\\n fig = plt.figure(figsize=(8,12))\\n ds = nc.Dataset(in_dict['fn'])\\n\\n # PLOT CODE\\n aa = [-122.8, -122.54, 47.92, 48.22]\\n # import cmocean\\n # cmap = cmocean.cm.speed\\n # cmap = 'RdYlBu_r'\\n cmap = 'Spectral_r'\\n\\n from warnings import filterwarnings\\n filterwarnings('ignore') # skip some warning messages\\n \\n # plot Code\\n \\n # calculate speed\\n uu = ds['u'][0, -1, :, :]\\n vv = ds['v'][0, -1, :, :]\\n u = zfun.fillit(uu)\\n v = zfun.fillit(vv)\\n u[np.isnan(u)] = 0\\n v[np.isnan(v)] = 0\\n # interpolate to the clipped rho grid\\n ur = (u[1:-1,1:] + u[1:-1,:-1])/2\\n vr = (v[1:,1:-1] + v[:-1,1:-1])/2\\n spd = np.sqrt(ur**2 + vr**2)\\n spd[spd==0] = np.nan\\n \\n G = zrfun.get_basic_info(in_dict['fn'], only_G=True)\\n \\n # panel 1\\n ax = fig.add_subplot(111)\\n cs = plt.pcolormesh(G['lon_psi'], G['lat_psi'], spd, cmap=cmap,\\n vmin=0, vmax=1.5)\\n tstr = (r'Admiralty Inlet Surface Speed ($m\\\\ s^{-1}$)')\\n #pfun.add_bathy_contours(ax, ds, txt=True)\\n pfun.add_coast(ax)\\n ax.axis(aa)\\n pfun.dar(ax)\\n ax.set_xlabel('Longitude')\\n ax.set_ylabel('Latitude')\\n ax.set_title(tstr)\\n pfun.add_info(ax, in_dict['fn'])\\n ax.set_xticks([-122.8, -122.7, -122.6])\\n ax.set_yticks([48, 48.1, 48.2])\\n \\n # Inset colorbar\\n from mpl_toolkits.axes_grid1.inset_locator import inset_axes\\n cbaxes = inset_axes(ax, width=\\\"4%\\\", height=\\\"30%\\\", loc='upper right', borderpad=3)\\n fig.colorbar(cs, cax=cbaxes, orientation='vertical')\\n \\n #pfun.add_bathy_contours(ax, ds)\\n pfun.add_coast(ax)\\n ax.axis(aa)\\n pfun.dar(ax)\\n ax.set_xlabel('Longitude')\\n ax.set_title(tstr)\\n \\n pfun.add_velocity_vectors(ax, ds, in_dict['fn'], v_scl=100, v_leglen=1,\\n nngrid=80, zlev='top', center=(.1,.05))\\n \\n fig.tight_layout()\\n # FINISH\\n ds.close()\\n if len(in_dict['fn_out']) > 0:\\n plt.savefig(in_dict['fn_out'])\\n plt.close()\\n else:\\n plt.show()\\n plt.rcdefaults()\",\n \"def get_sn2005ek(colorplt=False):\\n z = 0.016551\\n ebv = 0.210\\n D = cosmo.luminosity_distance([z])[0].value * 1e+6 # in pc\\n dis_mod = 5*np.log10(D / 10)\\n t_max = 53639.9\\n print (\\\"adopt r band t_max from Drout+13\\\")\\n \\n # tb = pd.read_csv('/Users/yuhanyao/Desktop/ZTF18abfcmjw/data/Drout2013/table1', sep='\\\\t')\\n # tb = tb.drop(columns=[\\\"Unnamed: 6\\\"])\\n \\n mjds = np.array([53639.3, 53640.3, 53641.3, 53642.2, 53643.2, 53645.3,\\n 53646.5, 53648.0, 53649.2, 53650.4, 53651.3, 53652.5,\\n 53654.2, 53655.2, 53656.2, 53657.2])\\n \\n Bmags = np.array([18.25, 18.38, 18.65, np.nan, 19.10, 19.71,\\n 20.07, np.nan, 20.67, 20.90, 21.05, np.nan,\\n 21.74, np.nan, np.nan, np.nan])\\n \\n Bmag_uncs = np.array([0.02, 0.03, 0.02, np.nan, 0.05, 0.07, \\n 0.07, np.nan, 0.04, 0.04, 0.04, np.nan,\\n 0.12, np.nan, np.nan, np.nan])\\n \\n Vmags = np.array([17.83, 18.03, 17.92, np.nan, 18.24, 18.66,\\n 18.93, 19.48, 19.63, 19.86, 19.98, 20.35,\\n 20.60, 20.74, 20.88, 21.22])\\n \\n Vmag_uncs = np.array([0.02, 0.03, 0.01, np.nan, 0.02, 0.02,\\n 0.02, 0.06, 0.03, 0.03, 0.04, 0.05, \\n 0.08, 0.10, 0.08, 0.13])\\n \\n Rmags = np.array([17.46, 17.41, 17.60, 17.69, 17.86, 18.18, \\n np.nan, 18.83, 19.03, 19.26, 19.48, 19.75,\\n 20.08, np.nan, 20.47, np.nan])\\n \\n Rmag_uncs = np.array([0.01, 0.02, 0.01, 0.02, 0.01, 0.01,\\n np.nan, 0.03, 0.02, 0.02, 0.02, 0.04,\\n 0.05, np.nan, 0.08, np.nan])\\n\\n Imags = np.array([17.20, 17.13, 17.18, np.nan, 17.47, 17.71, \\n np.nan, 18.13, 18.26, 18.51, 18.61, 18.74, \\n 19.01, np.nan, 19.47, np.nan])\\n \\n Imag_uncs = np.array([0.02, 0.04, 0.02, np.nan, 0.03, 0.02,\\n np.nan, 0.06, 0.02, 0.02, 0.02, 0.03,\\n 0.05, np.nan, 0.06, np.nan])\\n \\n mymjds = np.hstack([mjds, mjds, mjds, mjds])\\n mymags = np.hstack([Bmags, Vmags, Rmags, Imags])\\n myemags = np.hstack([Bmag_uncs, Vmag_uncs, Rmag_uncs, Imag_uncs])\\n myfilts = np.hstack([ np.repeat(\\\"B\\\", len(Bmags)),\\n np.repeat(\\\"V\\\", len(Bmags)),\\n np.repeat(\\\"R\\\", len(Rmags)),\\n np.repeat(\\\"I\\\", len(Imags)) ])\\n ix = ~np.isnan(mymags)\\n tb = pd.DataFrame({'mjd': mymjds[ix],\\n 'mag': mymags[ix],\\n 'emag': myemags[ix],\\n \\\"filter\\\": myfilts[ix]})\\n \\n ixB = tb['filter'].values==\\\"B\\\"\\n ixV = tb['filter'].values==\\\"V\\\"\\n ixR = tb['filter'].values==\\\"R\\\"\\n ixI = tb['filter'].values==\\\"I\\\"\\n \\n tb['wave'] = np.zeros(len(tb))\\n tb['wave'].values[ixB] = 4359\\n tb['wave'].values[ixV] = 5430\\n tb['wave'].values[ixR] = 6349\\n tb['wave'].values[ixI] = 8797\\n \\n tb['mag0'] = tb['mag'] - extinction.ccm89(tb['wave'].values, 3.1*ebv, 3.1)\\n tb['mag0_abs'] = tb['mag0'] - dis_mod\\n tb['tmax_rf'] = (tb['mjd'] - t_max) / (1+z)\\n if colorplt==False:\\n return tb\\n else:\\n tb = add_datecol(tb)\\n ix = np.in1d(tb[\\\"filter\\\"].values, np.array(['B', 'R', 'I']))\\n tb = tb[ix]\\n\\n dates = get_date_span(tb)\\n datesave = []\\n for i in range(len(dates)):\\n x = dates[i]\\n ix = tb[\\\"date\\\"].values == x\\n tbsub = tb[ix]\\n if len(tbsub)!=0:\\n flts = tbsub['filter'].values\\n if \\\"R\\\" in flts and np.sum(np.unique(flts))!=1:\\n datesave.append(x)\\n datesave = np.array(datesave)\\n \\n mcolor = []\\n mcolor_unc = []\\n mjds = []\\n colorname = []\\n for i in range(len(datesave)):\\n x = datesave[i]\\n ix = tb[\\\"date\\\"].values == x\\n tbsub = tb[ix]\\n gtb = tbsub[tbsub[\\\"filter\\\"].values==\\\"B\\\"]\\n rtb = tbsub[tbsub[\\\"filter\\\"].values==\\\"R\\\"]\\n itb = tbsub[tbsub[\\\"filter\\\"].values==\\\"I\\\"]\\n if len(gtb)!=0:\\n gmjds = gtb[\\\"mjd\\\"].values\\n gmags = gtb[\\\"mag0\\\"].values\\n gemags = gtb[\\\"emag\\\"].values\\n gwtgs = 1/gemags**2\\n gmag = np.sum(gmags * gwtgs) / np.sum(gwtgs)\\n gmjd = np.sum(gmjds * gwtgs) / np.sum(gwtgs)\\n gemag = 1/ np.sqrt(np.sum(gwtgs))\\n if len(rtb)!=0:\\n rmjds = rtb[\\\"mjd\\\"].values\\n rmags = rtb[\\\"mag0\\\"].values\\n remags = rtb[\\\"emag\\\"].values\\n rwtgs = 1/remags**2\\n rmag = np.sum(rmags * rwtgs) / np.sum(rwtgs)\\n rmjd = np.sum(rmjds * rwtgs) / np.sum(rwtgs)\\n remag = 1/ np.sqrt(np.sum(rwtgs))\\n if len(itb)!=0:\\n imjds = itb[\\\"mjd\\\"].values\\n imags = itb[\\\"mag0\\\"].values\\n iemags = itb[\\\"emag\\\"].values\\n iwtgs = 1/iemags**2\\n imag = np.sum(imags * iwtgs) / np.sum(iwtgs)\\n imjd = np.sum(imjds * iwtgs) / np.sum(iwtgs)\\n iemag = 1/ np.sqrt(np.sum(iwtgs))\\n if len(gtb)!=0 and len(rtb)!=0:\\n mcolor.append(gmag - rmag)\\n mjds.append( 0.5 * (gmjd + rmjd) )\\n mcolor_unc.append( np.sqrt(gemag**2 + remag**2) )\\n colorname.append(\\\"BmR\\\")\\n if len(rtb)!=0 and len(itb)!=0:\\n mcolor.append(rmag - imag)\\n mjds.append( 0.5 * (rmjd + imjd) )\\n mcolor_unc.append( np.sqrt(remag**2 + iemag**2) )\\n colorname.append(\\\"RmI\\\")\\n \\n ctb = Table(data = [mjds, mcolor, mcolor_unc, colorname],\\n names = [\\\"mjd\\\", \\\"c\\\", \\\"ec\\\", \\\"cname\\\"])\\n \\n ctb['tmax_rf'] = (ctb['mjd'] - t_max) / (1+z)\\n ctb = ctb.to_pandas()\\n return ctb\",\n \"def hexapodZernikeLinearModel_hexapodcoordinate():\\n Tfile='/home/jghao/research/decamFocus/psf_withseeing/finerGrid_coeff_matrix/zernike_coeff_finerGrid_training.cp'\\n b=p.load(open(Tfile))\\n nobs = len(b)\\n x = b[:,0]\\n y = b[:,1]\\n z = b[:,2]\\n theta = b[:,3]\\n phi = b[:,4]\\n fwhm = b[:,5]\\n e1 = b[:,6]\\n e2 = b[:,7]\\n thetax = theta*np.cos(np.deg2rad(phi))\\n thetay = theta*np.sin(np.deg2rad(phi))\\n xh = x*1000 # convert to hexapod coordinate\\n yh = -y*1000\\n zh = -z*1000\\n xtilth = - thetay\\n ytilth = - thetax\\n\\n M22realTrefoil2 = b[:,37] # for x decenter\\n M22imagTrefoil1 = b[:,54] \\n M22TrefoilXshift = 0.5*(M22realTrefoil2+M22imagTrefoil1)\\n\\n M22realTrefoil1 = b[:,34] # for y decenter\\n M22imagTrefoil2 = b[:,57] \\n M22TrefoilYshift = 0.5*(M22realTrefoil1 - M22imagTrefoil2)\\n\\n M20defocus = b[:,12] # for defocus\\n\\n M22realComa2 = b[:,36] # for x-tilt\\n M22imagComa1 = b[:,55]\\n M22ComaXtilt = 0.5*(M22realComa2+M22imagComa1)\\n\\n M22realComa1 = b[:,35] # for y-tilt\\n M22imagComa2 = b[:,56]\\n M22ComaYtilt = 0.5*(M22realComa1 - M22imagComa2)\\n \\n pl.figure(figsize=(21,12))\\n pl.subplot(2,3,1)\\n t=bp.bin_scatter(M22TrefoilXshift,xh,nbins=20,fmt='bo',scatter=True)\\n res = linefit(M22TrefoilXshift,xh)\\n pl.plot(M22TrefoilXshift,M22TrefoilXshift*res[1]+res[0],'r,')\\n pl.ylabel('x-decenter [micron]')\\n pl.xlabel('(M22realTrefoil2+M22imagTrefoil1)/2')\\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\\n pl.grid()\\n pl.subplot(2,3,2)\\n t=bp.bin_scatter(M22TrefoilYshift,yh,nbins=20,fmt='bo',scatter=True)\\n res = linefit(M22TrefoilYshift,yh)\\n pl.plot(M22TrefoilYshift,M22TrefoilYshift*res[1]+res[0],'r,')\\n pl.ylabel('y-decenter [micron]')\\n pl.xlabel('(M22realTrefoil1 - M22imagTrefoil2)/2')\\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\\n pl.grid()\\n pl.subplot(2,3,3)\\n t=bp.bin_scatter(M20defocus,zh,nbins=20,fmt='bo',scatter=True)\\n res = linefit(M20defocus,zh)\\n pl.plot(M20defocus,M20defocus*res[1]+res[0],'r,')\\n pl.ylabel('z-defocus [micron]')\\n pl.xlabel('M20defocus')\\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\\n pl.grid()\\n pl.subplot(2,3,4)\\n t=bp.bin_scatter(M22ComaXtilt,ytilth,nbins=20,fmt='bo',scatter=True)\\n res = linefit(M22ComaXtilt,ytilth)\\n pl.plot(M22ComaXtilt,M22ComaXtilt*res[1]+res[0],'r,')\\n pl.ylabel('y-tilt [arcsec]') # in hexapod coordiate, xtilt and y tilt is switched from the CRAY coordiante\\n pl.xlabel('(M22realComa2+M22imagComa1)/2')\\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\\n pl.grid()\\n pl.subplot(2,3,5)\\n t=bp.bin_scatter(M22ComaYtilt,xtilth,nbins=20,fmt='bo',scatter=True)\\n res = linefit(M22ComaYtilt,xtilth)\\n pl.plot(M22ComaYtilt,M22ComaYtilt*res[1]+res[0],'r,')\\n pl.ylabel('x-tilt [arcsec]')\\n pl.xlabel('(M22realComa1 - M22imagComa2)/2')\\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\\n pl.grid()\\n pl.savefig('linearModel_hexapod_coordinate.png')\\n pl.close()\",\n \"def test_plot_color(self):\\n lname = os.path.join(self.datadir,\\n 'monol_testA_nustar_fpma_E_10-5_over_5-3') + \\\\\\n HEN_FILE_EXTENSION\\n cname = os.path.join(self.datadir,\\n 'monol_testA_nustar_fpma_E_10-5_over_5-3') + \\\\\\n HEN_FILE_EXTENSION\\n hen.plot.main([cname, lname, '--noplot', '--xlog', '--ylog', '--CCD',\\n '-o', 'dummy.qdp'])\",\n \"def show(im,fig= None): #X\\n im = im.copy()\\n if len(im.shape)==1 or im.shape[1]==1:\\n im = X2patch(im)\\n im[im<=DEAD]=-0.5\\n if fig is None:\\n plt.figure()\\n fig = plt.imshow(hsv_to_rgb(im+0.5))\\n fig.set_data(hsv_to_rgb(im+0.5))\\n plt.draw()\\n plt.pause(0.001)\\n return fig\",\n \"def fiducial_evolution():\\n \\n # fiducial model\\n wangle = 180*u.deg\\n pk = pickle.load(open('../data/gd1_fiducial.pkl', 'rb'))\\n x = pk['x'].to(u.kpc)\\n xorig = x[:2]\\n \\n plt.close()\\n fig, ax = plt.subplots(1,1,figsize=(6,6))\\n \\n plt.sca(ax)\\n \\n Nsnap = 8\\n times = np.linspace(0,0.5,Nsnap)[::-1]\\n angles = np.linspace(0,322,Nsnap)[::-1]*u.deg\\n\\n for e, t in enumerate(times):\\n c = mpl.cm.Blues(0.05+0.85*(Nsnap-e)/Nsnap)\\n #a = 0.5 + 0.5*(Nsnap-e)/Nsnap\\n \\n pk = pickle.load(open('../data/gd1_fiducial_t{:.4f}.pkl'.format(t), 'rb'))\\n x = pk['x'].to(u.kpc)\\n x_, y_ = x[0], x[1]\\n \\n plt.plot(x_[120:-120], y_[120:-120], '.', color=c, ms=10, zorder=Nsnap-e, rasterized=False)\\n \\n xt = 24*np.cos(angles[e]+90*u.deg)\\n yt = 24*np.sin(angles[e]+90*u.deg)\\n if e<Nsnap-1:\\n txt = plt.text(xt, yt, '+ {:.2f} Gyr'.format(t), va='center', ha='center', fontsize='small', color='0.2', rotation=(angles[e]).value, zorder=10)\\n txt.set_bbox(dict(facecolor='w', alpha=0.7, ec='none'))\\n \\n plt.text(0, 24, 'Flyby', va='center', ha='center', fontsize='small', color='0.2')\\n\\n lim = 27\\n plt.xlim(-lim,lim)\\n plt.ylim(-lim,lim)\\n plt.gca().set_aspect('equal')\\n \\n plt.xlabel('x [kpc]')\\n plt.ylabel('y [kpc]')\\n \\n plt.tight_layout()\\n plt.savefig('../plots/loop_evolution.pdf')\",\n \"def one_transition_spectrum_fluor(self,tr):\\n \\n\\n ta = tr[\\\"ta\\\"] # TimeAxis\\n dd = tr[\\\"dd\\\"] # transition dipole strength\\n om = tr[\\\"om\\\"] # frequency - rwa\\n gg = tr[\\\"gg\\\"] # natural broadening (constant or time dependent)\\n fwhm = tr[\\\"fwhm\\\"] # Additional gaussian broadening of the spectra\\n sgm = fwhm/(2*numpy.sqrt(2*numpy.log(2)))\\n \\n # CD and fluorescence can be calculated in this step\\n # TODO if rotatory strength defined calculate also circular dichroism spectra\\n # TOOD calculate fluorescence spectra (for fluorescence there should be a switch because it should be calculated only for the first transition) \\n \\n \\n if self.system._has_system_bath_coupling:\\n# ct = tr[\\\"ct\\\"] # correlation function\\n re = tr[\\\"re\\\"] # reorganisation energy\\n \\n # convert correlation function to lineshape function\\n #gt = self._c2g(ta,ct.data)\\n gt = tr[\\\"gt\\\"]\\n # calculate time dependent response\\n at = numpy.exp(-numpy.conjugate(gt) -1j*om*ta.data + 2j*re*ta.data)\\n else:\\n # calculate time dependent response\\n at = numpy.exp(-1j*om*ta.data) \\n# plt.figure()\\n# plt.title(\\\"Absorption\\\")\\n# plt.plot(ta.data,numpy.real(at))\\n# plt.plot(ta.data,numpy.imag(at))\\n \\n \\n if len(gg) == 1:\\n gam = gg[0]\\n rt = numpy.exp(gam*ta.data)\\n at *= rt\\n #print(\\\"Constant: \\\", rt[20], len(at))\\n else:\\n rt = numpy.exp((gg)*ta.data) \\n at *= rt\\n #print(\\\"Time dependent: len = \\\", rt[20], len(rt))\\n \\n if fwhm!=0.0:\\n gauss = numpy.exp(-2*(numpy.pi**2)*(sgm**2)*(ta.data**2))\\n at *= gauss\\n \\n # Fourier transform the result\\n ft = dd*numpy.fft.hfft(at)*ta.step\\n ft = numpy.fft.fftshift(ft)\\n # invert the order because hfft is a transform with -i\\n ft = numpy.flipud(ft) \\n # cut the center of the spectrum\\n Nt = ta.length #len(ta.data) \\n return ft[Nt//2:Nt+Nt//2]\",\n \"def plotCombinedIncludingOceanFloors(self):\\n self.CombinedPlotHelper(minc=70,maxc=170,num=50)\",\n \"def results_plot_fuel_reactor(self):\\n \\n import matplotlib.pyplot as plt \\n\\n # Total pressure profile\\n P = []\\n for z in self.MB_fuel.z:\\n P.append(value(self.MB_fuel.P[z]))\\n fig_P = plt.figure(1)\\n plt.plot(self.MB_fuel.z, P)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Total Pressure [bar]\\\") \\n\\n # Temperature profile\\n Tg = []\\n Ts = []\\n# Tw = []\\n for z in self.MB_fuel.z:\\n Tg.append(value(self.MB_fuel.Tg[z] - 273.15))\\n Ts.append(value(self.MB_fuel.Ts[z] - 273.15))\\n# Tw.append(value(self.MB_fuel.Tw[z]))\\n fig_T = plt.figure(2)\\n plt.plot(self.MB_fuel.z, Tg, label='Tg')\\n plt.plot(self.MB_fuel.z, Ts, label='Ts')\\n# plt.plot(self.MB_fuel.z, Tw, label='Tw')\\n plt.legend(loc=0,ncol=2)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Temperature [C]\\\") \\n \\n # Superficial gas velocity and minimum fluidization velocity\\n vg = []\\n umf = []\\n for z in self.MB_fuel.z:\\n vg.append(value(self.MB_fuel.vg[z]))\\n umf.append(value(self.MB_fuel.umf[z]))\\n fig_vg = plt.figure(3)\\n plt.plot(self.MB_fuel.z, vg, label='vg')\\n plt.plot(self.MB_fuel.z, umf, label='umf')\\n plt.legend(loc=0,ncol=2)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Superficial gas velocity [m/s]\\\")\\n \\n # Gas components molar flow rate\\n for j in self.MB_fuel.GasList:\\n F = []\\n for z in self.MB_fuel.z:\\n F.append(value(self.MB_fuel.F[z,j]))\\n fig_F = plt.figure(4)\\n plt.plot(self.MB_fuel.z, F, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Gas component molar flow rate, F [mol/s]\\\") \\n \\n # Bulk gas phase total molar flow rate\\n Ftotal = []\\n for z in self.MB_fuel.z:\\n Ftotal.append(value(self.MB_fuel.Ftotal[z]))\\n fig_Ftotal = plt.figure(5)\\n plt.plot(self.MB_fuel.z, Ftotal)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Total molar gas flow rate [mol/s]\\\") \\n\\n # Solid components mass flow rate\\n for j in self.MB_fuel.SolidList:\\n M = []\\n for z in self.MB_fuel.z:\\n M.append(value(self.MB_fuel.Solid_M[z,j]))\\n fig_M = plt.figure(6)\\n plt.plot(self.MB_fuel.z, M, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Solid components mass flow rate [kg/s]\\\")\\n \\n # Bulk solid phase total molar flow rate\\n Mtotal = []\\n for z in self.MB_fuel.z:\\n Mtotal.append(value(self.MB_fuel.Solid_M_total[z]))\\n fig_Mtotal = plt.figure(7)\\n plt.plot(self.MB_fuel.z, Mtotal)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Solid total mass flow rate [kg/s]\\\") \\n \\n # Gas phase concentrations\\n for j in self.MB_fuel.GasList:\\n Cg = []\\n for z in self.MB_fuel.z:\\n Cg.append(value(self.MB_fuel.Cg[z,j]))\\n fig_Cg = plt.figure(8)\\n plt.plot(self.MB_fuel.z, Cg, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Concentration [mol/m3]\\\") \\n \\n # Gas phase mole fractions\\n for j in self.MB_fuel.GasList:\\n y = []\\n for z in self.MB_fuel.z:\\n y.append(value(self.MB_fuel.y[z,j]))\\n fig_y = plt.figure(9)\\n plt.plot(self.MB_fuel.z, y, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"y [-]\\\") \\n \\n # Solid phase mass fractions\\n for j in self.MB_fuel.SolidList:\\n x = []\\n for z in self.MB_fuel.z:\\n x.append(value(self.MB_fuel.x[z,j]))\\n fig_x = plt.figure(10)\\n plt.plot(self.MB_fuel.z, x, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"x [-]\\\") \\n\\n # Total mass fraction\\n xtot = []\\n for z in self.MB_fuel.z:\\n xtot.append(value(self.MB_fuel.xtot[z]))\\n fig_xtot = plt.figure(11)\\n plt.plot(self.MB_fuel.z, xtot)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Total mass fraction [-]\\\") \\n \\n # # Gas mix density\\n # rhog = []\\n # for z in self.MB_fuel.z:\\n # rhog.append(value(self.MB_fuel.rho_vap[z]))\\n # fig_rhog = plt.figure(23)\\n # plt.plot(self.MB_fuel.z, rhog)\\n # plt.grid()\\n # plt.xlabel(\\\"Bed height [-]\\\")\\n # plt.ylabel(\\\"Gas mix density [kg/m3]\\\") \\n \\n # Fe conversion\\n X_Fe = []\\n for z in self.MB_fuel.z:\\n X_Fe.append(value(self.MB_fuel.X[z])*100)\\n fig_X_Fe = plt.figure(13)\\n plt.plot(self.MB_fuel.z, X_Fe)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Fraction of metal oxide converted [%]\\\")\",\n \"def SH_surface_plots(n_max=6,figsize=(15,15),fs=15,saveA=True,show=False,dpi=400,vis_type='real'):\\n\\n N = 100j\\n\\n for n in range(n_max+1):\\n for m in range(n+1):\\n plt.close('all')\\n print(\\\"working on Y_%s^%s\\\" % (n,m) )\\n\\n PHI,THETA = np.mgrid[0:2*np.pi:N*2, 0:np.pi:N]\\n if vis_type == 'real':\\n R = sp.sph_harm(m,n,PHI,THETA).real\\n if vis_type == 'modulus':\\n r = sp.sph_harm(m,n,PHI,THETA)\\n R = r * r.conjugate()\\n if vis_type == 'unit':\\n R = sp.sph_harm(m,n,PHI,THETA).real + 1\\n\\n X = np.abs(R) * np.sin(THETA) * np.cos(PHI)\\n Y = np.abs(R) * np.sin(THETA) * np.sin(PHI)\\n Z = np.abs(R) * np.cos(THETA)\\n\\n norm = colors.Normalize()\\n fig, ax = plt.subplots(subplot_kw=dict(projection='3d'), figsize=(14,10))\\n sm = cm.ScalarMappable(cmap=cm.seismic)\\n ax.plot_surface(X, Y, Z, rstride=1, cstride=1, facecolors=cm.seismic(norm(R)))\\n ax.set_title('real$(Y^%s_%s)$' % (m,n), fontsize=fs)\\n ax.set_aspect(1)\\n sm.set_array(R)\\n fig.colorbar(sm, shrink=0.8)\\n\\n if saveA:\\n fig.savefig('images/%s/%s_%s.png' % (vis_type,n,m), dpi=dpi)\\n if show:\\n plt.show()\\n\\n # print(\\\"\\\\n only +m values are used.\\\")\\n # for n in range(n_max+1):\\n # for m in range(n+1):\\n # plt.close('all')\\n # print(\\\"\\\\n n,m = %s,%s\\\" % (n,m) )\\n #\\n # R,X,Y,Z = harmonics(m,n)\\n #\\n # fig = plt.figure(figsize=figsize)\\n # ax = plt.subplot(projection='3d')\\n # ax.set_aspect(1)\\n # ax.set_title(\\\"n: %s m: %s\\\" % (n,m), fontsize=fs+2)\\n # ax.plot_surface(X,Y,Z,\\\\\\n # cmap = cm.seismic,\\n # norm = colors.Normalize( vmin=np.min(R),vmax=np.max(R) )\\\\\\n # )\\n #\\n # if saveA:\\n # fig.savefig('images/%s_%s.png' % (n,m), dpi=dpi)\\n # if show:\\n # plt.show()\",\n \"def _showcalibrationscreen(self, showtext=FALSE):\\r\\n maxX, maxY = self.START_RES\\r\\n bandWidth = 10\\r\\n blue = (0,0,255)\\r\\n red = (112,0,0)\\r\\n brightred = (255,0,0)\\r\\n green = (0,255,0)\\r\\n centerRE = (maxX/2),(maxY/2-35)/2\\r\\n centerLE = centerRE[0],centerRE[1]+(maxY/2 + 35)\\r\\n #why not fill with blue, draw red on.?\\r\\n #put the red on-- using avg of vals in _drawBackground()\\r\\n self.dscreen.fill(brightred) #2003-01-24-1101 now fill with red, the average of the two check values.\\r\\n #draw bands, over-under.\\r\\n \\r\\n yExtent = (maxY/2)-35\\r\\n #need overunder display.\\r\\n #draw on surface.\\r\\n #draw surface on screen 2x\\r\\n #also draw crosshairs 2x (long, narrow rects)\\r\\n myHorizCrossHair = pygame.Rect(0,0,maxX,1)\\r\\n myVertCrossHair = pygame.Rect(0,0,1,yExtent)\\r\\n \\r\\n #init rects and get them the right size. \\r\\n \\r\\n #rflist=[.04,.1,.12,.14] #reductionfactor\\r\\n rflist=[.04,.1,.12] #reductionfactor\\r\\n #colorlist=[green,red,blue,red]\\r\\n colorlist=[green,red,blue]\\r\\n \\r\\n def returnScaledCenteredColoredRect(reductionFactor,color): \\r\\n myrect = pygame.Rect(0,0,maxX*(1-reductionFactor),yExtent*(1-reductionFactor))\\r\\n myrect.center = centerRE\\r\\n return(color,myrect)\\r\\n \\r\\n rectlist = map(returnScaledCenteredColoredRect,rflist,colorlist)\\r\\n \\r\\n myHorizCrossHair.topleft = 0,yExtent/2-1\\r\\n myVertCrossHair.topleft = maxX/2-1,0\\r\\n \\r\\n for rect in rectlist:\\r\\n self.dscreen.fill(rect[0],rect[1])\\r\\n self.dscreen.fill((0,0,0),myHorizCrossHair)\\r\\n self.dscreen.fill((0,0,0),myVertCrossHair)\\r\\n\\r\\n \\r\\n for rect in rectlist:\\r\\n rect[1].center = centerLE\\r\\n \\r\\n myHorizCrossHair.topleft = 0,yExtent/2-1\\r\\n myHorizCrossHair.move_ip(0,maxY/2 + 35)\\r\\n myVertCrossHair.move_ip(0,maxY/2 + 35)\\r\\n\\r\\n for rect in rectlist:\\r\\n self.dscreen.fill(rect[0],rect[1])\\r\\n \\r\\n self.dscreen.fill((0,0,0),myHorizCrossHair)\\r\\n self.dscreen.fill((0,0,0),myVertCrossHair)\\r\\n\\r\\n\\r\\n if showtext:\\r\\n my_string = 'Adjust your position so you can see all of the blue ring and none of the red ring.\\\\n\\\\nPress [enter] to continue.' \\r\\n self._displayMessage(width=300,height=125,yPos=325,displayString=my_string,textColor=(216,216,216))\\r\\n else:\\r\\n pygame.display.update()\\r\\n \\r\\n pygame.event.get() #clear event queue, otherwise, was taking a long time and multiple enters could be pressed, bypassing calibration screen.\\r\\n while 1:\\r\\n event = pygame.event.wait()\\r\\n if (event.type == KEYDOWN) and (event.key == K_RETURN): \\r\\n break\",\n \"def display4(*args):\\n #-------------------- unpack\\n twiss_func = args[0]\\n cos_like = args[1]\\n sin_like = args[2]\\n lat_plot = args[3]\\n #-------------------- beta x,y & dispersion x\\n s = [twiss_func(i,'s') for i in range(twiss_func.nbpoints)] # Abszisse\\n bx = [twiss_func(i,'bx') for i in range(twiss_func.nbpoints)] # beta x\\n by = [twiss_func(i,'by') for i in range(twiss_func.nbpoints)] # beta y\\n dx = [twiss_func(i,'dx') for i in range(twiss_func.nbpoints)] # dispersion x\\n#-------------------- longitudinal trajectories\\n z1= [cos_like(i,'s') for i in range(cos_like.nbpoints)]\\n cz= [cos_like(i,'cz') for i in range(cos_like.nbpoints)]\\n cdp= [cos_like(i,'cdp') for i in range(cos_like.nbpoints)]\\n\\n z2= [sin_like(i,'s') for i in range(sin_like.nbpoints)]\\n sz= [sin_like(i,'sz') for i in range(sin_like.nbpoints)]\\n sdp= [sin_like(i,'sdp') for i in range(sin_like.nbpoints)]\\n #-------------------- lattice viseo\\n vzero = [0. for i in range(lat_plot.nbpoints)] # zero line\\n vis_abszisse = [lat_plot(i,'s') for i in range(lat_plot.nbpoints)]\\n vis_ordinate = [lat_plot(i,'viseo') for i in range(lat_plot.nbpoints)]\\n #-------------------- figure frame\\n width=14; height=7.6\\n # fighdr = 'lattice version = {}, input file = {}'.format(PARAMS['lattice_version'],PARAMS['input_file'])\\n fig = plt.figure(num=1,figsize=(width,height),facecolor='#eaecef',tight_layout=False)\\n\\n #-------------------- beta functions\\n splot211=plt.subplot(211)\\n splot211.set_title('beta x,y')\\n # mapping box\\n splot211.text(0.01, 1.1, UTIL.FLAGS.get('mapping'),transform=splot211.transAxes,fontsize=8,bbox=dict(boxstyle='round',facecolor='wheat',alpha=0.5),verticalalignment='top')\\n # function plots\\n plt.plot(s,bx, label=r\\\"$\\\\beta$x [m]\\\", color='black', linestyle='-')\\n plt.plot(s,by, label=r\\\"$\\\\beta$y [m]\\\", color='red', linestyle='-')\\n plt.plot(s,dx, label=r'$\\\\eta_x$ [m]' , color='green', linestyle='-') # dispersion x\\n vscale=splot211.axis()[3]*0.25\\n viseoz = [x*vscale for x in vis_ordinate]\\n plt.plot(vis_abszisse,viseoz,label='',color='black')\\n plt.plot(vis_abszisse,vzero,color='green',linestyle='--')\\n # zero line\\n splot211.plot(vis_abszisse,vzero,color='green',linestyle='--')\\n plt.legend(loc='lower right',fontsize='x-small')\\n\\n #-------------------- longitudinal tracks z, dP/P\\n # ax_l = left abszisse\\n ax_l=plt.subplot(212)\\n # ax_l=plt.subplot(10,1,(7,9))\\n ax_l.set_title('synchrotron oscillation')\\n ax_l.set_ylabel(r\\\"z [mm]\\\")\\n ax_l.tick_params(axis='y', colors='green')\\n ax_l.yaxis.label.set_color('green')\\n ax_l.plot(z1,cz,label='C',color='green')\\n ax_l.plot(z2,sz,label='S',color='green',linestyle=':')\\n plt.legend(loc='lower left',fontsize='x-small')\\n # ax_r = right abszisse\\n ax_r = ax_l.twinx()\\n ax_r.set_ylabel(r'$\\\\Delta$p/p [%]')\\n ax_r.tick_params(axis='y', colors='red')\\n ax_r.yaxis.label.set_color('red')\\n ax_r.plot(z2,cdp,label='C',color='red')\\n ax_r.plot(z2,sdp,label='S',color='red',linestyle=':')\\n ax_r.plot(vis_abszisse,vzero,color='red', linestyle='--')\\n plt.legend(loc='lower right',fontsize='x-small')\\n # lattice elements\\n vscale=ax_l.axis()[3]*0.25\\n viseoz = [x*vscale for x in vis_ordinate]\\n ax_l.plot(vis_abszisse,viseoz,label='',color='black')\\n ax_l.plot(vis_abszisse,vzero,color='green',linestyle='--')\",\n \"def plot_reconstruction_diagnostics(self, figsize=(20, 10)):\\n figs = []\\n fig_names = []\\n\\n # upsampled frequency\\n fx_us = tools.get_fft_frqs(2 * self.nx, 0.5 * self.dx)\\n fy_us = tools.get_fft_frqs(2 * self.ny, 0.5 * self.dx)\\n\\n # plot different stages of inversion\\n extent = tools.get_extent(self.fy, self.fx)\\n extent_upsampled = tools.get_extent(fy_us, fx_us)\\n\\n for ii in range(self.nangles):\\n fig = plt.figure(figsize=figsize)\\n grid = plt.GridSpec(3, 4)\\n\\n for jj in range(self.nphases):\\n\\n # ####################\\n # separated components\\n # ####################\\n ax = plt.subplot(grid[jj, 0])\\n\\n to_plot = np.abs(self.separated_components_ft[ii, jj])\\n to_plot[to_plot <= 0] = np.nan\\n plt.imshow(to_plot, norm=LogNorm(), extent=extent)\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 0:\\n plt.title('O(f)otf(f)')\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 1:\\n plt.title('m*O(f-fo)otf(f)')\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 2:\\n plt.title('m*O(f+fo)otf(f)')\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n # ####################\\n # deconvolved component\\n # ####################\\n ax = plt.subplot(grid[jj, 1])\\n\\n plt.imshow(np.abs(self.components_deconvolved_ft[ii, jj]), norm=LogNorm(), extent=extent)\\n\\n if jj == 0:\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 1:\\n plt.scatter(self.frqs[ii, 0], self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n elif jj == 2:\\n plt.scatter(-self.frqs[ii, 0], -self.frqs[ii, 1], edgecolor='r', facecolor='none')\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 0:\\n plt.title('deconvolved component')\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n # ####################\\n # shifted component\\n # ####################\\n ax = plt.subplot(grid[jj, 2])\\n\\n # avoid any zeros for LogNorm()\\n cs_ft_toplot = np.abs(self.components_shifted_ft[ii, jj])\\n cs_ft_toplot[cs_ft_toplot <= 0] = np.nan\\n plt.imshow(cs_ft_toplot, norm=LogNorm(), extent=extent_upsampled)\\n plt.scatter(0, 0, edgecolor='r', facecolor='none')\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 1:\\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n elif jj == 2:\\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n if jj == 0:\\n plt.title('shifted component')\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n # ####################\\n # normalized weights\\n # ####################\\n ax = plt.subplot(grid[jj, 3])\\n\\n to_plot = self.weights[ii, jj] / self.weight_norm\\n to_plot[to_plot <= 0] = np.nan\\n im2 = plt.imshow(to_plot, norm=LogNorm(), extent=extent_upsampled)\\n im2.set_clim([1e-5, 1])\\n fig.colorbar(im2)\\n\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n if jj == 1:\\n circ2 = matplotlib.patches.Circle(-self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n elif jj == 2:\\n circ2 = matplotlib.patches.Circle(self.frqs[ii], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n if jj == 0:\\n plt.title('normalized weight')\\n plt.setp(ax.get_xticklabels(), visible=False)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n\\n plt.xlim([-2 * self.fmax, 2 * self.fmax])\\n plt.ylim([2 * self.fmax, -2 * self.fmax])\\n\\n plt.suptitle('period=%0.3fnm at %0.3fdeg=%0.3frad, f=(%0.3f,%0.3f) 1/um\\\\n'\\n 'mod=%0.3f, min mcnr=%0.3f, wiener param=%0.2f\\\\n'\\n 'phases (deg) =%0.2f, %0.2f, %0.2f, phase diffs (deg) =%0.2f, %0.2f, %0.2f' %\\n (self.periods[ii] * 1e3, self.angles[ii] * 180 / np.pi, self.angles[ii],\\n self.frqs[ii, 0], self.frqs[ii, 1], self.mod_depths[ii, 1], np.min(self.mcnr[ii]), self.wiener_parameter,\\n self.phases[ii, 0] * 180/np.pi, self.phases[ii, 1] * 180/np.pi, self.phases[ii, 2] * 180/np.pi,\\n 0, np.mod(self.phases[ii, 1] - self.phases[ii, 0], 2*np.pi) * 180/np.pi,\\n np.mod(self.phases[ii, 2] - self.phases[ii, 0], 2*np.pi) * 180/np.pi))\\n\\n figs.append(fig)\\n fig_names.append('sim_combining_angle=%d' % (ii + 1))\\n\\n # #######################\\n # net weight\\n # #######################\\n figh = plt.figure(figsize=figsize)\\n grid = plt.GridSpec(1, 2)\\n plt.suptitle('Net weight, Wiener param = %0.2f' % self.wiener_parameter)\\n\\n ax = plt.subplot(grid[0, 0])\\n net_weight = np.sum(self.weights, axis=(0, 1)) / self.weight_norm\\n im = ax.imshow(net_weight, extent=extent_upsampled, norm=PowerNorm(gamma=0.1))\\n\\n figh.colorbar(im, ticks=[1, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 1e-2, 1e-3, 1e-4, 1e-5])\\n\\n ax.set_title(\\\"non-linear scale\\\")\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n circ2 = matplotlib.patches.Circle((0, 0), radius=2*self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ3)\\n\\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ4)\\n\\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ5)\\n\\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ6)\\n\\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ7)\\n\\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ8)\\n\\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\\n\\n ax = plt.subplot(grid[0, 1])\\n ax.set_title(\\\"linear scale\\\")\\n im = ax.imshow(net_weight, extent=extent_upsampled)\\n\\n figh.colorbar(im)\\n circ = matplotlib.patches.Circle((0, 0), radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ)\\n\\n circ2 = matplotlib.patches.Circle((0, 0), radius=2 * self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ2)\\n\\n circ3 = matplotlib.patches.Circle(self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ3)\\n\\n circ4 = matplotlib.patches.Circle(-self.frqs[0], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ4)\\n\\n circ5 = matplotlib.patches.Circle(self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ5)\\n\\n circ6 = matplotlib.patches.Circle(-self.frqs[1], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ6)\\n\\n circ7 = matplotlib.patches.Circle(self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ7)\\n\\n circ8 = matplotlib.patches.Circle(-self.frqs[2], radius=self.fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ8)\\n\\n ax.set_xlim([-2 * self.fmax, 2 * self.fmax])\\n ax.set_ylim([2 * self.fmax, -2 * self.fmax])\\n\\n figs.append(figh)\\n fig_names.append('net_weight')\\n\\n return figs, fig_names\",\n \"def plot_colour_mag_diagram(params,mags, colours, local_mags, local_colours,\\n target, source, blend, RC, blue_filter, red_filter,\\n yaxis_filter, tol, log):\\n\\n def calc_colour_lightcurve(blue_lc, red_lc, y_lc):\\n\\n idx1 = np.where( red_lc['mag_err'] > 0.0 )[0]\\n idx2 = np.where( blue_lc['mag_err'] > 0.0 )[0]\\n idx3 = np.where( y_lc['mag_err'] > 0.0 )[0]\\n idx = set(idx1).intersection(set(idx2))\\n idx = list(idx.intersection(set(idx3)))\\n\\n mags = y_lc['mag'][idx]\\n magerr = y_lc['mag_err'][idx]\\n cols = blue_lc['mag'][idx] - red_lc['mag'][idx]\\n colerr = np.sqrt(blue_lc['mag_err'][idx]**2 + red_lc['mag_err'][idx]**2)\\n\\n return mags, magerr, cols, colerr\\n\\n\\n add_source_trail = False\\n add_target_trail = True\\n add_crosshairs = True\\n add_source = True\\n add_blend = True\\n add_rc_centroid = True\\n add_extinction_vector = True\\n\\n fig = plt.figure(1,(10,10))\\n\\n ax = plt.subplot(111)\\n\\n plt.rcParams.update({'font.size': 18})\\n\\n plt.scatter(colours,mags,\\n c='#E1AE13', marker='.', s=1,\\n label='Stars within ROME field')\\n\\n plt.scatter(local_colours,local_mags,\\n c='#8c6931', marker='*', s=4,\\n label='Stars < '+str(round(tol,1))+'arcmin of target')\\n\\n col_key = blue_filter+red_filter\\n\\n if getattr(source,blue_filter) != None and getattr(source,red_filter) != None\\\\\\n and add_source:\\n\\n plt.errorbar(getattr(source,col_key), getattr(source,yaxis_filter),\\n yerr = getattr(source,'sig_'+yaxis_filter),\\n xerr = getattr(source,'sig_'+col_key), color='m',\\n marker='d',markersize=10, label='Source crosshairs')\\n\\n if add_crosshairs:\\n plot_crosshairs(fig,getattr(source,col_key),getattr(source,yaxis_filter),'m')\\n\\n if add_source_trail:\\n red_lc = source.lightcurves[red_filter]\\n blue_lc = source.lightcurves[blue_filter]\\n y_lc = source.lightcurves[yaxis_filter]\\n\\n (smags, smagerr, scols, scolerr) = calc_colour_lightcurve(blue_lc, red_lc, y_lc)\\n\\n plt.errorbar(scols, smags, yerr = smagerr, xerr = scolerr,\\n color='m', marker='d',markersize=10, label='Source')\\n\\n if getattr(blend,blue_filter) != None and getattr(blend,red_filter) != None \\\\\\n and add_blend:\\n\\n plt.errorbar(getattr(blend,col_key), getattr(blend,yaxis_filter),\\n yerr = getattr(blend,'sig_'+yaxis_filter),\\n xerr = getattr(blend,'sig_'+col_key), color='b',\\n marker='v',markersize=10, label='Blend')\\n\\n if getattr(target,blue_filter) != None and getattr(target,red_filter) != None \\\\\\n and add_target_trail:\\n\\n plt.errorbar(getattr(target,col_key), getattr(target,yaxis_filter),\\n yerr = getattr(target,'sig_'+yaxis_filter),\\n xerr = getattr(target,'sig_'+col_key), color='k',\\n marker='x',markersize=10)\\n\\n red_lc = target.lightcurves[red_filter]\\n blue_lc = target.lightcurves[blue_filter]\\n y_lc = target.lightcurves[yaxis_filter]\\n\\n (tmags, tmagerr, tcols, tcolerr) = calc_colour_lightcurve(blue_lc, red_lc, y_lc)\\n\\n plt.errorbar(tcols, tmags, yerr = tmagerr,xerr = tcolerr,\\n color='k', marker='+',markersize=10, alpha=0.4,\\n label='Blended target')\\n\\n if add_rc_centroid:\\n plt.errorbar(getattr(RC,col_key), getattr(RC,yaxis_filter),\\n yerr=getattr(RC,'sig_'+yaxis_filter),\\n xerr=getattr(RC,'sig_'+col_key),\\n color='g', marker='s',markersize=10, label='Red Clump centroid')\\n\\n plt.xlabel('SDSS ('+blue_filter+'-'+red_filter+') [mag]')\\n\\n plt.ylabel('SDSS-'+yaxis_filter+' [mag]')\\n\\n [xmin,xmax,ymin,ymax] = plt.axis()\\n\\n plt.axis([xmin,xmax,ymax,ymin])\\n\\n xticks = np.arange(xmin,xmax,0.1)\\n yticks = np.arange(ymin,ymax,0.2)\\n\\n ax.set_xticks(xticks,minor=True)\\n ax.set_yticks(yticks,minor=True)\\n\\n plot_file = path.join(params['red_dir'],'colour_magnitude_diagram_'+\\\\\\n yaxis_filter+'_vs_'+blue_filter+red_filter\\\\\\n +'.pdf')\\n\\n plt.grid()\\n\\n if red_filter == 'i' and blue_filter == 'r' and yaxis_filter == 'i':\\n plt.axis([0.5,2.0,20.2,13.5])\\n\\n if red_filter == 'i' and blue_filter == 'r' and yaxis_filter == 'r':\\n plt.axis([0.0,1.5,21.0,13.5])\\n\\n if red_filter == 'r' and blue_filter == 'g':\\n plt.axis([0.5,3.0,22.0,14.0])\\n\\n if red_filter == 'i' and blue_filter == 'g':\\n plt.axis([0.5,4.4,22.0,14.0])\\n\\n if add_extinction_vector:\\n plot_extinction_vector(fig,params,yaxis_filter)\\n\\n box = ax.get_position()\\n ax.set_position([box.x0, box.y0 + box.height * -0.025,\\n box.width, box.height * 0.95])\\n\\n l = ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.2), ncol=2)\\n\\n l.legendHandles[0]._sizes = [50]\\n l.legendHandles[1]._sizes = [50]\\n\\n plt.rcParams.update({'legend.fontsize':18})\\n plt.rcParams.update({'font.size':18})\\n plt.rc('xtick', labelsize=18)\\n plt.rc('ytick', labelsize=18)\\n\\n plt.savefig(plot_file,bbox_inches='tight')\\n\\n plt.close(1)\\n\\n log.info('Colour-magnitude diagram output to '+plot_file)\",\n \"def plot_carrier_frequency(self):\\r\\n roi = self.phase_roi\\r\\n phase_slice = (slice(roi[2], roi[3]), slice(roi[0], roi[1]))\\r\\n # calculation\\r\\n S = self.image[phase_slice] # signal in phase_roi\\r\\n t_axis = self.image.x_axis[roi[0]:roi[1]] # [ns] time axis\\r\\n y_axis = self.image.y_axis[roi[2]:roi[3]] # [mic] spatial scale\\r\\n N = S.shape[0]//2\\r\\n\\r\\n s = np.fft.fft(S, axis=0) / N # fft\\r\\n s_abs = np.abs(s[:N,:])\\r\\n f_axis = np.arange(N) / (2 * N) # spatial frequency axis\\r\\n\\r\\n s_mean = np.log10(np.mean(s_abs, axis=1))\\r\\n i0 = np.argmax(s_mean[3:])\\r\\n f0 = f_axis[3+i0] # [px^-1] fringe carrier frequency (estimate)\\r\\n s0 = s_mean[3+i0]\\r\\n sys.stdout.write(\\\"{} VISAR-{} fringe period = {:.1f} px\\\\n\\\".format(\\r\\n self.h5.shot_id[:11], self.leg, 1/f0))\\r\\n\\r\\n # plot calcs\\r\\n vlim_0 = dataimage.thresh_vlim(S, 0.01)\\r\\n vlim_1 = dataimage.thresh_vlim(np.log10(s_abs), (0.02, 0.005))\\r\\n tlim = (t_axis[0], t_axis[-1])\\r\\n ylim = (y_axis[0], y_axis[-1])\\r\\n flim = (0, 0.5) # [1/px]\\r\\n extent_0 = tlim + (0, S.shape[0]) # extent for signal\\r\\n# extent_0 = tlim + ylim # extent for signal\\r\\n extent_1 = tlim + flim # extent for fft\\r\\n\\r\\n # figure\\r\\n fig = plt.figure(figsize=(7,7), dpi=100)\\r\\n axs = []\\r\\n axs.append(fig.add_subplot(221, ylabel='[px]', title='signal'))\\r\\n axs.append(fig.add_subplot(222, sharey=axs[0], title='spatial lineout'))\\r\\n axs.append(fig.add_subplot(223, sharex=axs[0], title='log(fft(signal))',\\r\\n xlabel='time [ns]', ylabel=\\\"spatial frequency [px^-1]\\\"))\\r\\n axs.append(fig.add_subplot(224, sharey=axs[2], xlabel='log10(power)', title='spectral lineout'))\\r\\n\\r\\n axs[0].imshow(S, extent=extent_0,\\r\\n aspect='auto', vmin=vlim_0[0], vmax=vlim_0[1])\\r\\n axs[2].imshow(np.log10(s_abs), extent=extent_1,\\r\\n aspect='auto', vmin=vlim_1[0], vmax=vlim_1[1])\\r\\n axs[1].plot(np.mean(S, axis=1), np.arange(S.shape[0]))\\r\\n axs[3].plot(s_mean, f_axis)\\r\\n axs[0].set_ylim(*extent_0[2:])\\r\\n \\r\\n axs[3].annotate(\\\"fringe period\\\\n= {:.1f} px\\\".format(1/f0),\\r\\n (s0, f0), (0.95, 0.5), textcoords='axes fraction',\\r\\n arrowprops=dict(width=1, headwidth=6, facecolor='k',\\r\\n shrink=0.03), ha='right',)\\r\\n\\r\\n axs[3].axhline(f0*0.7, color='r', linestyle='dashed')\\r\\n axs[3].axhline(f0*1.4, color='r', linestyle='dashed')\\r\\n\\r\\n fig.tight_layout()\\r\\n fig.canvas.window().move(0,0)\\r\\n return fig\",\n \"def visitcomp(plate,mjd,indiv=False,apred='test') :\\n #plt.close('all')\\n load=apload.ApLoad(apred=apred)\\n a=load.apVisitSum(plate,mjd)[1].data\\n\\n #dr14=apload.ApLoad(dr='dr14')\\n p=yanny.yanny(os.environ['PLATELIST_DIR']+'/platePlans.par',np=True)\\n j=np.where(p['PLATEPLANS']['plateid'] == plate)[0][0]\\n locid=p['PLATEPLANS']['locationid'][j]\\n b=fits.open(os.environ['APOGEE_REDUX']+'/r8/fields/apo25m/{:04d}/apVisitSum-{:04d}-{:05d}.fits'.format(\\n locid,plate,mjd))[1].data\\n\\n fig,ax=plots.multi(2,2)\\n i1,i2=match.match(a['FIBERID'],b['FIBERID'])\\n plots.plotc(ax[0,0],a['FIBERID'][i1],a['VHELIO'][i1]-b['VHELIO'][i2],a['RV_TEFF'][i1],zr=[3500,5500],xt='Fiber',yt=r'$\\\\Delta$ VHELIO')\\n plots.plotc(ax[0,1],a['FIBERID'][i1],a['VHELIO'][i1]-b['VHELIO'][i2],a['RV_TEFF'][i1],zr=[3500,5500],yr=[-2.,2.],xt='Fiber',yt=r'$\\\\Delta$ VHELIO')\\n plots.plotc(ax[1,0],a['FIBERID'][i1],a['RV_TEFF'][i1]-b['RV_TEFF'][i2],a['RV_TEFF'][i1],zr=[3500,5500],xt='Fiber',yt=r'$\\\\Delta$ RV_TEFF')\\n plots.plotc(ax[1,1],a['RV_TEFF'][i1]-b['RV_TEFF'][i2],a['VHELIO'][i1]-b['VHELIO'][i2],a['RV_TEFF'][i1],zr=[3500,5500],xt=r'$\\\\Delta$ RV_TEFF',yt=r'$\\\\Delta$ VHELIO')\\n out=load.filename('Plate',chips=True,plate=plate,mjd=mjd)\\n outdir=os.path.dirname(out)\\n outname=os.path.basename(out).replace('-a','').replace('.fits','_dr14comp.png')\\n fig.tight_layout()\\n pdb.set_trace()\\n print(outdir+'/plots/'+outname)\\n fig.savefig(outdir+'/plots/'+outname)\\n\\n if indiv :\\n va=load.apPlate(plate,mjd)\\n vb={}\\n for chip in chips :\\n tmp=fits.open(os.environ['APOGEE_REDUX']+'/r8/apo25m/{:04d}/{:05d}/apPlate-{:s}-{:04d}-{:05d}.fits'.format(\\n plate,mjd,chip,plate,mjd))\\n vb[chip] = tmp\\n\\n fig,ax=plots.multi(1,3,hspace=0.3) \\n pfig,pax=plots.multi(1,3,hspace=0.3) \\n wfig,wax=plots.multi(1,3,hspace=0.3) \\n for i in range(len(i1)) :\\n fiber = a['FIBERID'][i1[i]]\\n if (a['VHELIO'][i1[i]]-b['VHELIO'][i2[i]]) > 0.5 :\\n print(fiber,a['VHELIO'][i1[i]],b['VHELIO'][i2[i]],a['RV_TEFF'][i1[i]],b['RV_TEFF'][i2[i]])\\n applot.chip(va,ax=ax,row=300-fiber,color='r')\\n #applot.chip(va,ax=pax,row=300-fiber,color='r',pixel=True)\\n applot.chip(vb,ax=ax,row=300-fiber,color='b')\\n #applot.chip(vb,ax=pax,row=300-fiber,color='b',pixel=True)\\n for ichip,chip in enumerate(chips) :\\n pax[ichip].plot(va[chip][1].data[300-fiber,:]/vb[chip][1].data[300-fiber,:])\\n wax[ichip].plot(va[chip][4].data[300-fiber,:]-vb[chip][4].data[300-fiber,:])\\n plt.show()\\n\\n pdb.set_trace()\\n for ichip in range(3) :\\n ax[ichip].cla()\\n pax[ichip].cla()\\n wax[ichip].cla()\\n plt.close()\",\n \"def draw_heaters(ax, windtunnel):\\n draw_heater(ax, windtunnel.heater_l)\\n draw_heater(ax, windtunnel.heater_r)\",\n \"def frontiere(f, X, y, w=None, step=50, alpha_choice=1, colorbar=True,\\n samples=True):\\n # construct cmap\\n\\n min_tot0 = np.min(X[:, 0])\\n min_tot1 = np.min(X[:, 1])\\n\\n max_tot0 = np.max(X[:, 0])\\n max_tot1 = np.max(X[:, 1])\\n delta0 = (max_tot0 - min_tot0)\\n delta1 = (max_tot1 - min_tot1)\\n xx, yy = np.meshgrid(np.arange(min_tot0, max_tot0, delta0 / step),\\n np.arange(min_tot1, max_tot1, delta1 / step))\\n z = np.array([f(vec) for vec in np.c_[xx.ravel(), yy.ravel()]])\\n z = z.reshape(xx.shape)\\n labels = np.unique(z)\\n color_blind_list = sns.color_palette(\\\"colorblind\\\", labels.shape[0])\\n sns.set_palette(color_blind_list)\\n my_cmap = ListedColormap(color_blind_list)\\n plt.imshow(z, origin='lower', interpolation=\\\"mitchell\\\", alpha=0.80,\\n cmap=my_cmap, extent=[min_tot0, max_tot0, min_tot1, max_tot1])\\n if colorbar is True:\\n ax = plt.gca()\\n cbar = plt.colorbar(ticks=labels)\\n cbar.ax.set_yticklabels(labels)\\n\\n labels = np.unique(y)\\n k = np.unique(y).shape[0]\\n color_blind_list = sns.color_palette(\\\"colorblind\\\", k)\\n sns.set_palette(color_blind_list)\\n ax = plt.gca()\\n if samples is True:\\n for i, label in enumerate(y):\\n label_num = np.where(labels == label)[0][0]\\n plt.scatter(X[i, 0], X[i, 1], c=color_blind_list[label_num],\\n s=80, marker=symlist[label_num])\\n plt.xlim([min_tot0, max_tot0])\\n plt.ylim([min_tot1, max_tot1])\\n ax.get_yaxis().set_ticks([])\\n ax.get_xaxis().set_ticks([])\\n if w is not None:\\n plt.plot([min_tot0, max_tot0],\\n [min_tot0 * -w[1] / w[2] - w[0] / w[2],\\n max_tot0 * -w[1] / w[2] - w[0] / w[2]],\\n \\\"k\\\", alpha=alpha_choice)\",\n \"def plot_skyline_5578(fig_size,\\n flux_5578,\\n flux_5578_medfilt, show_plot=False):\\n fig, ax = plt.subplots(figsize=(fig_size, fig_size / 2.5))\\n ax.plot(flux_5578, alpha=0.5)\\n ax.plot(flux_5578_medfilt, alpha=1.0)\\n ax.set_ylabel(r\\\"Integrated flux of skyline 5578 $\\\\AA$\\\")\\n ax.set_xlabel(\\\"Fibre\\\")\\n p01 = np.nanpercentile(flux_5578, 1)\\n p99 = np.nanpercentile(flux_5578, 99)\\n ax.set_ylim(p01, p99)\\n ax.set_title(r\\\"Checking throughput correction using skyline 5578 $\\\\AA$\\\")\\n ax.tick_params(axis='both', which='minor')\\n if show_plot:\\n plt.show()\\n\\n return fig\",\n \"def plot_spectrum(inp='jw02767005001-02-clear-prism-nrs2-2767_11027.spec.fits', z=9.505, vel_width=100, bkg=None, scale_disp=1.3, nspline=27, show_cont=True, draws=100, figsize=(16, 8), ranges=[(3650, 4980)], Rline=1000, full_log=False, write=False, eazy_templates=None, use_full_dispersion=True, get_spl_templates=False, scale_uncertainty_kwargs=None, plot_unit=None, spline_single=True, sys_err=0.02, return_fit_results=False, use_aper_columns=False, label=None, **kwargs):\\n global SCALE_UNCERTAINTY\\n \\n lw, lr = utils.get_line_wavelengths()\\n \\n if isinstance(inp, str):\\n sampler = SpectrumSampler(inp, **kwargs)\\n file = inp\\n elif isinstance(inp, pyfits.HDUList):\\n sampler = SpectrumSampler(inp, **kwargs)\\n file = None\\n else:\\n file = None\\n sampler = inp\\n \\n if (label is None) & (file is not None):\\n label = os.path.basename(file)\\n \\n spec = sampler.spec\\n \\n if (use_aper_columns > 0) & ('aper_flux' in spec.colnames):\\n if ('aper_corr' in spec.colnames) & (use_aper_columns > 1):\\n ap_corr = spec['aper_corr']*1\\n else:\\n ap_corr = 1\\n \\n flam = spec['aper_flux']*spec['to_flam']*ap_corr\\n eflam = spec['aper_full_err']*spec['to_flam']*ap_corr\\n else:\\n flam = spec['flux']*spec['to_flam']\\n eflam = spec['full_err']*spec['to_flam']\\n \\n wrest = spec['wave']/(1+z)*1.e4\\n wobs = spec['wave']\\n mask = spec['valid']\\n \\n flam[~mask] = np.nan\\n eflam[~mask] = np.nan\\n \\n bspl = sampler.bspline_array(nspline=nspline, get_matrix=True)\\n\\n # bspl = utils.bspline_templates(wave=spec['wave']*1.e4,\\n # degree=3,\\n # df=nspline)\\n \\n w0 = utils.log_zgrid([spec['wave'].min()*1.e4,\\n spec['wave'].max()*1.e4], 1./Rline)\\n \\n templates, tline, _A = make_templates(sampler, z,\\n bspl=bspl,\\n eazy_templates=eazy_templates,\\n vel_width=vel_width,\\n scale_disp=scale_disp,\\n use_full_dispersion=use_full_dispersion,\\n disp=spec.disp,\\n grating=spec.grating,\\n **kwargs,\\n )\\n \\n if scale_uncertainty_kwargs is not None:\\n _, escl, _ = calc_uncertainty_scale(file=None,\\n data=(spec, _A),\\n **scale_uncertainty_kwargs)\\n eflam *= escl\\n spec['escale'] *= escl\\n \\n okt = _A[:,mask].sum(axis=1) > 0\\n \\n _Ax = _A[okt,:]/eflam\\n _yx = flam/eflam\\n \\n if eazy_templates is None:\\n _x = np.linalg.lstsq(_Ax[:,mask].T, \\n _yx[mask], rcond=None)\\n else:\\n _x = nnls(_Ax[:,mask].T, _yx[mask])\\n \\n coeffs = np.zeros(_A.shape[0])\\n coeffs[okt] = _x[0]\\n \\n _model = _A.T.dot(coeffs)\\n _mline = _A.T.dot(coeffs*tline)\\n _mcont = _model - _mline\\n \\n full_chi2 = ((flam - _model)**2/eflam**2)[mask].sum()\\n cont_chi2 = ((flam - _mcont)**2/eflam**2)[mask].sum()\\n \\n if return_fit_results:\\n return templates, coeffs, flam, eflam, _model, mask, full_chi2\\n \\n try:\\n oktemp = okt & (coeffs != 0)\\n \\n AxT = (_A[oktemp,:]/eflam)[:,mask].T\\n \\n covar_i = utils.safe_invert(np.dot(AxT.T, AxT))\\n covar = utils.fill_masked_covar(covar_i, oktemp)\\n covard = np.sqrt(covar.diagonal())\\n \\n has_covar = True\\n except:\\n has_covar = False\\n covard = coeffs*0.\\n N = len(templates)\\n covar = np.eye(N, N)\\n \\n print(f'\\\\n# line flux err\\\\n# flux x 10^-20 erg/s/cm2')\\n if label is not None:\\n print(f'# {label}')\\n \\n print(f'# z = {z:.5f}\\\\n# {time.ctime()}')\\n \\n cdict = {}\\n eqwidth = {}\\n \\n for i, t in enumerate(templates):\\n cdict[t] = [float(coeffs[i]), float(covard[i])]\\n if t.startswith('line '):\\n lk = t.split()[-1]\\n \\n # Equivalent width:\\n # coeffs, line fluxes are in units of 1e-20 erg/s/cm2\\n # _mcont, continuum model is in units of 1-e20 erg/s/cm2/A\\n # so observed-frame equivalent width is roughly\\n # eqwi = coeffs[i] / _mcont[ wave_obs[i] ]\\n \\n if lk in lw:\\n lwi = lw[lk][0]*(1+z)/1.e4\\n continuum_i = np.interp(lwi, spec['wave'], _mcont)\\n eqwi = coeffs[i]/continuum_i\\n else:\\n eqwi = np.nan\\n \\n eqwidth[t] = eqwi\\n \\n print(f'{t:>20} {coeffs[i]:8.1f} ± {covard[i]:8.1f} (EW={eqwi:9.1f})')\\n \\n \\n if 'srcra' not in spec.meta:\\n spec.meta['srcra'] = 0.0\\n spec.meta['srcdec'] = 0.0\\n spec.meta['srcname'] = 'unknown'\\n \\n spec['model'] = _model/spec['to_flam']\\n spec['mline'] = _mline/spec['to_flam']\\n \\n data = {'z': float(z),\\n 'file':file,\\n 'label':label,\\n 'ra': float(spec.meta['srcra']),\\n 'dec': float(spec.meta['srcdec']),\\n 'name': str(spec.meta['srcname']),\\n 'wmin':float(spec['wave'][mask].min()),\\n 'wmax':float(spec['wave'][mask].max()),\\n 'coeffs':cdict,\\n 'covar':covar.tolist(),\\n 'wave': [float(m) for m in spec['wave']],\\n 'flux': [float(m) for m in spec['flux']],\\n 'err': [float(m) for m in spec['err']],\\n 'escale': [float(m) for m in spec['escale']],\\n 'model': [float(m) for m in _model/spec['to_flam']],\\n 'mline':[float(m) for m in _mline/spec['to_flam']],\\n 'templates':templates, \\n 'dof': int(mask.sum()), \\n 'fullchi2': float(full_chi2), \\n 'contchi2': float(cont_chi2),\\n 'eqwidth': eqwidth,\\n }\\n \\n for k in ['z','wmin','wmax','dof','fullchi2','contchi2']:\\n spec.meta[k] = data[k]\\n \\n #fig, axes = plt.subplots(len(ranges)+1,1,figsize=figsize)\\n if len(ranges) > 0:\\n fig = plt.figure(figsize=figsize, constrained_layout=True)\\n gs = GridSpec(2, len(ranges), figure=fig)\\n axes = []\\n for i, _ra in enumerate(ranges):\\n axes.append(fig.add_subplot(gs[0,i]))\\n \\n axes.append(fig.add_subplot(gs[1,:]))\\n \\n else:\\n fig, ax = plt.subplots(1,1,figsize=figsize)\\n axes = [ax]\\n \\n _Acont = (_A.T*coeffs)[mask,:][:,:nspline]\\n _Acont[_Acont < 0.001*_Acont.max()] = np.nan\\n \\n if (draws is not None) & has_covar:\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\")\\n mu = np.random.multivariate_normal(coeffs[oktemp], covar_i, size=draws)\\n \\n #print('draws', draws, mu.shape, _A.shape)\\n mdraws = _A[oktemp,:].T.dot(mu.T)\\n else:\\n mdraws = None\\n \\n if plot_unit is not None:\\n unit_conv = (1*spec.meta['flamunit']).to(plot_unit,\\n equivalencies=spec.equiv).value\\n else:\\n unit_conv = np.ones(len(wobs))\\n \\n for ax in axes:\\n if 1:\\n ax.errorbar(wobs, flam*unit_conv, eflam*unit_conv,\\n marker='None', linestyle='None',\\n alpha=0.5, color='k', ecolor='k', zorder=100)\\n\\n ax.step(wobs, flam*unit_conv, color='k', where='mid', lw=1, alpha=0.8)\\n # ax.set_xlim(3500, 5100)\\n\\n #ax.plot(_[1]['templz']/(1+z), _[1]['templf'])\\n \\n ax.step(wobs[mask], (_mcont*unit_conv)[mask],\\n color='pink', alpha=0.8, where='mid')\\n ax.step(wobs[mask], (_model*unit_conv)[mask],\\n color='r', alpha=0.8, where='mid')\\n \\n cc = utils.MPL_COLORS\\n for w, c in zip([3727, 4980, 6565, 9070, 9530, 1.094e4, 1.282e4, \\n 1.875e4], \\n [cc['purple'], cc['b'], cc['g'], 'darkred', 'darkred', \\n cc['pink'], cc['pink'], cc['pink']]):\\n wz = w*(1+z)/1.e4\\n dw = 70*(1+z)/1.e4\\n ax.fill_between([wz-dw, wz+dw], [0,0], [100,100], \\n color=c, alpha=0.07, zorder=-100)\\n \\n \\n if mdraws is not None:\\n ax.step(wobs[mask], (mdraws.T*unit_conv).T[mask,:],\\n color='r', alpha=np.maximum(1./draws, 0.02), zorder=-100, where='mid')\\n\\n if show_cont:\\n ax.plot(wobs[mask], (_Acont.T*unit_conv[mask]).T,\\n color='olive', alpha=0.3)\\n \\n ax.fill_between(ax.get_xlim(), [-100, -100], [0, 0], color='0.8', \\n alpha=0.5, zorder=-1)\\n\\n ax.fill_betweenx([0, 100], [0,0], [1215.67*(1+z)/1.e4]*2, \\n color=utils.MPL_COLORS['orange'], alpha=0.2,\\n zorder=-1)\\n \\n ax.grid()\\n\\n # axes[0].set_xlim(1000, 2500)\\n # ym = 0.15; axes[0].set_ylim(-0.1*ym, ym)\\n \\n for i, r in enumerate(ranges):\\n axes[i].set_xlim(*[ri*(1+z)/1.e4 for ri in r])\\n # print('xxx', r)\\n \\n if spec.filter == 'clear':\\n axes[-1].set_xlim(0.6, 5.29)\\n axes[-1].xaxis.set_minor_locator(MultipleLocator(0.1))\\n axes[-1].xaxis.set_major_locator(MultipleLocator(0.5))\\n elif spec.filter == 'f070lp':\\n axes[-1].set_xlim(0.69, 1.31)\\n axes[-1].xaxis.set_minor_locator(MultipleLocator(0.02))\\n elif spec.filter == 'f100lp':\\n axes[-1].set_xlim(0.99, 1.91)\\n axes[-1].xaxis.set_minor_locator(MultipleLocator(0.02))\\n axes[-1].xaxis.set_major_locator(MultipleLocator(0.1))\\n elif spec.filter == 'f170lp':\\n axes[-1].set_xlim(1.69, 3.21)\\n elif spec.filter == 'f290lp':\\n axes[-1].set_xlim(2.89, 5.31)\\n else:\\n axes[-1].set_xlim(wrest[mask].min(), wrest[mask].max())\\n \\n axes[-1].set_xlabel(f'obs wavelenth, z = {z:.5f}')\\n \\n #axes[0].set_title(os.path.basename(file))\\n \\n for ax in axes:\\n xl = ax.get_xlim()\\n ok = wobs > xl[0]\\n ok &= wobs < xl[1]\\n ok &= np.abs(wrest-5008) > 100\\n ok &= np.abs(wrest-6564) > 100\\n ok &= mask\\n if ok.sum() == 0:\\n ax.set_visible(False)\\n continue\\n \\n ymax = np.maximum((_model*unit_conv)[ok].max(), 10*np.median((eflam*unit_conv)[ok]))\\n \\n ymin = np.minimum(-0.1*ymax, -3*np.median((eflam*unit_conv)[ok]))\\n ax.set_ylim(ymin, ymax*1.3)\\n # print(xl, ymax)\\n \\n if ok.sum() > 0:\\n if (np.nanmax((flam/eflam)[ok]) > 20) & (full_log):\\n ax.set_ylim(0.005*ymax, ymax*5)\\n ax.semilogy()\\n \\n if len(axes) > 0:\\n gs.tight_layout(fig, pad=0.8)\\n else:\\n fig.tight_layout(pad=0.8)\\n \\n if label is not None:\\n fig.text(0.015*12./12, 0.005, f'{label}',\\n ha='left', va='bottom',\\n transform=fig.transFigure, fontsize=8)\\n \\n fig.text(1-0.015*12./12, 0.005, time.ctime(),\\n ha='right', va='bottom',\\n transform=fig.transFigure, fontsize=6)\\n \\n \\n return fig, spec, data\",\n \"def plot_observed_spectrum(self, iremove = [], cc = [\\\"C0\\\", \\\"C2\\\", \\\"C3\\\"],\\n yloc = 1.8, plot_boxes = False, label_molecules = True,\\n show_bandpasses = True):\\n\\n bp_names = self.bp_names\\n\\n # Set planet and star parameters for an Earth-Sun analog at 6pc\\n self.cn.planet.distance = 6.0\\n self.cn.planet.a = 1.0\\n self.cn.star.Rs = 1.0\\n self.cn.star.Teff = 5780.\\n\\n \\\"\\\"\\\"\\n wantSNR_grid = np.array([wantSNR for i in range(len(bp_names))])\\n wantSNR_grid[0] = 1.0\\n wantSNR_grid[1] = 1.0\\n \\\"\\\"\\\"\\n\\n output = self.complete_spectrum_time()\\n spectrum = output[2]\\n\\n fig, ax = plt.subplots(figsize = (16,5))\\n ax.set_xlabel(\\\"Wavelength [$\\\\mu$m]\\\")\\n ax.set_ylabel(r\\\"Planet-Star Flux Ratio ($\\\\times 10^{-10}$)\\\")\\n for i in range(len(bp_names)):\\n if i not in iremove:\\n ax.plot(spectrum[0][i], 1e10*spectrum[3][i], \\\"o\\\", ms = 4.0, alpha = 0.65, color = \\\"w\\\", zorder = 80)\\n ax.errorbar(spectrum[0][i], 1e10*spectrum[3][i], yerr=1e10*spectrum[4][i], fmt = \\\"o\\\", ms = 2.0, alpha = 0.65, color = \\\"k\\\", zorder = 80)\\n if show_bandpasses:\\n ax.axvspan(self.bandpasses[i][0], self.bandpasses[i][1], alpha = 0.2, color = cc[self.bp_chan[i]])\\n\\n self.cn.telescope.lammin = 0.2\\n self.cn.telescope.lammax = 2.0\\n self.cn.telescope.resolution = 140.\\n # Re-do count rate calcs for true Earth spectrum\\n self.cn.run_count_rates(self.AHR, self.LAMHR, self.FSTAR)\\n ax.plot(self.cn.lam, 1e10*self.cn.Cratio, color = \\\"purple\\\", zorder = 70, lw = 4.0, alpha = 1.)\\n ax.plot(self.cn.lam, 1e10*self.cn.Cratio, color = \\\"w\\\", zorder = 70, lw = 2.0, alpha = 0.65)\\n ax.set_ylim(bottom=0.0)\\n\\n # Label Molecules\\n if label_molecules:\\n ax.text(0.27, 1.55, \\\"O$_3$\\\", ha = \\\"center\\\", va = \\\"center\\\", color = \\\"k\\\", zorder = 130)\\n ax.text(0.6, 1.45, \\\"O$_3$\\\", ha = \\\"center\\\", va = \\\"center\\\", color = \\\"k\\\", zorder = 130)\\n ax.text(0.69, 1.35, \\\"O$_2$\\\", ha = \\\"center\\\", va = \\\"center\\\", color = \\\"k\\\", zorder = 130)\\n ax.text(0.76, 1.65, \\\"O$_2$\\\", ha = \\\"center\\\", va = \\\"center\\\", color = \\\"k\\\", zorder = 130)\\n ax.text(0.96, 1.65, \\\"H$_2$O\\\", ha = \\\"center\\\", va = \\\"center\\\", color = \\\"k\\\", zorder = 130)\\n ax.text(1.15, 1.45, \\\"H$_2$O\\\", ha = \\\"center\\\", va = \\\"center\\\", color = \\\"k\\\", zorder = 130)\\n ax.text(1.4, 1.45, \\\"H$_2$O\\\", ha = \\\"center\\\", va = \\\"center\\\", color = \\\"k\\\", zorder = 130)\\n ax.text(1.9, 1.25, \\\"H$_2$O\\\", ha = \\\"center\\\", va = \\\"center\\\", color = \\\"k\\\", zorder = 130)\\n ax.text(1.6, 1.25, \\\"CO$_2$\\\", ha = \\\"center\\\", va = \\\"center\\\", color = \\\"k\\\", zorder = 130)\\n\\n lammin_inst = self.bandpasses[self.bp_chan == 0][0][0]\\n lammax_inst = self.bandpasses[self.bp_chan == 0][-1][1]\\n xloc = (lammax_inst + lammin_inst) / 2\\n name = \\\"UV\\\"\\n color = cc[0]\\n bbox_fc = \\\"w\\\"\\n ax.annotate(s='', xy=(lammin_inst,yloc), xytext=(lammax_inst,yloc), arrowprops=dict(arrowstyle='<->', color=color, lw = 2.0), zorder=2)\\n ax.text(xloc, yloc, name, ha=\\\"center\\\", va=\\\"bottom\\\", color=color, zorder=99)#, bbox=dict(boxstyle=\\\"square\\\", fc=bbox_fc, ec=\\\"none\\\", zorder=2))\\n if not show_bandpasses: ax.axvspan(lammin_inst, lammax_inst, alpha = 0.2, color = color)\\n\\n lammin_inst = self.bandpasses[self.bp_chan == 1][0][0]\\n lammax_inst = self.bandpasses[self.bp_chan == 1][-1][1]\\n xloc = (lammax_inst + lammin_inst) / 2\\n name = \\\"visible\\\"\\n color = cc[1]\\n bbox_fc = \\\"w\\\"\\n ax.annotate(s='', xy=(lammin_inst,yloc), xytext=(lammax_inst,yloc), arrowprops=dict(arrowstyle='<->', color=color, lw = 2.0), zorder=2)\\n ax.text(xloc, yloc, name, ha=\\\"center\\\", va=\\\"bottom\\\", color=color, zorder=99)#, bbox=dict(boxstyle=\\\"square\\\", fc=bbox_fc, ec=\\\"none\\\", zorder=2))\\n if not show_bandpasses: ax.axvspan(lammin_inst, lammax_inst, alpha = 0.2, color = color)\\n\\n lammin_inst = self.bandpasses[self.bp_chan == 2][0][0]\\n lammax_inst = self.bandpasses[self.bp_chan == 2][-1][1]\\n xloc = (lammax_inst + lammin_inst) / 2\\n name = \\\"NIR\\\"\\n color = cc[2]\\n bbox_fc = \\\"w\\\"\\n ax.annotate(s='', xy=(lammin_inst,yloc), xytext=(lammax_inst,yloc), arrowprops=dict(arrowstyle='<->', color=color, lw = 2.0), zorder=2)\\n ax.text(xloc, yloc, name, ha=\\\"center\\\", va=\\\"bottom\\\", color=color, zorder=99)#, bbox=dict(boxstyle=\\\"square\\\", fc=bbox_fc, ec=\\\"none\\\", zorder=2))\\n if not show_bandpasses: ax.axvspan(lammin_inst, lammax_inst, alpha = 0.2, color = color)\\n\\n if plot_boxes:\\n\\n ax2 = ax.twinx()\\n\\n \\\"\\\"\\\"\\n Xdraw = len(tpbpcs_draws_tots[0][0])\\n\\n # Transform quantities for boxplot\\n tmp = [np.zeros((len(tpbpcs_draws_tots[i]), Xdraw)) for i in range(len(spectroscopy.CHANNELS))]\\n for i in range(Xdraw):\\n for j in range(tp):\\n for k in range(len(tpbpcs_draws_tots[j])):\\n tmp[j][k,i] = tpbpcs_draws_tots[j][k][i]\\n \\\"\\\"\\\"\\n\\n icount = 0\\n for ichan in range(len(spectroscopy.CHANNELS)):\\n\\n data = []\\n positions = []\\n widths = []\\n\\n for j in range(len(bp_names[bp_chan == ichan])):\\n\\n data.append(tmp[icount,:])\\n positions.append(np.mean(spectrum[0][icount]))\\n widths.append(spectrum[0][icount][-1] - spectrum[0][icount][0] + np.mean(spectrum[1][icount][:]))\\n color1 = cc[ichan]\\n\\n comp_str = \\\"$%i \\\\%%$\\\" %(100.*frac_bias_bp[icount])\\n comp_str2 = \\\"$\\\\mathbf{%i \\\\%%}$\\\" %(100.*frac_bias_bp[icount])\\n #ax2.text(positions[j], np.median(tmp[icount,:]) + 5.*np.std(tmp[icount,:]), comp_str2,\\n # ha = \\\"center\\\", va = \\\"top\\\", fontsize = 12, color = \\\"w\\\")\\n ax2.text(positions[j], np.median(tmp[icount,:]) + 5.*np.std(tmp[icount,:]), comp_str2,\\n ha = \\\"center\\\", va = \\\"top\\\", fontsize = 12, color = color1)\\n\\n icount += 1\\n\\n positions = np.array(positions)\\n widths = np.array(widths)\\n bp1 = ax2.boxplot(data, sym = '', widths = widths, showfliers = False,\\n boxprops = {\\\"color\\\" : color1, \\\"alpha\\\" : 0.5},\\n whiskerprops = {\\\"color\\\" : color1, \\\"linewidth\\\" : 2.0},\\n capprops = {\\\"color\\\" : color1, \\\"linewidth\\\" : 0.0},\\n medianprops = {\\\"color\\\" : \\\"w\\\", \\\"linewidth\\\" : 2.0},\\n patch_artist=True, positions = positions, whis = [5, 95]);\\n\\n for patch in bp1['boxes']:\\n patch.set_facecolor(color1)\\n\\n ax2.set_ylabel(\\\"Science Time [hrs]\\\", labelpad = 22, rotation = 270)\\n #ax2.set_title(r\\\"All %i targets (S/N$\\\\approx$%i)\\\" %(Ndraw, wantSNR))\\n ax2.set_yscale(\\\"log\\\")\\n\\n ax2.set_xlabel(\\\"Wavelength [$\\\\mu$m]\\\")\\n ax2.set_ylim(bottom = 0.0)\\n\\n ax2.set_xticks([0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0])\\n ax2.set_xticklabels([0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0])\\n ax2.set_xlim(0.1, 2.0)\\n #ax2.set_xlim(0.4, 1.0)\\n\\n return fig, ax\",\n \"def P_AI_Rocky(in_dict):\\n # START\\n fs = 16\\n plt.rc('font', size=fs)\\n fig = plt.figure(figsize=(14,12))\\n ds = nc.Dataset(in_dict['fn'])\\n\\n # PLOT CODE\\n aa = [-122.8, -122.54, 47.92, 48.22]\\n import cmocean\\n cmap = cmocean.cm.balance\\n # cmap = 'RdYlBu_r'\\n\\n from warnings import filterwarnings\\n filterwarnings('ignore') # skip some warning messages\\n \\n # plot Code\\n \\n # calculate divergence and vorticity\\n uu = ds['u'][0, -1, :, :]\\n vv = ds['v'][0, -1, :, :]\\n u = zfun.fillit(uu)\\n v = zfun.fillit(vv)\\n u[np.isnan(u)] = 0\\n v[np.isnan(v)] = 0\\n \\n G = zrfun.get_basic_info(in_dict['fn'], only_G=True)\\n \\n dive = ((np.diff(u, axis=1)/G['DX'][:, 1:-1])[1:-1, :]\\n + (np.diff(v, axis = 0)/G['DY'][1:-1, :])[:, 1:-1])\\n #dive[G['mask_rho'][1:-1,1:-1]==False] = np.nan\\n \\n vort = np.diff(v, axis=1)/G['DX'][1:,1:] - np.diff(u, axis=0)/G['DY'][1:,1:]\\n #vort[G['mask_rho'][1:,1:]==False] = np.nan\\n \\n scl = 2e-3\\n \\n # panel 1\\n ax = fig.add_subplot(121)\\n # cs = plt.pcolormesh(G['lon_psi'], G['lat_psi'], dive/scl, cmap=cmap,\\n # vmin=-1, vmax=1)\\n cs = plt.pcolormesh(G['lon_rho'][1:-1,1:-1], G['lat_rho'][1:-1,1:-1], dive/scl, cmap=cmap,\\n vmin=-1, vmax=1, shading='gouraud')\\n tstr = (r'Surface Divergence (%0.1e $s^{-1}$)' % (scl))\\n #pfun.add_bathy_contours(ax, ds, txt=True)\\n pfun.add_coast(ax)\\n ax.axis(aa)\\n pfun.dar(ax)\\n ax.set_xlabel('Longitude')\\n ax.set_ylabel('Latitude')\\n ax.set_title(tstr)\\n pfun.add_info(ax, in_dict['fn'])\\n ax.set_xticks([-122.8, -122.7, -122.6])\\n ax.set_yticks([48, 48.1, 48.2])\\n #\\n # panel 2\\n ax = fig.add_subplot(122)\\n # cs = plt.pcolormesh(G['lon_rho'], G['lat_rho'], vort/scl, cmap=cmap,\\n # vmin=-1, vmax=1)\\n cs = plt.pcolormesh(G['lon_psi'], G['lat_psi'], vort/scl, cmap=cmap,\\n vmin=-1, vmax=1, shading='gouraud')\\n tstr = (r'Surface Vorticity (%0.1e $s^{-1}$)' % (scl))\\n ax.set_xticks([-122.8, -122.7, -122.6])\\n ax.set_yticks([])\\n #fig.colorbar(cs)\\n \\n # Inset colorbar\\n from mpl_toolkits.axes_grid1.inset_locator import inset_axes\\n cbaxes = inset_axes(ax, width=\\\"4%\\\", height=\\\"40%\\\", loc='lower left')\\n fig.colorbar(cs, cax=cbaxes, orientation='vertical')\\n \\n #pfun.add_bathy_contours(ax, ds)\\n pfun.add_coast(ax)\\n ax.axis(aa)\\n pfun.dar(ax)\\n ax.set_xlabel('Longitude')\\n ax.set_title(tstr) \\n \\n #fig.tight_layout()\\n # FINISH\\n ds.close()\\n if len(in_dict['fn_out']) > 0:\\n plt.savefig(in_dict['fn_out'])\\n plt.close()\\n else:\\n plt.show()\\n plt.rcdefaults()\",\n \"def plot_regime_diagram_background_L19(\\n ax=None,\\n ):\\n if ax is None:\\n ax = plt.gca()\\n # range of power\\n xpr = [-1, 1]\\n ypr = [-3, 3]\\n # range\\n xlims = [10**i for i in xpr]\\n ylims = [10**i for i in ypr]\\n # background following Fig. 3 of Belcher et al., 2012\\n nx = 500\\n ny = 500\\n xx = np.logspace(xpr[0], xpr[1], nx)\\n yy = np.logspace(ypr[0], ypr[1], ny)\\n zz1 = np.zeros([nx, ny])\\n zz2 = np.zeros([nx, ny])\\n zz3 = np.zeros([nx, ny])\\n for i in np.arange(nx):\\n for j in np.arange(ny):\\n zz1[i,j] = 2*(1-np.exp(-0.5*xx[i]))\\n zz2[i,j] = 0.22*xx[i]**(-2)\\n zz3[i,j] = 0.3*xx[i]**(-2)*yy[j]\\n zz = zz1 + zz2 + zz3\\n\\n rz_ST = zz1/zz\\n rz_LT = zz2/zz\\n rz_CT = zz3/zz\\n fr = np.ones(zz.shape) * 7\\n cfrac = 0.25\\n fr[(rz_LT<cfrac) & (rz_CT<cfrac)] = 1\\n fr[(rz_ST<cfrac) & (rz_CT<cfrac)] = 2\\n fr[(rz_ST<cfrac) & (rz_LT<cfrac)] = 3\\n fr[(rz_ST>=cfrac) & (rz_LT>=cfrac) & (rz_CT<cfrac)] = 4\\n fr[(rz_ST>=cfrac) & (rz_CT>=cfrac) & (rz_LT<cfrac)] = 5\\n fr[(rz_LT>=cfrac) & (rz_CT>=cfrac) & (rz_ST<cfrac)] = 6\\n color_list = ['firebrick','forestgreen','royalblue','gold','orchid','turquoise','w']\\n cb_ticks = [0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5]\\n cmap, norm = from_levels_and_colors(cb_ticks, color_list)\\n ax.contourf(xx, yy, np.transpose(fr), cmap=cmap, norm=norm)\\n ax.contour(xx, yy, np.transpose(fr), colors='darkgray')\\n ax.set_xlim(xlims)\\n ax.set_ylim(ylims)\\n ax.set_xscale('log')\\n ax.set_yscale('log')\\n ax.set_xlabel('La$_t$')\\n ax.set_ylabel('$h/L_L$')\\n ax.set_aspect(aspect=1/3)\\n ax.text(0.11, 4e-3, 'Langmuir', bbox=dict(boxstyle=\\\"square\\\",ec='k',fc='w'))\\n ax.text(3, 4e-3, 'Shear', bbox=dict(boxstyle=\\\"square\\\",ec='k',fc='w'))\\n ax.text(0.13, 1e2, 'Convection', bbox=dict(boxstyle=\\\"square\\\",ec='k',fc='w'))\",\n \"def plot_ratio_illustration_for_poster(fs, lfp_pre, lfp_band, zeros, extrema, extrema_kind, steepness_indices,\\n steepness_values, save_figure=False):\\n \\\"\\\"\\\"\\n Plot a figure for illustration of sharpness ratio and steepness ratio calculation. use large fonts for poster.\\n \\\"\\\"\\\"\\n upto = 5\\n fontsize = 20\\n markersize = 8\\n\\n filter_offset = 167 # in ms\\n samples_per_5ms = int(5 * fs / 1000)\\n last_zero_idx = zeros[upto]\\n extrema_to_use = extrema[:(upto - 1)]\\n steepness_to_use = steepness_indices[:upto - 2]\\n steepness_values_to_use = steepness_values[:upto - 2]\\n sharpness_idx = np.sort(np.array([extrema_to_use - samples_per_5ms, extrema_to_use + samples_per_5ms]).flatten())\\n\\n extrema_idx = int((upto - 1) / 2)\\n last_idx = np.max([last_zero_idx, extrema_to_use.max()])\\n time_array = np.linspace(filter_offset, filter_offset + last_idx / fs * 1000, last_idx)\\n plt.close()\\n\\n plt.figure(figsize=(15, 5))\\n\\n # plot LFP only up to last but one zero:\\n plt.plot(time_array[:zeros[upto - 1]], lfp_pre[:zeros[upto - 1]], label='preprocessed')\\n plt.plot(time_array[:zeros[upto - 1]], lfp_band[:zeros[upto - 1]], label='beta filtered', color='C1')\\n plt.plot(time_array[zeros[:upto]], lfp_band[zeros[:upto]], 'o', color='C1', markersize=markersize)\\n\\n # plot zero line\\n plt.axhline(0, color='grey')\\n\\n # plot +-5ms sharpness markers\\n for idx, sharpness_sample in enumerate(sharpness_idx):\\n # plt.axvline(x=time_array[sharpness_sample], color='k', alpha=.7, linewidth=.5)\\n # color = 'red' if ll[idx] > 0 else 'blue'\\n color = 'm'\\n plt.plot(time_array[sharpness_sample], lfp_pre[sharpness_sample], '*', markersize=markersize, color=color)\\n\\n # plot maximum slope markers\\n for idx, steepness_sample in enumerate(steepness_to_use):\\n plt.plot(time_array[steepness_sample], lfp_pre[steepness_sample], 'd', markersize=markersize, color='g')\\n # set up a tangent on this point\\n m = (steepness_values_to_use[idx]) / 0.4\\n y_val = lfp_pre[steepness_sample]\\n x_val = time_array[steepness_sample]\\n bias = y_val - m * x_val\\n tangent = lambda x: m * x + bias\\n tangent_time_array = np.linspace(time_array[steepness_sample] - 2,\\n time_array[steepness_sample] + 2, 20)\\n plt.plot(tangent_time_array, tangent(tangent_time_array), color='g')\\n\\n for idx, extrema in enumerate(extrema_to_use):\\n if extrema_kind[idx] > 0:\\n format = '^'\\n label = 'peaks'\\n else:\\n format = 'v'\\n label = 'troughs'\\n\\n color = 'red'\\n plt.plot(time_array[extrema], lfp_pre[extrema], format, markersize=markersize, color=color)\\n\\n # remove labels for poster figure\\n plt.xticks([], [])\\n plt.yticks([], [])\\n plt.xlabel('time', fontsize=fontsize)\\n plt.ylabel('LFP', fontsize=fontsize)\\n # plt.xlim([time_array[0], time_array[-1]])\\n\\n plt.tight_layout()\\n plt.legend(frameon=False, prop={'size': 20})\\n if save_figure:\\n plt.savefig(os.path.join(SAVE_PATH_FIGURES, 'pre_sharpness.pdf'))\\n plt.show()\",\n \"def swe(lon, lat, month):\\n\\n im = month - 1\\n\\n h0 = np.array( [ 8.37, 9.43, 10.74, 11.67, 11.80, 12.48,\\n 4.01, 1.08, 3.84, 6.24, 7.54, 8.00 ] )\\n a = np.array( [ -0.0270, 0.0058, 0.1618, 0.0841, -0.0043, 0.2084,\\n 0.0970, 0.0712, 0.0393, 0.1158, 0.0567, -0.0540 ] )\\n b = np.array( [ -0.3400, -0.1309, 0.0276, -0.1328, -0.4284, -0.5739,\\n -0.4930, -0.1450, -0.2107, -0.2803, -0.3201, -0.3650 ] )\\n c = np.array( [ -0.0319, 0.0017, 0.0213, 0.0081, -0.0380, -0.0468,\\n -0.0333, -0.0155, -0.0182, -0.0215, -0.0284, -0.0362 ] )\\n d = np.array( [ -0.0056, -0.0021, 0.0076, -0.0003, -0.0071, -0.0023,\\n -0.0026, 0.0014, -0.0053, 0.0015, -0.0032, -0.0112 ] )\\n e = np.array( [ -0.0005, -0.0072, -0.0125, -0.0301, -0.0063, -0.0253,\\n -0.0343, -0.0000, -0.0190, -0.0176, -0.0129, -0.0035 ] )\\n\\n x = (90. - lat) * np.cos( np.radians(lon) )\\n y = (90. - lat) * np.sin( np.radians(lon) )\\n\\n h = ( h0[im] + ( a[im] * x ) + ( b[im] * y ) + ( c[im] * x * y ) +\\n ( d[im] * x * x ) + ( e[im] * y * y ) )\\n\\n# h = np.where( h < 0., 0., h)\\n \\n return h\",\n \"def draw_zenith(self, observatory):\\n defaults = dict(color='green',alpha=0.75,lw=1.5)\\n for k,v in defaults.items():\\n kwargs.setdefault(k,v)\\n\\n # RA and Dec of zenith\\n ra_zenith, dec_zenith = np.degrees(observatory.radec_of(0, '90'))\\n xy = self.proj(ra_zenith, dec_zenith)\\n \\n self.plot(*xy,marker='+',ms=10,mew=1.5, **kwargs)\\n self.tissot(ra_zenith, dec_zenith, DECAM, 100, fc='none',**kwargs)\",\n \"def plotSurface(surfaceFile, comp=2, points=False, tris=False,\\n profile=False, ax=None, annotate=True, norm=None,xscale=1, yscale=1):\\n verts,data,tris = load_h5(surfaceFile)\\n\\n if comp==3: #radial displacements\\n z = np.hypot(data[:,:,0], data[:,:,1]).flatten()\\n else:\\n z = data[:,:,comp].flatten()\\n #z = data[:,:,comp].flatten()\\n x = verts[:,0] / xscale\\n y = verts[:,1] / yscale\\n\\n #NOTE: need to change grid for linear spacing to work properly\\n xi = np.linspace(x.min(), x.max(), x.size)\\n yi = np.linspace(y.min(), y.max(), y.size)\\n zi = griddata(x,y,z, xi,yi, interp='nn') #'nn'\\n\\n #NOTE: getting error message here...\\n # linear interpolation requires exactly the same limits\\n #xi=np.arange(-15000.0,15000.0+1e-14,30000.0/x.size)\\n #yi=np.arange(-15000.0,15000.0+1e-14,30000.0/x.size)\\n #zi = griddata(x,y,z, xi,yi, interp='linear') #'nn'\\n #ValueError: output grid must have constant spacing when using interp='linear'\\n\\n if ax==None:\\n plt.figure()\\n else:\\n ax = plt.axes(ax)\\n\\n #plt.pcolor(xi, yi, zi, cmap=plt.cm.jet) #Very slow...\\n x1, x2, y1, y2 = [x.min(), x.max(), y.min(), y.max()]\\n im = plt.imshow(zi, cmap=plt.cm.jet, norm=norm, extent=[x1, x2, y1, y2])\\n\\n if annotate:\\n compdict = {0:'Ux',1:'Uy',2:'Uz',3:'Ur'}\\n plt.title('{} Displacement'.format(compdict[comp]))\\n plt.xlabel('Distance [m]')\\n plt.ylabel('Distance [m]')\\n cb = plt.colorbar()\\n cb.set_label('[m]')\\n\\n if points:\\n plt.plot(x,y,'k.')\\n\\n if type(tris) is np.ndarray:\\n plt.triplot(x, y, tris, 'k-')\\n\\n # EW profile line through the x-axis\\n if profile:\\n plt.axhline(linewidth=2, color='r')\\n Zi = zi[x.size/2,:]\\n plt.figure()\\n plt.plot(xi, Zi, 'b.-')\\n plt.title('Profile')\\n plt.xlabel('Distance [m]')\\n plt.ylabel('{} Displacement [m]'.format(compdict[comp]))\\n\\n return im\",\n \"def show3(dlist,r=2,c=2,greyscale=False,output=False,samerange=True):\\n\\n#distrib.show3((d63[:128,:128,0]-1,d0[:128,:128,0]-1,N.log(d63[:128,:128,0]),d63ga[:128,:128,0]),greyscale=True)\\n\\n M.clf()\\n\\n fig = M.figure(figsize=(6.4, 6.4), dpi=100) \\n axesarr=N.array([[0.01,0.51,0.4,0.4],\\n [0.51,0.51,0.4,0.4],\\n [0.01,0.01,0.4,0.4],\\n [0.51,0.01,0.4,0.4]])\\n\\n print axesarr\\n colorbax = 1.*axesarr\\n print colorbax\\n colorbax[:,2] = 0.*colorbax[:,2] + 0.03\\n colorbax[:,0] += 0.4\\n\\n print colorbax\\n\\n if greyscale:\\n colorscheme='binary'\\n else:\\n colorscheme='jet'\\n\\n # d63, d0, log d63, d63g\\n titlearr=[r'$\\\\delta$',r'$\\\\delta_{\\\\rm initial}$',r'$\\\\log(1+\\\\delta)$',r'$\\\\delta_{\\\\rm Gauss}$']\\n\\n if (dlist[1] != None):\\n min23 = min(min(dlist[2].flatten()),min(dlist[3].flatten()))\\n max23 = max(max(dlist[2].flatten()),max(dlist[3].flatten()))\\n\\n max0 = max(dlist[1].flatten())\\n min0 = min(dlist[1].flatten())\\n\\n initfact = min(max23/max0,min23/min0)\\n print min23,max23, initfact\\n\\n sc = 0\\n for d in dlist:\\n if (d != None):\\n M.axes(axesarr[sc])\\n M.title(titlearr[sc],fontsize=23)\\n if (sc > 1):\\n print titlearr[sc]\\n if (samerange):\\n M.pcolor(d,cmap=M.get_cmap(colorscheme),vmin = min23,vmax=max23)\\n else:\\n M.pcolor(d,cmap=M.get_cmap(colorscheme))\\n elif (sc == 1):\\n #print min(d.flatten()*initfact),max(d.flatten()*initfact)\\n if (samerange):\\n M.pcolor(d*initfact,cmap=M.get_cmap(colorscheme),vmin = min23,vmax=max23)\\n else:\\n M.pcolor(d,cmap=M.get_cmap(colorscheme))\\n\\n else:\\n M.pcolor(d,cmap=M.get_cmap(colorscheme))\\n\\n# if (sc == 1):\\n# M.colorbar(ticks=[-0.1,-0.05,0,0.05,0.1])\\n# else:\\n\\n M.axis('tight')\\n M.axis('equal')\\n M.axis('tight')\\n M.xticks([])\\n M.yticks([])\\n\\n cax = M.axes(colorbax[sc])\\n M.colorbar(cax=cax)\\n\\n sc += 1\\n\\n #M.savefig('showdens.eps',dpi=8)\\n #M.gcf().set_size_inches((6.4,6.4))\\n #M.gcf().set_size_inches((15.,12.))\\n if (output):\\n if greyscale:\\n M.savefig('showdens_grey.png',dpi=100)\\n M.savefig('showdens_grey.pdf')\\n else:\\n fig.savefig('showdens.png',dpi=100)\\n M.savefig('showdens.pdf')\\n\\n #M.show()\",\n \"def app_complex(data_pupil,data_phase,oversize=4):\\n#phase colors\\n # cdict = {'red': ((0.0, 1.0, 1.0),(0.25, 0.0, 0.0),(0.5, 0.0, 0.0),(0.75, 1.0, 1.0),(1.00, 1.0, 1.0)),'green': ((0.0, 0.0, 0.0),(0.25, 1.0, 1.0),(0.5, 0.0, 0.0),(0.75, 1.0, 1.0),(1.0, 0.0, 0.0)),'blue': ((0.0, 0.0, 0.0),(0.25, 0.0, 0.0),(0.5, 1.0, 1.0),(0.75, 0.0, 0.0),(1.0, 0.0, 0.0))}\\n #my_cmap = matplotlib.colors.LinearSegmentedColormap('my_colormap',cdict,256)\\n\\n size=data_pupil.shape[0]\\n#make empty oversized array\\n\\n expand_phase=zeros([oversize*size,oversize*size])\\n expand_amp=zeros([oversize*size,oversize*size])\\n\\n#copy fits into lower left corner\\n\\n expand_amp[0:size,0:size]=data_pupil[0:size,0:size]\\n expand_phase[0:size,0:size]=data_phase[0:size,0:size]\\n\\n#move to corners\\n\\n expand_phase=roll(expand_phase,-size/2,0)\\n expand_phase=roll(expand_phase,-size/2,1)\\n\\n expand_amp=roll(expand_amp,-size/2,0)\\n expand_amp=roll(expand_amp,-size/2,1)\\n\\n# recalculate real and imaginary part\\n\\n #xr=expand_amp*cos(expand_phase)\\n #yr=expand_amp*sin(expand_phase)\\n\\n# make complex array\\n\\n complexr=expand_amp*numpy.exp(1j*expand_phase)\\n\\n# apply 2d-fft\\n\\n complexr=numpy.fft.fftpack.fft2(complexr)\\n return fftshift(complexr)\",\n \"def plotArt(self):\\n self.isArt=True\\n warr=self.ws.value(self.xarr)\\n asfarr=st.interpolate(warr, self.swarr, self.sfarr, left=0.0, right=0.0)\\n asfarr=asfarr*self.farr.max()/asfarr.max()\\n self.fpcurve,=self.axes.plot(self.xarr,asfarr,linewidth=0.5,linestyle='-',\\n marker='None',color='r')\",\n \"def fdplot(self, imx):\\n fig = plt.figure()\\n maxval = np.max(imx)\\n ims = list(map(lambda im: [plt.imshow(np.fabs(im),norm=colors.Normalize(0.0,maxval))], imx))\\n animation = anim.ArtistAnimation(fig,ims,interval=50)\\n plt.show()\",\n \"def plot_steel_pen_N4255(data_obj, test_num):\\n\\n new_pdf_page(data_obj.pdf_obj) #Create a new page in the pdf for the test results\\n\\n #--------------------------------#\\n # Display the title for the test #\\n #--------------------------------#\\n n_img = len(data_obj.img_data)\\n plt.suptitle('Test ' + str(test_num) + ': Steel penetration (' + str(data_obj.steel_pen) + ' mm)\\\\n' +\\n 'boundary images shown below')\\n\\n #------------------------------------------------------------------------------------#\\n # Display the boundaries of the test for the steps in the steel wedge for each image #\\n #------------------------------------------------------------------------------------#\\n ROI_size = [15 / data_obj.px_size[0], 5 / data_obj.px_size[1]]\\n\\n # Loop for each boundary (step) in the steel wedge / test\\n for i_boundary in np.arange(12):\\n\\n # Go through each image and display the individual boundaries for the penetration test\\n for i_img in np.arange(n_img):\\n\\n # ax2 = fig.add_subplot(n_img,12,12*i_img + i_boundary + 1)\\n plt.subplot(n_img, 12, 12 * i_img + i_boundary + 1)\\n\\n plt.tick_params(axis='both', which='both', bottom='off', left='off', top='off', right='off',\\n labelbottom='off', labelleft='off')\\n\\n #-------------------------------------------------------#\\n # Create a new ROI for each \\\"boundary slice\\\" to display #\\n #-------------------------------------------------------#\\n center0 = data_obj.img_data[i_img].step_wedge_boundaries[i_boundary]\\n center1 = data_obj.img_data[i_img].step_wedge_ROI.shape[1] / 2\\n\\n ROI_i = ROI(data_obj.img_data[i_img].step_wedge_ROI.get_img(), (center0, center1), ROI_size)\\n\\n # Calculate the boundary signal for the ROI\\n bs = calc_boundary_sig(ROI_i, data_obj.img_data[i_img].px_size,\\n ROI_size_mm=2, plot=True, force_middle=True)\\n\\n #------------------------------------------------------------------------------#\\n # Display the additional details to the pdf, formatted for location in the pdf #\\n #------------------------------------------------------------------------------#\\n\\n # Display the area (in mm) that the ROI covers\\n if i_img == 0:\\n plt.title(str(3 * i_boundary) + '/' + str(3 * (i_boundary + 1)) + ' mm', fontsize=7)\\n\\n #Display the BSNR values for the test\\n elif i_img == 3:\\n plt.title('BSNR=' + \\\"{0:.1f}\\\".format(data_obj.steel_pen_BSNR[i_boundary]), fontsize=6)\\n\\n # Display the image (orientation) number\\n if i_boundary == 0:\\n plt.ylabel('Orientation ' + str(i_img + 1), fontsize=7)\",\n \"def main(ngrains=100,sigma=15.,c2a=1.6235,mu=0.,\\n prc='cst',isc=False,tilt_1=0.,\\n tilts_about_ax1=0.,tilts_about_ax2=0.):\\n if isc:\\n h = mmm()\\n else:\\n h=np.array([np.identity(3)])\\n gr = []\\n for i in range(ngrains):\\n dth = random.uniform(-180., 180.)\\n if prc=='cst': g = gen_gr_fiber(th=dth,sigma=sigma,mu=mu,tilt=tilt_1,iopt=0) # Basal//ND\\n elif prc=='ext': g = gen_gr_fiber(th=dth,sigma=sigma,mu=mu,tilt=tilt_1,iopt=1) # Basal//ED\\n else:\\n raise IOError('Unexpected option')\\n for j in range(len(h)):\\n temp = np.dot(g,h[j].T)\\n\\n ## tilts_about_ax1\\n if abs(tilts_about_ax1)>0:\\n g_tilt = rd_rot(tilts_about_ax1)\\n temp = np.dot(temp,g_tilt.T)\\n ## tilts_about_ax2?\\n elif abs(tilts_about_ax2)>0:\\n g_tilt = td_rot(tilts_about_ax2)\\n temp = np.dot(temp,g_tilt.T)\\n elif abs(tilts_about_ax2)>0 and abs(tilts_about_ax2)>0:\\n raise IOError('One tilt at a time is allowed.')\\n\\n phi1,phi,phi2 = euler(a=temp, echo=False)\\n gr.append([phi1,phi,phi2,1./ngrains])\\n\\n mypf=upf.polefigure(grains=gr,csym='hexag',cdim=[1,1,c2a])\\n mypf.pf_new(poles=[[0,0,0,2],[1,0,-1,0]],cmap='jet',ix='TD',iy='RD')\\n return np.array(gr)\",\n \"def visualizeObs():\\n fcontourf(fObs, [-2, 2], [-1, 1], [0, 10])\",\n \"def plot_vanHove_dt(comp,conn,start,step_size,steps):\\n \\n (fin,) = conn.execute(\\\"select fout from comps where comp_key = ?\\\",comp).fetchone()\\n (max_step,) = conn.execute(\\\"select max_step from vanHove_prams where comp_key = ?\\\",comp).fetchone()\\n Fin = h5py.File(fin,'r')\\n g = Fin[fd('vanHove',comp[0])]\\n\\n temp = g.attrs['temperature']\\n dtime = g.attrs['dtime']\\n\\n\\n # istatus = plots.non_i_plot_start()\\n \\n fig = mplt.figure()\\n fig.suptitle(r'van Hove dist temp: %.2f dtime: %d'% (temp,dtime))\\n dims = figure_out_grid(steps)\\n \\n plt_count = 1\\n outs = []\\n tmps = []\\n for j in range(start,start+step_size*steps, step_size):\\n (edges,count,x_lim) = _extract_vanHove(g,j+1,1,5)\\n if len(count) < 50:\\n plt_count += 1\\n continue\\n #count = count/np.sum(count)\\n \\n sp_arg = dims +(plt_count,)\\n ax = fig.add_subplot(*sp_arg)\\n ax.grid(True)\\n\\n \\n alpha = _alpha2(edges,count)\\n \\n ax.set_ylabel(r'$\\\\log{P(N)}$')\\n ax.step(edges,np.log((count/np.sum(count))),lw=2)\\n ax.set_title(r'$\\\\alpha_2 = %.2f$'%alpha + ' j:%d '%j )\\n ax.set_xlim(x_lim)\\n plt_count += 1\\n\\n mplt.draw()\\n\\n # plots.non_i_plot_start(istatus)\\n\\n del g\\n Fin.close()\\n del Fin\",\n \"def display0(*args):\\n #----------*----------* # unpack\\n twiss_func = args[0]\\n cos_like = args[1]\\n sin_like = args[2]\\n lat_plot = args[3]\\n #-------------------- Bahnkoordinate (z)\\n z = [twiss_func(i,'s') for i in range(twiss_func.nbpoints)]\\n sgx = [twiss_func(i,'sigx') for i in range(twiss_func.nbpoints)]\\n sgy = [twiss_func(i,'sigy') for i in range(twiss_func.nbpoints)]\\n # zero = [0. for i in range(sigma_fun.nbpoints)]\\n #-------------------- trajectories (tz)\\n tz= [cos_like(i,'s') for i in range(cos_like.nbpoints)]\\n cx= [cos_like(i,'cx') for i in range(cos_like.nbpoints)]\\n # cxp= [cos_like(i,'cxp') for i in range(cos_like.nbpoints)]\\n cy= [cos_like(i,'cy') for i in range(cos_like.nbpoints)]\\n # cyp= [cos_like(i,'cyp') for i in range(cos_like.nbpoints)]\\n # cz= [cos_like(i,'cz') for i in range(cos_like.nbpoints)]\\n # cdp= [cos_like(i,'cdp') for i in range(cos_like.nbpoints)]\\n\\n sx= [sin_like(i,'sx') for i in range(sin_like.nbpoints)]\\n # sxp= [sin_like(i,'sxp') for i in range(sin_like.nbpoints)]\\n sy= [sin_like(i,'sy') for i in range(sin_like.nbpoints)]\\n # syp= [sin_like(i,'syp') for i in range(sin_like.nbpoints)]\\n # sz= [sin_like(i,'sz') for i in range(sin_like.nbpoints)]\\n # sdp= [sin_like(i,'sdp') for i in range(sin_like.nbpoints)]\\n #-------------------- lattice viseo\\n stop_viseox = 5 # stop viseo plot after so many [m]\\n stop_viseoy = 5 # stop viseo plot after so many [m]\\n vzero = [0. for i in range(lat_plot.nbpoints)] # zero line\\n vis_abszisse = [lat_plot(i,'s') for i in range(lat_plot.nbpoints)]\\n vis_ordinate = [lat_plot(i,'viseo') for i in range(lat_plot.nbpoints)]\\n #-------------------- figure frame\\n width=14; height=7.6\\n plt.figure(num=0,figsize=(width,height),facecolor='#eaecef',tight_layout=False)\\n\\n #-------------------- transverse X\\n splot211=plt.subplot(211)\\n splot211.set_title('transverse x')\\n plt.plot(z,sgx ,label=r'$\\\\sigma$ [m]',color='green')\\n plt.plot(tz,cx ,label='Cx[m]', color='blue',linestyle='-')\\n # plt.plot(tz,cxp,label=\\\"Cx'[m]\\\",color='blue',linestyle=':')\\n plt.plot(tz,sx, label='Sx[m]', color='red' ,linestyle='-')\\n # plt.plot(tz,sxp,label=\\\"Sx'[m]\\\",color='red' ,linestyle=':')\\n # vscale=plt.axis()[3]*0.1\\n # viseox = [x*vscale for x in vis_ordinate]\\n # for i,s in enumerate(vis_abszisse):\\n # if s > stop_viseox:\\n # viseox[i] = 0.\\n # plt.plot(vis_abszisse,viseox,label='',color='black')\\n plt.plot(vis_abszisse,vzero,color='black')\\n plt.legend(loc='lower right',fontsize='x-small')\\n\\n #-------------------- transverse Y\\n splot212=plt.subplot(212)\\n splot212.set_title('transverse y')\\n plt.plot(z,sgy ,label=r'$\\\\sigma$ [m]',color='green')\\n plt.plot(tz,cy, label='Cy[m]', color='blue',linestyle='-')\\n # plt.plot(tz,cyp,label=\\\"Cy'[m]\\\",color='blue',linestyle=':')\\n plt.plot(tz,sy, label='Sy[m]', color='red' ,linestyle='-')\\n # plt.plot(tz,syp,label=\\\"Sy'[m]\\\",color='red' ,linestyle=':')\\n vscale=plt.axis()[3]*0.1\\n viseoy = [x*vscale for x in vis_ordinate]\\n # for i,s in enumerate(vis_abszisse):\\n # if s > stop_viseoy:\\n # viseoy[i] = 0.\\n plt.plot(vis_abszisse,viseoy,label='',color='black')\\n plt.plot(vis_abszisse,vzero,color='black')\\n plt.legend(loc='lower right',fontsize='x-small')\",\n \"def plot_waterfall(d, freqs, lsts, t_unit='hr', f_unit='MHz',\\n raster=True):\\n\\n plt.imshow(d, aspect='auto', interpolation='none',\\n rasterized=raster,\\n extent=(freqs[0], freqs[-1], lsts[0], lsts[-1]))\\n plt.xlabel(\\\"Frequency [%s]\\\" % f_unit)\\n plt.ylabel(\\\"Time [%s]\\\" % t_unit)\",\n \"def DisplayMesh():\\r\\n \\r\\n # Load Surface Mesh Data and generate normals\\r\\n VTKString = OpenData('C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles','muscle_surface.vtk')\\r\\n header, Vertices, Triangles = CreateMatrixVTK(VTKString)\\r\\n \\r\\n fig = plt.figure()\\r\\n ax1 = fig.add_subplot(111,projection = '3d')\\r\\n ax1.plot_trisurf(Vertices[:,0],Vertices[:,1],Vertices[:,2],triangles= Triangles[:,1:])\\r\\n ax1.set_zlabel('z')\\r\\n ax1.set_ylabel('y')\\r\\n ax1.set_xlabel('x')\\r\\n plt.show()\",\n \"def plot_fr_and_spikes(self, t):\\n plt.figure(figsize=(10, 8))\\n\\n plt.subplot(2, 2, 1)\\n self.plot_base_image()\\n\\n plt.subplot(2, 2, 2)\\n self.plot_firing_rates(t, mode='ON')\\n plt.title('Retinal Image')\\n\\n # Spikes\\n ax = plt.subplot(2, 2, 3)\\n self.plot_spikes(ax, t, mode='ON', moving_average=True)\\n\\n ax = plt.subplot(2, 2, 4)\\n self.plot_spikes(ax, t, mode='OFF', moving_average=True)\",\n \"def app_SN_animated_gradient_plot(self):\\n print('this option is yet to be implemented')\",\n \"def opacity(nu, T, n_HI, n_e, n_l, rv, line='halpha'):\\n n_l_cgs = n_l * 1e-6\\n balmer_properties = {'wavelength': {'halpha': 6562.8e-10, 'hbeta': 4861.35e-10, 'hgamma': 4340.47e-10, 'hdelta': 4101.73e-10},\\n 'f_osc': {'halpha': 6.407e-1, 'hbeta': 1.1938e-1, 'hgamma': 4.4694e-2, 'hdelta': 2.2105e-2},\\n 'Aul' : {'halpha': 4.4101e7, 'hbeta': 8.4193e6, 'hgamma' : 2.530e6, 'hdelta': 9.732e5}}\\n nu_0 = constants.c / balmer_properties['wavelength'][line]\\n f_line = balmer_properties['f_osc'][line]\\n\\n u, a, delta_nu = u_a(nu, nu_0, n_HI, n_e, T, rv, line=line)\\n phi_nu = voigt(u, a) / ( np.pi**.5 * delta_nu )\\n C_osc = ( np.pi * consts.e.esu.value**2 / (consts.m_e.cgs.value * consts.c.cgs.value ) )\\n abs_coeff_cgs = C_osc * f_line * phi_nu * n_l_cgs * ( 1 - np.exp(-constants.h * nu_0 / (constants.k * T )))\\n abs_coeff_si = abs_coeff_cgs * 1e2\\n\\n return abs_coeff_si\",\n \"def zernikeHexapodTrend(mnts='M20'):\\n Tfile='/home/jghao/research/decamFocus/psf_withseeing/finerGrid_coeff_matrix/zernike_coeff_finerGrid_training.cp'\\n b=p.load(open(Tfile))\\n nobs = len(b)\\n x = b[:,0]\\n y = b[:,1]\\n z = b[:,2]\\n theta = b[:,3]\\n phi = b[:,4]\\n fwhm = b[:,5]\\n e1 = b[:,6]\\n e2 = b[:,7]\\n thetax = theta*np.cos(np.deg2rad(phi))\\n thetay = theta*np.sin(np.deg2rad(phi))\\n if mnts == 'M20':\\n idxBase = 9\\n if mnts == 'M22real':\\n idxBase = 29\\n if mnts == 'M22imag':\\n idxBase = 49\\n idx = np.arange(14)\\n zernikeName=('Piston','Tip','Tilt','Astignism','Defocus','Astignism','Trefoil','Coma','Coma','Trefoil','Ashtray','Astigm.5th','Spherical','Astigm.5th','Ashtray','16','17','18','19','20')\\n for i in range(14):\\n pl.figure(figsize=(21,10))\\n pl.subplot(2,3,1)\\n bp.bin_scatter(x,b[:,idxBase+idx[i]],binsize=0.01,fmt='bo',scatter=True)\\n pl.xlabel('x decenter')\\n pl.ylabel(zernikeName[i+1])\\n pl.title(mnts)\\n pl.subplot(2,3,2)\\n bp.bin_scatter(y,b[:,idxBase+idx[i]],binsize=0.01,fmt='bo',scatter=True)\\n pl.xlabel('y decenter')\\n pl.ylabel(zernikeName[i+1])\\n pl.title(mnts)\\n pl.subplot(2,3,3)\\n bp.bin_scatter(z,b[:,idxBase+idx[i]],binsize=0.01,fmt='bo',scatter=True)\\n pl.xlabel('z-defocus')\\n pl.ylabel(zernikeName[i+1])\\n pl.title(mnts)\\n pl.subplot(2,3,4)\\n bp.bin_scatter(thetax,b[:,idxBase+idx[i]],binsize=5,fmt='bo',scatter=True)\\n pl.xlabel('x-tilt')\\n pl.ylabel(zernikeName[i+1])\\n pl.title(mnts)\\n pl.subplot(2,3,5)\\n bp.bin_scatter(thetay,b[:,idxBase+idx[i]],binsize=5,fmt='bo',scatter=True)\\n pl.xlabel('y-tilt')\\n pl.ylabel(zernikeName[i+1])\\n pl.title(mnts)\\n pl.savefig(mnts+'_'+str(i+1)+'_'+zernikeName[i+1]+'.png')\\n pl.close()\",\n \"def plot_map(priors):\\n sns.set_style(\\\"white\\\")\\n\\n cmap=sns.cubehelix_palette(8, start=.5, rot=-.75,as_cmap=True)\\n hdulists=list(map(lambda prior:postmaps.make_fits_image(prior,prior.sim), priors))\\n fig = plt.figure(figsize=(10*len(priors),10))\\n figs=[]\\n for i in range(0,len(priors)):\\n figs.append(aplpy.FITSFigure(hdulists[i][1],figure=fig,subplot=(1,len(priors),i+1)))\\n\\n for i in range(0,len(priors)):\\n vmin=np.min(priors[i].sim)\\n vmax=np.max(priors[i].sim)\\n figs[i].show_colorscale(vmin=vmin,vmax=vmax,cmap=cmap)\\n figs[i].show_markers(priors[i].sra, priors[i].sdec, edgecolor='black', facecolor='black',\\n marker='o', s=20, alpha=0.5)\\n figs[i].tick_labels.set_xformat('dd.dd')\\n figs[i].tick_labels.set_yformat('dd.dd')\\n figs[i].add_colorbar()\\n figs[i].colorbar.set_location('top')\\n return figs,fig\",\n \"def cov_plot(self, matrix, station=\\\"\\\", hour = \\\"\\\", date=\\\"\\\" , averaged = \\\"\\\" ):\\n var = self.var_dics[self.var]['name'] \\n fig,ax = plt.subplots()\\n date = self.date_prettyfier(date)\\n hour = str(hour).replace('0','00:00').replace('1','12:00')\\n if not averaged:\\n title = \\\"Stat: \\\" + station + ', H: ' + hour + ', Date: ' + date + ', ' + var\\n filename = 'Cov_' + station + '_hour_' + hour.replace(':','') + '_date_' + str(date).replace('/','') + '_' +var\\n \\n elif averaged :\\n title = var.replace('temp','Temp.') + \\\" , Stat: \\\" + station + ', H: ' + str(hour) + ', Date: ' + str(date)\\n filename ='Cov_' + station + '_hour_' + str(hour).replace(':','') + '_averaged_' + str(date).replace('/','') + '_' + var \\n\\n plt.title(title.replace('_', ' ' ), y=1.03, fontsize = self.font-2)\\n\\n num = len(matrix[0,:])\\n Num = range(num)\\n\\n vmin, vmax = -3, 3\\n if self.var == 'direction': \\n vmin, vmax = -10, 10\\n color_map= plt.imshow(matrix, interpolation= 'nearest', cmap = 'RdYlBu', vmin = vmin, vmax = vmax ) # nearest serves for discreete grid # cmaps blue, seismic \\n plt.ylim(-0.5, 15.5)\\n plt.xlim(-0.5, 15.5)\\n plt.xticks(Num, Num)\\n plt.xlabel('Pressure level an_dep [hPa]', fontsize = self.font-2)\\n plt.yticks(Num, Num)\\n plt.ylabel('Pressure level fg_dep [hPa]', fontsize = self.font-2)\\n ax.set_xticklabels(labels = self.pretty_pressure, fontsize = self.font-4, rotation=45)\\n ax.set_yticklabels(labels = self.pretty_pressure, fontsize = self.font-4)\\n\\n bar = plt.colorbar()\\n bar.ax.set_ylabel(\\\"Covariance\\\", fontsize = self.font)\\n \\n for i in Num: # creating text labels\\n for j in Num:\\n value = '{0:.2f}'.format(matrix[i,j])\\n text = ax.text( j,i, value , ha = 'center' , va = 'center', color = 'black', fontsize = 5)\\n\\n if not os.path.isdir('plots/covariances/'+station): os.mkdir('plots/covariances/'+station)\\n plt.savefig('plots/covariances/' + station + '/' + filename + '.png', bbox_inches='tight', dpi = 200)\\n plt.close()\",\n \"def find_chart():\\r\\n ###############################################\\r\\n # Read values of S/N\\r\\n sn = np.loadtxt(outtable, usecols=(14,))\\r\\n xs, ys = np.loadtxt(outtable, usecols=(1, 2)).T\\r\\n specs = np.loadtxt(outtable, usecols=(0,), dtype=str)\\r\\n ###############################################\\r\\n # Find good (and bad) regions according to S/N\\r\\n good = np.where(((~np.isnan(sn)) & (sn >= sn_cut)))[0]\\r\\n bad = np.where((sn < sn_cut))[0]\\r\\n ###############################################\\r\\n # Filter arrays for S/N\\r\\n sn = sn[good]\\r\\n xs = xs[good]\\r\\n ys = ys[good]\\r\\n specs = specs[good].tolist()\\r\\n specs = [x.replace(\\\".fits\\\", \\\"\\\")[1:] for x in specs]\\r\\n ###############################################\\r\\n # Set limits for the plot\\r\\n norm = Normalize(0, 1)\\r\\n ###############################################\\r\\n # Set colormap\\r\\n # cmap = brewer2mpl.get_map('YlGnBu', 'sequential', 5).mpl_colormap\\r\\n # Produces a collection of polygons with colors according to S/N values\\r\\n coll = PolyCollection(polygons_bins[good], array=np.ones_like(sn),\\r\\n cmap=\\\"gray\\\", edgecolors='0.5', norm=norm)\\r\\n ###############################################\\r\\n # Initiate figure and axis for matplotlib\\r\\n fig = plt.figure(figsize=(6.25, 6))\\r\\n gs = gridspec.GridSpec(1, 1)\\r\\n gs.update(left=0.08, right=0.985, bottom=0.08, top=0.985, hspace=0.05,\\r\\n wspace=0.06)\\r\\n ax = plt.subplot(gs[0])\\r\\n ###############################################\\r\\n # Draw the polygons\\r\\n draw_map(fig, ax, coll)\\r\\n ###############################################\\r\\n # Add contours according to V-band image\\r\\n draw_contours(\\\"vband\\\", fig, ax)\\r\\n ###############################################\\r\\n for x, y, spec in zip(xs, ys, specs):\\r\\n ax.text(x, y, spec, fontsize=10)\\r\\n # Write labels\\r\\n xylabels(ax)\\r\\n ##############################################\\r\\n # Save the figure\\r\\n plt.show()\\r\\n plt.savefig(\\\"figs/find_chart.pdf\\\")\\r\\n return\",\n \"def plot_overview(cube=nro_12co,\\n region_file='../shell_candidates/AllShells.reg', mode='peak', plotname='12co_peak_shells.png',\\n interactive=False, show_shells=True, shells_highlight=None, dist=orion_dist, vmin=None, vmax=None,\\n scalebar_color=\\\"white\\\", scalebar_pc = 1., scale_factor=1., pmin=0.25,\\n pmax=99.75, cbar_label=r\\\"Peak T$_{\\\\rm MB}$ [K]\\\",\\n circle_color='white', circle_linewidth=1, circle_style=\\\"solid\\\", return_fig=False, show=True,\\n title=r\\\"$^{12}$CO Peak T$_{MB}$\\\", recenter=False, ra=None, dec=None, radius=None):\\n try:\\n cube = SpectralCube.read(cube)\\n except ValueError:\\n pass\\n\\n if mode == \\\"peak\\\":\\n image = (cube.max(axis=0) * scale_factor).hdu\\n \\n\\n if mode == \\\"mom0\\\":\\n image = (cube.moment0() * scale_factor).hdu\\n\\n\\n\\n fig = FITSFigure(image)\\n if show:\\n fig.show_colorscale(cmap='viridis', vmin=vmin, vmax=vmax, pmin=pmin,\\n pmax=pmax, interpolation='none')\\n fig.tick_labels.set_yformat(\\\"dd:mm\\\")\\n fig.tick_labels.set_xformat(\\\"hh:mm\\\")\\n #fig.hide_yaxis_label()\\n #fig.hide_ytick_labels()\\n plt.title(title)\\n plt.xlabel(\\\"RA (J2000)\\\")\\n plt.ylabel(\\\"DEC (J2000)\\\")\\n\\n if show_shells:\\n shell_list = get_shells(region_file=region_file)\\n for i, shell in enumerate(shell_list):\\n if shells_highlight:\\n if i+1 in shells_highlight:\\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle='solid', edgecolor=circle_color,\\n facecolor='none', linewidth=3)\\n else:\\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle=circle_style, edgecolor=circle_color,\\n facecolor='none', linewidth=circle_linewidth)\\n else:\\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle=circle_style, edgecolor=circle_color,\\n facecolor='none', linewidth=circle_linewidth)\\n\\n #RECENTER\\n if recenter:\\n fig.recenter(ra, dec, radius)\\n\\n\\n #SCALEBAR\\n fig.add_scalebar(206265 * scalebar_pc / (dist.to(u.pc).value * 3600), color=scalebar_color)\\n fig.scalebar.set_label(\\\"{} pc\\\".format(scalebar_pc))\\n\\n fig.add_colorbar()\\n cb = fig.colorbar\\n cb.set_axis_label_text(cbar_label)\\n\\n if return_fig:\\n return fig\\n else:\\n fig.save(plotname, dpi=600)\",\n \"def data_vis():\\n dataroot = 'solar_data.txt'\\n debug = False \\n diff = False\\n X, y = read_data(dataroot, debug, diff)\\n\\n # First plot the original timeseries\\n fig = plt.figure(figsize=(40,40))\\n\\n fig.add_subplot(3,3,1)\\n plt.plot(y)\\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,2)\\n plt.plot(X[:,0])\\n plt.title('Avg Zenith Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,3)\\n plt.plot(X[:,1])\\n plt.title('Avg Azimuth Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,4)\\n plt.plot(X[:,2])\\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,5)\\n plt.plot(X[:,3])\\n plt.title('Avg Tower RH [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,6)\\n plt.plot(X[:,4])\\n plt.title('Avg Total Cloud Cover [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,7)\\n plt.plot(X[:,5])\\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\\n # plt.show()\\n\\n ##########################################################################################\\n # Plotting the Fourier Transform of the signals\\n\\n freq = np.fft.fftfreq(len(y), 1*60*60)\\n\\n fig = plt.figure(figsize=(40,40))\\n\\n fig.add_subplot(3,3,1)\\n plt.plot(freq, np.abs(np.fft.fft(y)))\\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,2)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,0])))\\n plt.title('Avg Zenith Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,3)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,1])))\\n plt.title('Avg Azimuth Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,4)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,2])))\\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,5)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,3])))\\n plt.title('Avg Tower RH [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,6)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,4])))\\n plt.title('Avg Total Cloud Cover [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,7)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,5])))\\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\\n # plt.show()\\n\\n ##################################################################################################\\n # Print correlation matrix\\n\\n df = pd.DataFrame(np.c_[y, X])\\n df.columns = ['Avg Global PSP (vent/cor) [W/m^2]','Avg Zenith Angle [degrees]','Avg Azimuth Angle [degrees]','Avg Tower Dry Bulb Temp [deg C]','Avg Tower RH [%]','Avg Total Cloud Cover [%]','Avg Avg Wind Speed @ 6ft [m/s]']\\n f = plt.figure(figsize=(19, 15))\\n plt.matshow(df.corr(), fignum=f.number)\\n plt.xticks(range(df.shape[1]), df.columns, fontsize=14, rotation=20)\\n plt.yticks(range(df.shape[1]), df.columns, fontsize=14)\\n cb = plt.colorbar()\\n cb.ax.tick_params(labelsize=14)\\n plt.title('Correlation Matrix', fontsize=16);\\n plt.show()\",\n \"def plot_combined_spectrum(SSC, band):\\n\\n def get_spectrum(SSC, band):\\n spectrum = spectra[str(SSC['no'])][band]\\n frequency = spectrum['frequency'].to(u.GHz)\\n intensity = spectrum['spectrum'].to(u.K)\\n # shift spectrum to rest frequency\\n velshift = SSC['velshift']\\n frequency = [(-vsys-velshift).to(u.GHz, equivalencies=u.doppler_optical(f)).value for f in frequency]*u.GHz\\n # remove NaNs\\n frequency, intensity = crossmatch(frequency.to(u.GHz).value, intensity.to(u.K).value)\\n return frequency, intensity\\n\\n def get_model(SSC, band):\\n with open(escape_fname(os.path.join(XCLASSdir,'SSC_'+str(SSC['no']),'combined_model.spectrum.pickle')), 'rb') as f:\\n m = pickle.load(f, encoding=\\\"latin1\\\")\\n frequency = (m[:,0]*u.MHz).to(u.GHz)\\n model = m[:,1]*u.K\\n return frequency.value,model.value\\n\\n def set_up_figure(SSC, band):\\n fig,ax = plt.subplots(nrows=1, ncols=1, squeeze=True, sharex='col', sharey='row', figsize=(10,8))\\n ax.text(0.05, 0.9, 'SSC '+str(SSC['no'])+': '+band, color='k', transform=ax.transAxes, ha='left', va='top', weight='bold', fontsize=16, bbox=props)\\n return fig,ax\\n\\n def plot_spectrum(ax, frequency, spectrum):\\n ax.plot(frequency, spectrum, lw=1, ls='-', color='k', zorder=3)\\n ax.fill_between(frequency, spectrum, [0. for f in frequency], color='grey', alpha=0.5, zorder=2)\\n\\n def plot_fitted_spectrum(ax, frequency, model):\\n ax.plot(frequency, model, lw=1, ls='-', color='r', zorder=5)\\n # ax.fill_between(frequency, model, [0. for f in frequency], color='r', alpha=0.5, zorder=4)\\n\\n def get_detected_lines(band=None):\\n # get detected species\\n all_species = []\\n for SSC in SSCs:\\n for specie in detected_species[str(SSC['no'])]:\\n if not specie in all_species:\\n all_species.append(specie)\\n # get all lines of the detected species\\n all_lines = []\\n for specie in all_species:\\n slines = [l for l in lines if l['XCLASS']==specie]\\n for sl in slines:\\n all_lines.append(sl)\\n # keep only lines of given band\\n if not band==None:\\n bandlines = []\\n for line in all_lines:\\n if band=='LSB':\\n if line['restfreq']<350*u.GHz:\\n bandlines.append(line)\\n elif band=='USB':\\n if line['restfreq']>350*u.GHz:\\n bandlines.append(line)\\n return sorted(bandlines, key=lambda k: k['restfreq'])\\n else:\\n return sorted(all_lines, key=lambda k: k['restfreq'])\\n\\n def label_lines(ax, spectrum, band):\\n detected_lines = get_detected_lines(band=band)\\n for idx,line in enumerate(detected_lines):\\n restfreq = line['restfreq'].to(u.GHz).value\\n if (restfreq>frequency[0] and restfreq<frequency[-1]):\\n if band=='LSB':\\n xlim = [342.4, 346.2]\\n elif band=='USB':\\n xlim = [354.3, 358.1]\\n xloc = xlim[0] +((idx+0.5)/len(detected_lines))*(xlim[1]-xlim[0])\\n ax.axvline(x=restfreq, ymin=0, ymax=1, color='dimgrey', ls='--', lw=0.5, zorder=1)\\n ax.plot([restfreq,xloc], [1.05*np.nanmax(spectrum), 1.05*1.05*np.nanmax(spectrum)], color='dimgrey', ls='--', lw=0.5, zorder=1, clip_on=False)\\n ax.text(xloc, 1.06*1.05*np.nanmax(spectrum), line_tex(line), color='dimgrey', fontsize=10, rotation=90, ha='center', va='bottom')\\n\\n def format_figure(ax, frequency, spectrum, band):\\n if band=='LSB':\\n ax.set_xlim([342.4, 346.2])\\n elif band=='USB':\\n ax.set_xlim([354.3, 358.1])\\n ax.set_ylim(-0.05*np.nanmax(spectrum), 1.05*np.nanmax(spectrum))\\n ax.xaxis.set_major_locator(MultipleLocator(0.5))\\n ax.xaxis.set_minor_locator(MultipleLocator(0.1))\\n ax.yaxis.set_major_locator(MultipleLocator(10))\\n ax.yaxis.set_minor_locator(MultipleLocator(2))\\n ax.tick_params(axis='both', which='major', labelsize=12)\\n ax.set_axisbelow(True)\\n ax.grid(axis='y', ls=':', c='grey')\\n ax.set_xlabel(r'$\\\\nu_\\\\mathrm{rest}$ [GHz]', fontsize=12)\\n ax.set_ylabel(r'T$_\\\\mathrm{b}$ [K]', fontsize=12)\\n fig.set_tight_layout(True)\\n\\n def save_figure(fig, band):\\n savepath = escape_fname(os.path.join(plotdir, '03.XCLASS_fit', 'combined_spectra', 'SSC_'+str(SSC['no'])+'.'+band+'.combined_spectrum.pdf'))\\n os.system('mkdir -p '+os.path.dirname(savepath))\\n fig.savefig(savepath, dpi=300, bbox_inches='tight')\\n\\n\\n frequency, spectrum = get_spectrum(SSC, band)\\n mfrequency, model = get_model(SSC, band)\\n fig,ax = set_up_figure(SSC, band)\\n plot_spectrum(ax, frequency, spectrum)\\n plot_fitted_spectrum(ax, mfrequency, model)\\n label_lines(ax, spectrum, band)\\n format_figure(ax, frequency, spectrum, band)\\n save_figure(fig, band)\",\n \"def test1():\\n\\t\\n\\td = np.arange(-10000,10000,10) # MHz\\n\\t#Voigt\\n\\tp_dict = {'Bfield':300,'rb85frac':1,'Btheta':0,'lcell':75e-3,'T':58,'Dline':'D2','Elem':'Cs'}\\n\\t\\n\\t#timing:\\n\\tst = time.clock()\\n\\tTF = get_spectra(d,[1,0,0],p_dict,outputs=['Iy'])\\n\\tet = time.clock() - st\\n\\tprint(('E-field - Elapsed time (s):', et))\\n\\n\\t'''\\n\\t#check vs old elecsus\\n\\tfrom elecsus_v2.libs import spectra as old_spec\\n\\tst = time.clock()\\n\\tTF_old = old_spec.get_spectra(d,p_dict,outputs=['Iy'])\\n\\tet = time.clock() - st\\n\\tprint 'Old elecsus - Elapsed time (s):', et\\n\\t'''\\n\\t\\n\\tfig = plt.figure(\\\"Faraday comparison\\\")\\n\\tax1 = fig.add_subplot(111)\\n\\tax1.plot(d,TF[0],'r',lw=2,label='Faraday')\\n\\t#ax1.plot(d,TF_old[0],'k--',lw=2,label='Vanilla ElecSus')\\n\\t\\n\\t#ax1.legend(loc=0)\\n\\t\\n\\tax1.set_xlabel('Detuning (MHz)')\\n\\tax1.set_ylabel('Transmission')\\n\\t\\n\\tplt.show()\",\n \"def hexapodZernikeLinearModel():\\n Tfile='/home/jghao/research/decamFocus/psf_withseeing/finerGrid_coeff_matrix/zernike_coeff_finerGrid_training.cp'\\n b=p.load(open(Tfile))\\n nobs = len(b)\\n x = b[:,0]\\n y = b[:,1]\\n z = b[:,2]\\n theta = b[:,3]\\n phi = b[:,4]\\n fwhm = b[:,5]\\n e1 = b[:,6]\\n e2 = b[:,7]\\n thetax = theta*np.cos(np.deg2rad(phi))\\n thetay = theta*np.sin(np.deg2rad(phi))\\n \\n M22realTrefoil2 = b[:,37] # for x decenter\\n M22imagTrefoil1 = b[:,54] \\n M22TrefoilXshift = 0.5*(M22realTrefoil2+M22imagTrefoil1)\\n\\n M22realTrefoil1 = b[:,34] # for y decenter\\n M22imagTrefoil2 = b[:,57] \\n M22TrefoilYshift = 0.5*(M22realTrefoil1 - M22imagTrefoil2)\\n\\n M20defocus = b[:,12] # for defocus\\n\\n M22realComa2 = b[:,36] # for x-tilt\\n M22imagComa1 = b[:,55]\\n M22ComaXtilt = 0.5*(M22realComa2+M22imagComa1)\\n\\n M22realComa1 = b[:,35] # for y-tilt\\n M22imagComa2 = b[:,56]\\n M22ComaYtilt = 0.5*(M22realComa1 - M22imagComa2)\\n \\n pl.figure(figsize=(21,12))\\n pl.subplot(2,3,1)\\n t=bp.bin_scatter(M22TrefoilXshift,x,nbins=20,fmt='bo',scatter=True)\\n res = linefit(M22TrefoilXshift,x)\\n pl.plot(M22TrefoilXshift,M22TrefoilXshift*res[1]+res[0],'r,')\\n pl.ylabel('x-decenter')\\n pl.xlabel('(M22realTrefoil2+M22imagTrefoil1)/2')\\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\\n pl.subplot(2,3,2)\\n t=bp.bin_scatter(M22TrefoilYshift,y,nbins=20,fmt='bo',scatter=True)\\n res = linefit(M22TrefoilYshift,y)\\n pl.plot(M22TrefoilYshift,M22TrefoilYshift*res[1]+res[0],'r,')\\n pl.ylabel('y-decenter')\\n pl.xlabel('(M22realTrefoil1 - M22imagTrefoil2)/2')\\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\\n pl.subplot(2,3,3)\\n t=bp.bin_scatter(M20defocus,z,nbins=20,fmt='bo',scatter=True)\\n res = linefit(M20defocus,z)\\n pl.plot(M20defocus,M20defocus*res[1]+res[0],'r,')\\n pl.ylabel('z-defocus')\\n pl.xlabel('M20defocus')\\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\\n pl.subplot(2,3,4)\\n t=bp.bin_scatter(M22ComaXtilt,thetax,nbins=20,fmt='bo',scatter=True)\\n res = linefit(M22ComaXtilt,thetax)\\n pl.plot(M22ComaXtilt,M22ComaXtilt*res[1]+res[0],'r,')\\n pl.ylabel('x-tilt')\\n pl.xlabel('(M22realComa2+M22imagComa1)/2')\\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\\n pl.subplot(2,3,5)\\n t=bp.bin_scatter(M22ComaYtilt,thetay,nbins=20,fmt='bo',scatter=True)\\n res = linefit(M22ComaYtilt,thetay)\\n pl.plot(M22ComaYtilt,M22ComaYtilt*res[1]+res[0],'r,')\\n pl.ylabel('y-tilt')\\n pl.xlabel('(M22realComa1 - M22imagComa2)/2')\\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\\n\\n pl.close()\",\n \"def plotAll(fx,tfarray,tlst,flst,fignum=1,starttime=0,timeinc='hrs',\\r\\n dt=1.0,title=None,vmm=None,cmap=None,aspect=None,interpolation=None,\\r\\n cbori=None,cbshrink=None,cbaspect=None,cbpad=None,normalize='n',\\r\\n scale='log'):\\r\\n \\r\\n #time increment\\r\\n if timeinc=='hrs':\\r\\n tinc=3600/dt\\r\\n elif timeinc=='min':\\r\\n tinc=60/dt\\r\\n elif timeinc=='sec':\\r\\n tinc=1/dt\\r\\n else:\\r\\n raise ValueError(timeinc+'is not defined')\\r\\n #colormap\\r\\n if cmap==None:\\r\\n cmap='jet'\\r\\n else:\\r\\n cmap=cmap\\r\\n #aspect ratio\\r\\n if aspect==None:\\r\\n aspect='auto'\\r\\n else:\\r\\n aspect=aspect\\r\\n #interpolation\\r\\n if interpolation==None:\\r\\n interpolation='gaussian'\\r\\n else:\\r\\n interpolation=interpolation\\r\\n #colorbar orientation\\r\\n if cbori==None:\\r\\n cbori='vertical'\\r\\n else:\\r\\n cbori=cbori\\r\\n #colorbar shinkage\\r\\n if cbshrink==None:\\r\\n cbshrink=.99\\r\\n else:\\r\\n cbshrink=cbshrink\\r\\n #colorbar aspect\\r\\n if cbaspect==None:\\r\\n cbaspect=20\\r\\n else:\\r\\n cbaspect=cbaspect\\r\\n #colorbar pad\\r\\n if cbpad==None:\\r\\n cbpad=.1\\r\\n else:\\r\\n cbpad=cbpad\\r\\n \\r\\n #scale\\r\\n if scale=='log':\\r\\n zerofind=np.where(abs(tfarray)==0)\\r\\n tfarray[zerofind]=1.0\\r\\n if normalize=='y':\\r\\n plottfarray=20*np.log10(abs(tfarray/np.max(abs(tfarray))))\\r\\n else:\\r\\n plottfarray=20*np.log10(abs(tfarray))\\r\\n elif scale=='linear':\\r\\n if normalize=='y':\\r\\n plottfarray=abs(plottfarray/np.max(abs(plottfarray)))**2\\r\\n else:\\r\\n plottfarray=abs(tfarray)**2\\r\\n \\r\\n t=np.arange(len(fx))*dt+starttime*dt\\r\\n FX=np.fft.fft(padzeros(fx))\\r\\n FXfreq=np.fft.fftfreq(len(FX),dt)\\r\\n \\r\\n #set some plot parameters\\r\\n plt.rcParams['font.size']=10\\r\\n plt.rcParams['figure.subplot.left']=.13\\r\\n plt.rcParams['figure.subplot.right']=.98\\r\\n plt.rcParams['figure.subplot.bottom']=.07\\r\\n plt.rcParams['figure.subplot.top']=.96\\r\\n plt.rcParams['figure.subplot.wspace']=.25\\r\\n plt.rcParams['figure.subplot.hspace']=.20\\r\\n #plt.rcParams['font.family']='helvetica'\\r\\n \\r\\n fig=plt.figure(fignum)\\r\\n \\r\\n #plot FFT of fx\\r\\n fax=fig.add_axes([.05,.25,.1,.7])\\r\\n plt.plot(abs(FX[0:len(FX)/2]/max(abs(FX)))**2,FXfreq[0:len(FX)/2],'-k')\\r\\n plt.xlim(0,1)\\r\\n plt.ylim(0,FXfreq[len(FX)/2-1])\\r\\n fax.xaxis.set_major_locator(MultipleLocator(.5))\\r\\n \\r\\n #plot TFD\\r\\n pax=fig.add_axes([.25,.25,.75,.7])\\r\\n if vmm!=None:\\r\\n vmin=vmm[0]\\r\\n vmax=vmm[1]\\r\\n plt.imshow(plottfarray,extent=(tlst[0]/tinc,tlst[-1]/tinc,\\r\\n flst[0],flst[-1]),aspect=aspect,vmin=vmin,vmax=vmax,cmap=cmap,\\r\\n interpolation=interpolation)\\r\\n else:\\r\\n plt.imshow(plottfarray,extent=(tlst[0]/tinc,tlst[-1]/tinc,\\r\\n flst[0],flst[-1]),aspect=aspect,cmap=cmap,\\r\\n interpolation=interpolation)\\r\\n plt.xlabel('Time('+timeinc+')',fontsize=12,fontweight='bold')\\r\\n plt.ylabel('Frequency (Hz)',fontsize=12,fontweight='bold')\\r\\n if title!=None:\\r\\n plt.title(title,fontsize=14,fontweight='bold')\\r\\n plt.colorbar(orientation=cbori,shrink=cbshrink,pad=cbpad,aspect=cbaspect)\\r\\n \\r\\n #plot timeseries\\r\\n tax=fig.add_axes([.25,.05,.60,.1])\\r\\n plt.plot(t,fx,'-k')\\r\\n plt.axis('tight')\\r\\n plt.show()\",\n \"def flatNoisePellicle():\\n #Get data\\n wdir = '/home/rallured/Dropbox/AXRO/Metrology/' \\\\\\n 'NoiseStudy/SolarBwPellicle/'\\n d1,dx1 = met.read4DFits(wdir+'161209_Avg8_Meas1.fits')\\n d2,dx2 = met.read4DFits(wdir+'161209_Avg8_Meas2.fits')\\n d3,dx3 = met.read4DFits(wdir+'161209_Avg8_Meas3.fits')\\n d4,dx4 = met.read4DFits(wdir+'161209_Avg8_Meas4.fits')\\n\\n #Construct power spectra\\n f12,pow12 = fourier.meanPSD((d1-d2)[:,100:-100],\\\\\\n win=np.hanning,dx=dx1,irregular=True)\\n f23,pow23 = fourier.meanPSD((d2-d3)[:,100:-100],\\\\\\n win=np.hanning,dx=dx1,irregular=True)\\n f34,pow34 = fourier.meanPSD((d3-d4)[:,100:-100],\\\\\\n win=np.hanning,dx=dx1,irregular=True)\\n f14,pow14 = fourier.meanPSD((d1-d4)[:,100:-100],\\\\\\n win=np.hanning,dx=dx1,irregular=True)\\n\\n #Mid frequency\\n midfreq = [1000*np.sqrt(np.sum(p[np.logical_and(f>.1,f<1.)])) \\\\\\n for f,p in zip([f12,f23,f34,f14],[pow12,pow23,pow34,pow14])]\\n\\n #Plot\\n plt.loglog(f12,pow12/f12[0],label='1-2: %.2f' % midfreq[0])\\n plt.loglog(f23,pow23/f23[0],label='2-3: %.2f' % midfreq[1])\\n plt.loglog(f34,pow34/f34[0],label='3-4: %.2f' % midfreq[2])\\n plt.loglog(f14,pow14/f14[0],label='1-4: %.2f' % midfreq[3])\\n plt.legend(loc='lower left')\\n plt.grid()\\n plt.title('4D Repeatability: SolarB Flat+Pellicle')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n\\n print midfreq\\n\\n return f12,pow12\",\n \"def plotBrighterFatter(out='BrighterFatter.pdf', requirementFWHM=10.8, sigma=3):\\n matplotlib.rc('text', usetex=True)\\n\\n #600nm\\n low = [fileIO.cPicleRead(file) for file in g.glob('results/I600nm5k*.pkl')]\\n med = [fileIO.cPicleRead(file) for file in g.glob('results/I600nm10k*.pkl')]\\n high = [fileIO.cPicleRead(file) for file in g.glob('results/I600nm54k*.pkl')]\\n data = (low, med, high)\\n fluxes600 = []\\n fluxes600err = []\\n wx600 = []\\n wxerrs = []\\n wy600 = []\\n wyerrs = []\\n for x in data:\\n wx = np.median([d['wx'] for d in x])\\n wxerr = np.median([d['wxerr'] for d in x])\\n wy = np.median([d['wy'] for d in x])\\n wyerr = np.median([d['wyerr'] for d in x])\\n wx600.append(wx)\\n wxerrs.append(wxerr)\\n wy600.append(wy)\\n wyerrs.append(wyerr)\\n fluxes600.append(np.median([d['peakvalue'] for d in x]))\\n fluxes600err.append(np.std([d['peakvalue'] for d in x]))\\n\\n wx600 = _FWHMGauss(np.asarray(wx600))\\n wy600 = _FWHMGauss(np.asarray(wy600))\\n fluxes600 = np.asarray(fluxes600)\\n fluxes600err = np.asarray(fluxes600err)\\n #averaged over many runs\\n wx600err = _FWHMGauss(np.asarray(wxerr))\\n wy600err = _FWHMGauss(np.asarray(wyerr))\\n w600 = np.sqrt(wx600*wy600)\\n w600err = np.sqrt(wx600err*wy600err)\\n print wx600\\n print wy600\\n print fluxes600\\n\\n #800nm\\n nom = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm?.pkl')]\\n nom5k = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm5k*.pkl')]\\n nom10k = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm10k*.pkl')]\\n nom20k = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm20k*.pkl')]\\n nom30k = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm30k*.pkl')]\\n nom38k = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm38k*.pkl')]\\n nom50k = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm50k*.pkl')]\\n nom54k = [fileIO.cPicleRead(file) for file in g.glob('results/I800nm54k*.pkl')]\\n\\n data = (nom5k, nom10k, nom20k, nom30k, nom38k, nom50k, nom54k, nom)\\n fluxes800 = []\\n fluxes800err = []\\n wx800 = []\\n wxerrs = []\\n wy800 = []\\n wyerrs = []\\n for x in data:\\n wx = np.max([d['wx'] for d in x])\\n wxerr = np.max([d['wxerr'] for d in x])\\n wy = np.max([d['wy'] for d in x])\\n wyerr = np.max([d['wyerr'] for d in x])\\n wx800.append(wx)\\n wxerrs.append(wxerr)\\n wy800.append(wy)\\n wyerrs.append(wyerr)\\n fluxes800.append(np.median([d['peakvalue'] for d in x]))\\n fluxes800err.append(np.std([d['peakvalue'] for d in x]))\\n\\n wx800 = _FWHMGauss(np.asarray(wx800))\\n wy800 = _FWHMGauss(np.asarray(wy800))\\n fluxes800 = np.asarray(fluxes800)\\n fluxes800err = np.asarray(fluxes800err)\\n #averaged over many runs\\n wx800err = _FWHMGauss(np.asarray(wxerr))\\n wy800err = _FWHMGauss(np.asarray(wyerr))\\n w800 = np.sqrt(wx800*wy800)\\n w800err = np.sqrt(wx800err*wy800err)\\n print wx800\\n print wy800\\n print fluxes800\\n\\n #plot FWHM\\n fig = plt.figure()\\n ax1 = fig.add_subplot(311)\\n ax2 = fig.add_subplot(312)\\n ax3 = fig.add_subplot(313)\\n fig.subplots_adjust(hspace=0, top=0.93, bottom=0.17, left=0.11, right=0.93)\\n ax1.set_title('CCD273 PSF Intensity Dependency')\\n\\n ax1.errorbar(fluxes600, wx600, yerr=sigma*wx600err, xerr=sigma*fluxes600err, fmt='o', label='600nm', c='g')\\n ax2.errorbar(fluxes600, wy600, yerr=sigma*wy600err, xerr=sigma*fluxes600err, fmt='o', label='600nm', c='g')\\n ax3.errorbar(fluxes600, w600, yerr=sigma*w600err, xerr=sigma*fluxes600err, fmt='o', label='600nm', c='g')\\n\\n ax1.errorbar(fluxes800, wx800, yerr=sigma*wx800err, xerr=sigma*fluxes800err, fmt='s', label='800nm', c='m')\\n ax2.errorbar(fluxes800, wy800, yerr=sigma*wy800err, xerr=sigma*fluxes800err, fmt='s', label='800nm', c='m')\\n ax3.errorbar(fluxes800, w800, yerr=sigma*w800err, xerr=sigma*fluxes800err, fmt='s', label='800nm', c='m')\\n\\n #linear fits\\n z1 = np.polyfit(fluxes600, wx600, 1)\\n p1 = np.poly1d(z1)\\n z2 = np.polyfit(fluxes600, wy600, 1)\\n p2 = np.poly1d(z2)\\n z3 = np.polyfit(fluxes600, w600, 1)\\n p3 = np.poly1d(z3)\\n x = np.linspace(0., fluxes600.max()*1.05, 100)\\n #ax1.plot(x, p1(x), 'g-')\\n #ax2.plot(x, p2(x), 'g-')\\n #ax3.plot(x, p3(x), 'g-')\\n print '600nm fits:'\\n print p1\\n print p2\\n print p3\\n\\n # Bayesian\\n p600x, params600x, errors600x, outliers600x = linearFitWithOutliers(fluxes600, wx600, wx600err,\\n outtriangle='BF600FWHMx.png')\\n p600y, params600y, errors600y, outliers600y = linearFitWithOutliers(fluxes600, wy600, wy600err,\\n outtriangle='BF600FWHMy.png')\\n p600, params600, errors600, outliers600 = linearFitWithOutliers(fluxes600, w600, w600err,\\n outtriangle='BF600FWHM.png')\\n print params600x[::-1], errors600x[::-1]\\n print params600y[::-1], errors600y[::-1]\\n print params600[::-1], errors600[::-1]\\n\\n ax1.plot(x, params600x[0] + params600x[1]*x, 'g-')\\n #ax1.plot(fluxes600[outliers600x], wx600[outliers600x], 'ro', ms=20, mfc='none', mec='red')\\n ax2.plot(x, params600y[0] + params600y[1]*x, 'g-')\\n #ax2.plot(fluxes600[outliers600y], wy600[outliers600y], 'ro', ms=20, mfc='none', mec='red')\\n ax3.plot(x, params600[0] + params600[1]*x, 'g-')\\n #ax3.plot(fluxes600[outliers600], w600[outliers600], 'ro', ms=20, mfc='none', mec='red')\\n\\n z1 = np.polyfit(fluxes800, wx800, 1)\\n p1 = np.poly1d(z1)\\n z2 = np.polyfit(fluxes800, wy800, 1)\\n p2 = np.poly1d(z2)\\n z3 = np.polyfit(fluxes800, w800, 1)\\n p3 = np.poly1d(z3)\\n x = np.linspace(0., fluxes800.max()*1.05, 100)\\n #ax1.plot(x, p1(x), 'm-')\\n #ax2.plot(x, p2(x), 'm-')\\n #ax3.plot(x, p3(x), 'm-')\\n print '800nm fits:'\\n print p1\\n print p2\\n print p3\\n\\n # Bayesian\\n p800x, params800x, errors800x, outliers800x = linearFitWithOutliers(fluxes800, wx800, wx800err,\\n outtriangle='BF800FWHMx.png')\\n p800y, params800y, errors800y, outliers800y = linearFitWithOutliers(fluxes800, wy800, wy800err,\\n outtriangle='BF800FWHMy.png')\\n p800, params800, errors800, outliers800 = linearFitWithOutliers(fluxes800, w800, w800err,\\n outtriangle='BF800FWHM.png')\\n print params800x[::-1], errors800x[::-1]\\n print params800y[::-1], errors800y[::-1]\\n print params800[::-1], errors800[::-1]\\n\\n ax1.plot(x, params800x[0] + params800x[1]*x, 'm-')\\n #ax1.plot(fluxes800[outliers800x], wx800[outliers800x], 'ro', ms=20, mfc='none', mec='red')\\n ax2.plot(x, params800y[0] + params800y[1]*x, 'm-')\\n #ax2.plot(fluxes800[outliers800y], wy800[outliers800y], 'ro', ms=20, mfc='none', mec='red')\\n ax3.plot(x, params800[0] + params800[1]*x, 'm-')\\n #ax3.plot(fluxes800[outliers800], w800[outliers800], 'ro', ms=20, mfc='none', mec='red')\\n\\n #requirements\\n #ax1.axhline(y=requirementFWHM, label='Requirement (800nm)', c='r', ls='--')\\n #ax2.axhline(y=requirementFWHM, label='Requirement (800nm)', c='r', ls='--')\\n #ax3.axhline(y=requirementFWHM, label='Requirement (800nm)', c='r', ls='-')\\n\\n plt.sca(ax1)\\n plt.xticks(visible=False)\\n plt.sca(ax2)\\n plt.xticks(visible=False)\\n plt.sca(ax3)\\n\\n ax1.set_ylim(4.3, 10.8)\\n ax2.set_ylim(4.3, 10.8)\\n ax3.set_ylim(4.3, 10.8)\\n ax1.set_xlim(0., fluxes800.max()*1.05)\\n ax2.set_xlim(0., fluxes800.max()*1.05)\\n ax3.set_xlim(0., fluxes800.max()*1.05)\\n\\n ax3.set_ylabel(r'FWHM $\\\\, [\\\\mu$m$]$')\\n ax1.set_ylabel(r'FWHM$_{X} \\\\, [\\\\mu$m$]$')\\n ax2.set_ylabel(r'FWHM$_{Y} \\\\, [\\\\mu$m$]$')\\n ax3.set_xlabel(r'Intensity $\\\\quad [e^{-}]$')\\n ax1.legend(shadow=True, fancybox=True, numpoints=1, loc='lower right')\\n ax2.legend(shadow=True, fancybox=True, numpoints=1, loc='lower right')\\n ax3.legend(shadow=True, fancybox=True, numpoints=1, loc='lower right')\\n plt.savefig(out)\\n plt.close()\\n\\n print 'R2:'\\n R2 = _R2FromGaussian(wx800pix, wy800pix)*1e3\\n errR2 = _R2err(wx800pix, wy800pix, wxerr, wyerr)*1e3\\n print R2\\n p, params, errors, outliers = linearFitWithOutliers(fluxes800, R2, errR2, outtriangle='BF800R2.png')\\n print params[::-1], errors[::-1]\\n\\n fig = plt.figure()\\n ax1 = fig.add_subplot(211)\\n ax2 = fig.add_subplot(212)\\n fig.subplots_adjust(hspace=0, top=0.93, bottom=0.17, left=0.11, right=0.93)\\n ax1.set_title('CCD273 PSF Intensity Dependency')\\n ax1.errorbar(fluxes800, R2, yerr=sigma*errR2, fmt='o', label='800nm', c='b')\\n ax1.plot(x, params[0] + params[1]*x, 'm-')\\n ax1.plot(fluxes800[outliers], R2[outliers], 'ro', ms=20, mfc='none', mec='red')\\n ax1.set_ylabel(r'$R^{2} \\\\, [$mas$^{2}]$')\\n\\n print 'Ellipticity'\\n ell = _ellipticityFromGaussian(wx800pix, wy800pix)\\n print ell\\n ellerr = _ellipticityerr(wx800pix, wy800pix, wxerr, wyerr)\\n p, params, errors, outliers = linearFitWithOutliers(fluxes800, ell, ellerr, outtriangle='BF800ell.png')\\n print params[::-1], errors[::-1]\\n\\n ax2.errorbar(fluxes800, ell, yerr=sigma*ellerr, fmt='s', label='800nm', c='m')\\n ax2.plot(x, params[0] + params[1]*x, 'm-')\\n ax2.plot(fluxes800[outliers], ell[outliers], 'ro', ms=20, mfc='none', mec='red')\\n ax2.axhline(y=0.156, label='Requirement', c='r')\\n ax1.axhline(y=2., label='Requirement', c='r')\\n ax1.set_xlim(0., fluxes800.max()*1.05)\\n ax2.set_xlim(0., fluxes800.max()*1.05)\\n ax1.set_ylim(0.8, 2.1)\\n ax2.set_ylim(-0.01, 0.165)\\n ax2.set_ylabel('Ellipticity')\\n ax2.set_xlabel(r'Intensity $\\\\quad [e^{-}]$')\\n ax1.legend(shadow=True, fancybox=True, numpoints=1, loc='lower right')\\n ax2.legend(shadow=True, fancybox=True, numpoints=1)\\n\\n plt.savefig('R2ellIntensity.pdf')\\n plt.close()\",\n \"def plot_phase(self,res):\\n x = np.linspace(0,1,res)\\n y = np.linspace(0,1,res)\\n X,Y = np.meshgrid(x,y)\\n plt.figure()\\n ax = plt.axes(projection = '3d')\\n ax.plot_surface(X,Y,np.angle(self.psi)[:,:,math.floor(res/2)])\\n plt.show()\",\n \"def get_iPTF14gqr(colorplt=False):\\n z = 0.063\\n # ebv = 0.082\\n D = cosmo.luminosity_distance([z])[0].value * 1e+6 # in pc\\n dis_mod = 5*np.log10(D / 10)\\n t_exp = 56943.74 # \\n t_max = 56950.26 # g band max light + 3\\n \\n tb = Table(fits.open('../data/otherSN/De2018/tables1.fit')[1].data)\\n tb.rename_column('MJD' , 'mjd')\\n tb['texp_rf'] = (tb['mjd'] - t_exp) / (1+z)\\n tb['tmax_rf'] = (tb['mjd'] - t_max) / (1+z)\\n # tb = tb[tb[\\\"Filt\\\"]==\\\"g \\\"]\\n tb = tb[~np.isnan(tb['e_mag'])]\\n tb.rename_column('Filt' , 'filter')\\n tb.rename_column('e_mag' , 'emag')\\n tb.rename_column('mag' , 'mag0')\\n \\n ixg = tb['filter']==\\\"g \\\"\\n ixB = tb['filter']==\\\"B \\\"\\n ixV = tb['filter']==\\\"V \\\"\\n ixr = tb['filter']==\\\"r \\\"\\n ixi = tb['filter']==\\\"i \\\"\\n ixUVW1 = tb['filter']==\\\"UVW1\\\"\\n ixUVW2 = tb['filter']==\\\"UVW2\\\"\\n \\n tb['wave'] = np.zeros(len(tb))\\n tb['wave'][ixUVW2] = 2079\\n tb['wave'][ixUVW1] = 2614\\n tb['wave'][ixB] = 4359\\n tb['wave'][ixg] = 4814\\n tb['wave'][ixV] = 5430\\n tb['wave'][ixr] = 6422\\n tb['wave'][ixi] = 7883\\n \\n tb['mag0_abs'] = tb['mag0'] - dis_mod\\n \\n tb = tb.to_pandas()\\n tb[\\\"texp_rf\\\"] = tb[\\\"Phase\\\"]\\n tb = tb.drop(columns=[\\\"recno\\\", \\\"Phase\\\", \\\"l_mag\\\"])\\n \\\"\\\"\\\"\\n ix = np.any([tb['Tel'].values==\\\"P60 \\\",\\n tb[\\\"filter\\\"].values=='g '], axis=0)\\n tb = tb[ix]\\n \\\"\\\"\\\"\\n tb = add_datecol(tb)\\n tb = add_physcol(tb)\\n tt = tb[\\\"tmax_rf\\\"].values\\n epochs = [\\\" \\\" for x in range(len(tt))]\\n epochs = np.array(epochs)\\n \\\"\\\"\\\"\\n ix = (tt>-5.6)&(tt<-5.55)\\n epochs[ix] = \\\"epoch 01\\\"\\n \\\"\\\"\\\"\\n ix = (tt>-5.55)&(tt<-5.50)\\n epochs[ix] = \\\"epoch 02\\\"\\n \\n ix = (tt>-5.50)&(tt<-5.45)\\n epochs[ix] = \\\"epoch 03\\\"\\n \\n ix = (tt>-5.2)&(tt<-5.0)\\n epochs[ix] = \\\"epoch 04\\\"\\n ix = (tt>-5.0)&(tt<-4.7)\\n epochs[ix] = \\\"epoch 05\\\"\\n \\n ix = (tt>-4.7)&(tt<-4.5)\\n epochs[ix] = \\\"epoch 06\\\"\\n ix = (tt>-4.5)&(tt<-3.5)\\n epochs[ix] = \\\"epoch 07\\\"\\n ix = (tt>-3.5)&(tt<-2.5)\\n epochs[ix] = \\\"epoch 08\\\"\\n ix = (tt>-1.5)&(tt<-1)\\n epochs[ix] = \\\"epoch 09\\\"\\n ix = (tt>-1)&(tt<-0.82)\\n epochs[ix] = \\\"epoch 10\\\"\\n ix = (tt>-0.82)&(tt<-0.6)\\n epochs[ix] = \\\"epoch 11\\\"\\n ix = (tt>-0.5)&(tt<0.5)\\n epochs[ix] = \\\"epoch 12\\\"\\n ix = (tt>0.5)&(tt<1.5)\\n epochs[ix] = \\\"epoch 13\\\"\\n ix = (tt>1.5)&(tt<2.5)\\n epochs[ix] = \\\"epoch 14\\\"\\n ix = (tt>3.5)&(tt<4.5)\\n epochs[ix] = \\\"epoch 15\\\"\\n ix = (tt>4.5)&(tt<5)\\n epochs[ix] = \\\"epoch 16\\\"\\n ix = (tt>5)&(tt<5.6)\\n epochs[ix] = \\\"epoch 17\\\"\\n ix = (tt>5.6)&(tt<5.8)\\n epochs[ix] = \\\"epoch 18\\\"\\n ix = (tt>6)&(tt<7)\\n epochs[ix] = \\\"epoch 19\\\"\\n ix = (tt>7)&(tt<8)\\n epochs[ix] = \\\"epoch 20\\\"\\n ix = (tt>8)&(tt<9)\\n epochs[ix] = \\\"epoch 21\\\"\\n tb[\\\"epoch\\\"] = epochs\\n\\n if colorplt==False:\\n return tb\\n else:\\n tb = add_datecol(tb)\\n ix = np.in1d(tb[\\\"filter\\\"].values, np.array(['g ', 'r ', 'i ']))\\n tb = tb[ix]\\n\\n dates = get_date_span(tb)\\n datesave = []\\n for i in range(len(dates)):\\n x = dates[i]\\n ix = tb[\\\"date\\\"].values == x\\n tbsub = tb[ix]\\n if len(tbsub)!=0:\\n flts = tbsub['filter'].values\\n if \\\"r \\\" in flts and np.sum(np.unique(flts))!=1:\\n datesave.append(x)\\n datesave = np.array(datesave)\\n \\n mcolor = []\\n mcolor_unc = []\\n mjds = []\\n colorname = []\\n for i in range(len(datesave)):\\n x = datesave[i]\\n ix = tb[\\\"date\\\"].values == x\\n tbsub = tb[ix]\\n gtb = tbsub[tbsub[\\\"filter\\\"].values==\\\"g \\\"]\\n rtb = tbsub[tbsub[\\\"filter\\\"].values==\\\"r \\\"]\\n itb = tbsub[tbsub[\\\"filter\\\"].values==\\\"i \\\"]\\n if len(gtb)!=0:\\n gmjds = gtb[\\\"mjd\\\"].values\\n gmags = gtb[\\\"mag0\\\"].values\\n gemags = gtb[\\\"emag\\\"].values\\n gwtgs = 1/gemags**2\\n gmag = np.sum(gmags * gwtgs) / np.sum(gwtgs)\\n gmjd = np.sum(gmjds * gwtgs) / np.sum(gwtgs)\\n gemag = 1/ np.sqrt(np.sum(gwtgs))\\n if len(rtb)!=0:\\n rmjds = rtb[\\\"mjd\\\"].values\\n rmags = rtb[\\\"mag0\\\"].values\\n remags = rtb[\\\"emag\\\"].values\\n rwtgs = 1/remags**2\\n rmag = np.sum(rmags * rwtgs) / np.sum(rwtgs)\\n rmjd = np.sum(rmjds * rwtgs) / np.sum(rwtgs)\\n remag = 1/ np.sqrt(np.sum(rwtgs))\\n if len(itb)!=0:\\n imjds = itb[\\\"mjd\\\"].values\\n imags = itb[\\\"mag0\\\"].values\\n iemags = itb[\\\"emag\\\"].values\\n iwtgs = 1/iemags**2\\n imag = np.sum(imags * iwtgs) / np.sum(iwtgs)\\n imjd = np.sum(imjds * iwtgs) / np.sum(iwtgs)\\n iemag = 1/ np.sqrt(np.sum(iwtgs))\\n if len(gtb)!=0 and len(rtb)!=0:\\n mcolor.append(gmag - rmag)\\n mjds.append( 0.5 * (gmjd + rmjd) )\\n mcolor_unc.append( np.sqrt(gemag**2 + remag**2) )\\n colorname.append(\\\"gmr\\\")\\n if len(rtb)!=0 and len(itb)!=0:\\n mcolor.append(rmag - imag)\\n mjds.append( 0.5 * (rmjd + imjd) )\\n mcolor_unc.append( np.sqrt(remag**2 + iemag**2) )\\n colorname.append(\\\"rmi\\\")\\n \\n ctb = Table(data = [mjds, mcolor, mcolor_unc, colorname],\\n names = [\\\"mjd\\\", \\\"c\\\", \\\"ec\\\", \\\"cname\\\"])\\n \\n ctb['tmax_rf'] = (ctb['mjd'] - t_max) / (1+z)\\n ctb = ctb.to_pandas()\\n return ctb\",\n \"def plot_stream(x,y,gvx,gvy,oargs,outfile):\\r\\n\\t\\r\\n\\tme = \\\"LE_Plot.plot_stream: \\\"\\r\\n\\t\\r\\n\\t## Expand out parameters\\r\\n\\tb,X,xmax,ymax,BW,smooth = oargs\\r\\n\\tgv = np.sqrt(gvx*gvx+gvy*gvy)\\r\\n\\t\\t\\r\\n\\tshowplot = False\\r\\n\\r\\n\\t## Smooth data\\r\\n\\tif smooth is not 0.0:\\r\\n\\t\\tgvy = gaussian_filter(gvy, smooth)\\r\\n\\t\\tgvx = gaussian_filter(gvx, smooth)\\r\\n\\t\\tgv = gaussian_filter(gv, smooth)\\r\\n\\toutfile += \\\"_sm\\\"+str(smooth)\\r\\n\\t\\t\\r\\n\\t## --------------------------------------------------------------------\\t\\r\\n\\t\\r\\n\\t## Plotting\\r\\n\\t\\r\\n\\tt0 = time.time()\\r\\n\\tfs = 25\\r\\n\\t\\r\\n\\tfig = plt.figure(facecolor=\\\"white\\\")\\r\\n\\tfig.suptitle(outfile)\\r\\n\\t\\r\\n\\t## Add subplot with exact solution\\r\\n\\tif not BW:\\r\\n\\t\\tfrom LE_ExactHO import main as plot_exact\\r\\n\\t\\tax1 = fig.add_subplot(121,aspect=\\\"auto\\\")\\r\\n\\t\\tax2 = fig.add_subplot(122,aspect=\\\"auto\\\",sharey=ax1)\\r\\n\\t\\tplot_exact((ax2,xmax,ymax,b,False))\\r\\n\\t\\tfig.tight_layout();fig.subplots_adjust(top=0.93)\\r\\n\\t\\tprint me+\\\"Plotting exact\\\",round(time.time()-t0,1),\\\"seconds\\\"\\r\\n\\telse:\\r\\n\\t\\tax1 = fig.add_subplot(111)\\r\\n\\t\\r\\n\\t## Accoutrements\\t\\r\\n\\tax1.set_xlim([-xmax,xmax]);\\tax1.set_ylim([-ymax,ymax])\\r\\n\\tax1.set_xlabel(\\\"$x$\\\",fontsize=fs);ax1.set_ylabel(\\\"$\\\\eta$\\\",fontsize=fs)\\r\\n\\t## Plot wall positions if BW; plot separatrix if HO\\r\\n\\tif BW:\\tplot_walls(ax1, X, xmax,ymax,2)\\r\\n\\telse:\\tplot_separatrix(ax1, b, xmax, ymax, 2)\\r\\n\\t\\r\\n\\t## Line widths\\r\\n\\tlw1 = 3.0*gv/gv.max()\\r\\n\\t\\r\\n\\tt0=time.time()\\r\\n\\t## Plot absolute speed contour and streamplot\\r\\n\\t## NOTE fudge (-) to force agreement with exact\\r\\n\\t# ax1.contourf(xi,yi,gv, 4, alpha=0.4)\\r\\n\\tax1.streamplot(-x,y, -gvx,gvy, arrowsize=1.8, arrowstyle=\\\"->\\\", linewidth=lw1, minlength=xmax/20)\\r\\n\\t\\t\\t\\r\\n\\tprint me+\\\"Plotting data \\\",round(time.time()-t0,1),\\\"seconds\\\"; t0=time.time()\\r\\n\\t\\t\\r\\n\\t## Output\\r\\n\\tfig.savefig(outfile+\\\".png\\\",facecolor=fig.get_facecolor(), edgecolor=\\\"none\\\")\\r\\n\\tprint me+\\\"Plot saved\\\",outfile+\\\".png\\\"\\r\\n\\tif showplot:\\tplt.show()\\r\\n\\r\\n\\tplt.close()\\r\\n\\t\\t\\t\\r\\n\\treturn\",\n \"def plot_pretty():\\n\\n ts, ys, lin_model, K, us, dt_control, biass, end_time = simulate()\\n plt.style.use('seaborn-deep')\\n\\n black = '#2B2B2D'\\n red = '#E90039'\\n orange = '#FF1800'\\n white = '#FFFFFF'\\n yellow = '#FF9900'\\n\\n plt.figure(figsize=(12.8, 9.6))\\n plt.rcParams.update({'font.size': 16, 'text.color': white, 'axes.labelcolor': white,\\n 'axes.edgecolor': white, 'xtick.color': white, 'ytick.color': white})\\n\\n plt.gcf().set_facecolor(black)\\n\\n plt.subplot(2, 3, 1)\\n plt.plot(ts, ys[:, 2], color=orange)\\n plt.axhline(lin_model.yd2n(K.ysp)[1], color=white)\\n plt.title(r'$C_{FA}$')\\n plt.xlim([0, ts[-1]])\\n plt.gca().set_facecolor(black)\\n\\n plt.subplot(2, 3, 2)\\n plt.plot(ts, ys[:, 0], color=orange)\\n plt.axhline(lin_model.yd2n(K.ysp)[0], color=white)\\n plt.title(r'$C_{G}$')\\n plt.xlim([0, ts[-1]])\\n plt.gca().set_facecolor(black)\\n\\n plt.subplot(2, 3, 3)\\n plt.plot(ts, ys[:, 3], color=orange)\\n plt.title(r'$C_{E}$')\\n plt.xlim([0, ts[-1]])\\n plt.gca().set_facecolor(black)\\n\\n plt.subplot(2, 3, 4)\\n plt.plot(ts, us[:, lin_model.inputs[1]], color=red)\\n plt.title(r'$F_{m, in}$')\\n plt.xlim([0, ts[-1]])\\n plt.gca().set_facecolor(black)\\n\\n plt.subplot(2, 3, 5)\\n plt.plot(ts, us[:, lin_model.inputs[0]], color=red)\\n plt.title(r'$F_{G, in}$')\\n plt.xlim([0, ts[-1]])\\n plt.gca().set_facecolor(black)\\n\\n plt.subplot(2, 3, 6)\\n plt.plot(\\n numpy.arange(dt_control, end_time, dt_control),\\n biass[:, 1],\\n color=red\\n )\\n plt.plot(\\n numpy.arange(dt_control, end_time, dt_control),\\n biass[:, 0],\\n color=yellow\\n )\\n plt.legend([r'$C_{FA}$', r'$C_G$'], facecolor=black)\\n plt.title('bias')\\n plt.xlim([0, ts[-1]])\\n plt.gca().set_facecolor(black)\\n\\n # plt.suptitle('Closedloop bioreactor without noise')\\n plt.tight_layout(rect=[0, 0.03, 1, 0.95])\\n plt.savefig('no_noise_pretty.png', transparent=True)\\n plt.show()\",\n \"def traces(mndata,Params,srate,imagepath):\\n\\t#plot high gamma traces\\n\\t#data should be bandpassed (todo)\\n\\t#resample to srate\\n\\tst = resample(Params[\\\"st\\\"],srate)\\n\\ten = resample(Params[\\\"en\\\"],srate)\\n\\tbl_en = resample(Params[\\\"bl_en\\\"],srate)\\n\\tbl_st = resample(Params[\\\"bl_st\\\"],srate)\\n\\tplot_tp = resample(Params[\\\"plot\\\"],srate)\\n\\tcue = resample(500,srate)\\n\\t\\n\\tcolors = ['red','orange','green','blue']\\n\\tx = np.array(range(st,en+1))\\n\\tf, (ax,ax2) = plt.subplots(1,2, sharex = False)\\n\\tax.axhline(y = 0,color = 'k',linewidth=2)\\n\\tax.axvline(x = 0,color='k',linewidth=2)\\n\\tax.axvline(x = cue,color = 'gray',linewidth = 2)\\n\\tax.axvline(x = cue+cue,color = 'gray',linewidth = 2)\\n\\tax.axvspan(cue, cue+cue, facecolor='0.5', alpha=0.25,label = 'cue')\\n\\n\\tfor j in range(len(Params[\\\"conditions\\\"])):\\n\\t\\tcondition = Params['conditions'][j]\\n\\t\\ty = mndata[condition]['data']\\n\\t\\tax.plot(x,y, label = condition,linewidth = 2,color = colors[j])\\n\\t\\n\\tax.set_ylim((-30,85))\\n\\tax.set_xlim(st,en)\\n\\tax.legend()\\n\\tax.xaxis.set_ticklabels(['', '0', '','500', '', '1000', '', '1500', '', '2000','','2500','', '3000'],minor=False)\\n\\tax.xaxis.set_ticks(range(st,en,plot_tp))\\n\\n\\tax.set_xlabel(\\\"time (ms)\\\")\\n\\tax.set_ylabel(\\\"% change baseline\\\")\\n\\tax.set_title('Analytic Amplitude - High Gamma (70-150Hz)', fontsize = 18)\\n\\n\\t#plot brain with elec location\\n\\t#brain = plt.imread(imagepath)\\n\\t#aa = pylab.mean(brain,2)\\n\\t#ax2.imshow(aa)\\n\\t#a2.gray()\\n\\n\\t#brain = Image.open(imagepath)\\n\\t#ax2.set_axis_off()\\n\\t#im = plt.imshow(brain, origin = 'lower')\\n\\n\\t#brain = _png.read_png(imagepath)\\n\\t#imagebox = OffsetImage(brain,zoom =5)\\n\\t#ab = AnnotationBbox(imagebox,)\\n\\n\\tim = Image.open(imagepath)\\n\\tax2.imshow(im,aspect = 'auto',origin = 'lower')\\n\\tax2.set_xlim((0,750))\\n\\tax2.set_title('Electrode Location',fontsize = 18)\\n\\n\\n\\n\\treturn f, (ax, ax2)\",\n \"def plot(self):\\n # -- plotting\\n fig = plt.figure(figsize=figsize)\\n ax = fig.add_axes([0.08, 0.12, 0.55, 0.85])\\n ax.plot(self.raw['stress'][1:], self.raw['e'][1:], ls=(0, (1, 1)),\\n marker='o', lw=1.5, c='k', mfc='w', label='Experimental data')\\n ax.plot(self.sigmaV, self.eSigmaV, ls='', marker='|', c='r', ms=15,\\n mfc='w', mew=1.5,\\n label=str().join([r'$\\\\sigma^\\\\prime_\\\\mathrm{v_0}=$ ',\\n f'{self.sigmaV:.0f} kPa']))\\n # Compression index\\n x4Cc = np.linspace(\\n self.cleaned['stress'].iloc[-4], self.cleaned['stress'].iloc[-1])\\n y4Cc = -self.idxCc * np.log10(x4Cc) + self.idxCcInt\\n ax.plot(x4Cc, y4Cc, ls='-', lw=1.125, color=colors[1],\\n label=str().join([r'$C_\\\\mathrm{c}=$', f'{self.idxCc:.3f}']))\\n if self.fitCc:\\n ax.plot(self.cleaned['stress'].iloc[self.maskCc],\\n self.cleaned['e'].iloc[self.maskCc], ls='', marker='x',\\n color=colors[1],\\n label=f'Data for linear fit\\\\n(R$^2={self.r2Cc:.3f}$)')\\n # Recompression index\\n x4Cr = np.linspace(self.raw['stress'].iloc[self.maskCr].min(),\\n self.raw['stress'].iloc[self.maskCr].max())\\n y4Cr = -self.idxCr * np.log10(x4Cr) + self.idxCrInt\\n ax.plot(x4Cr, y4Cr, ls='-', lw=1.125, color=colors[2],\\n label=str().join([r'$C_\\\\mathrm{r}=$', f'{self.idxCr:.3f}']))\\n ax.plot(self.raw['stress'].iloc[self.maskCr],\\n self.raw['e'].iloc[self.maskCr], ls='', marker='+',\\n color=colors[2],\\n label=f'Data for linear fit\\\\n(R$^2={self.r2Cr:.3f}$)')\\n # other details\\n ax.spines['top'].set_visible(False)\\n ax.spines['right'].set_visible(False)\\n ax.set(xscale='log', ylabel='Void ratio, $e$',\\n xlabel=str().join(['Effective vertical stress, ',\\n r'$\\\\sigma^\\\\prime_\\\\mathrm{v}$ [kPa]']))\\n ax.xaxis.set_major_formatter(mtick.ScalarFormatter())\\n ax.yaxis.set_minor_locator(mtick.AutoMinorLocator())\\n ax.grid(False)\\n ax.legend(bbox_to_anchor=(1.125, 0.5), loc=6,\\n title=r\\\"\\\\textbf{Compressibility curve}\\\")\\n return fig\",\n \"def ShowOneContour(index,all_images,all_pointing,thex0,they0,all_titles,object_name,all_expo,dir_top_img,all_filt,figname):\\n plt.figure(figsize=(15,6))\\n spec_index_min=100 # cut the left border\\n spec_index_max=1900 # cut the right border\\n star_halfwidth=70\\n \\n YMIN=-15\\n YMAX=15\\n \\n figfilename=os.path.join(dir_top_img,figname) \\n \\n #center is approximately the one on the original raw image (may be changed)\\n #x0=int(all_pointing[index][0])\\n x0=int(thex0[index])\\n \\n \\n # Extract the image \\n full_image=np.copy(all_images[index])\\n \\n # refine center in X,Y\\n star_region_X=full_image[:,x0-star_halfwidth:x0+star_halfwidth]\\n \\n profile_X=np.sum(star_region_X,axis=0)\\n profile_Y=np.sum(star_region_X,axis=1)\\n\\n NX=profile_X.shape[0]\\n NY=profile_Y.shape[0]\\n \\n X_=np.arange(NX)\\n Y_=np.arange(NY)\\n \\n avX,sigX=weighted_avg_and_std(X_,profile_X**4) # take squared on purpose (weigh must be >0)\\n avY,sigY=weighted_avg_and_std(Y_,profile_Y**4)\\n \\n x0=int(avX+x0-star_halfwidth)\\n \\n \\n # find the center in Y on the spectrum\\n yprofile=np.sum(full_image[:,spec_index_min:spec_index_max],axis=1)\\n y0=np.where(yprofile==yprofile.max())[0][0]\\n\\n # cut the image in vertical and normalise by exposition time\\n reduc_image=full_image[y0-20:y0+20,x0:spec_index_max]/all_expo[index] \\n reduc_image[:,0:100]=0 # erase central star\\n \\n X_Size_Pixels=np.arange(0,reduc_image.shape[1])\\n Y_Size_Pixels=np.arange(0,reduc_image.shape[0])\\n Transverse_Pixel_Size=Y_Size_Pixels-int(float(Y_Size_Pixels.shape[0])/2.)\\n \\n # calibration in wavelength\\n #grating_name=all_filt[index].replace('dia ','')\\n grating_name=get_disperser_filtname(all_filt[index])\\n \\n lambdas=Pixel_To_Lambdas(grating_name,X_Size_Pixels,all_pointing[index],True)\\n \\n #if grating_name=='Ron200':\\n # holo = Hologram('Ron400',verbose=True)\\n #else: \\n # holo = Hologram(grating_name,verbose=True)\\n #lambdas=holo.grating_pixel_to_lambda(X_Size_Pixels,all_pointing[index])\\n #if grating_name=='Ron200':\\n # lambdas=lambdas*2.\\n \\n\\n X,Y=np.meshgrid(lambdas,Transverse_Pixel_Size) \\n T=np.transpose(reduc_image)\\n \\n \\n plt.contourf(X, Y, reduc_image, 100, alpha=1., cmap='jet',origin='lower')\\n C = plt.contour(X, Y, reduc_image , 20, colors='black', linewidth=.5,origin='lower')\\n \\n \\n for line in LINES:\\n if line == O2 or line == HALPHA or line == HBETA or line == HGAMMA:\\n plt.plot([line['lambda'],line['lambda']],[YMIN,YMAX],'-',color='lime',lw=0.5)\\n plt.text(line['lambda'],YMAX-3,line['label'],verticalalignment='bottom', horizontalalignment='center',color='lime', fontweight='bold',fontsize=16)\\n \\n \\n \\n plt.axis([X.min(), X.max(), Y.min(), Y.max()]); plt.grid(True)\\n plt.title(all_titles[index])\\n plt.grid(color='white', ls='solid')\\n plt.text(200,-5.,all_filt[index],verticalalignment='bottom', horizontalalignment='center',color='yellow', fontweight='bold',fontsize=16)\\n plt.xlabel('$\\\\lambda$ (nm)')\\n plt.ylabel('pixels')\\n plt.ylim(YMIN,YMAX)\\n plt.xlim(0.,1200.)\\n plt.savefig(figfilename)\",\n \"def plot(model, center, extent, outname):\\n # define model grid\\n xg = np.linspace(-extent, extent, model.shape[0])\\n yg = xg.copy()\\n interp_func = RectBivariateSpline(xg, yg, model)\\n\\n x = np.array([-2, -1, 0, 1, 2]) + center[0]\\n y = np.array([-2, -1, 0, 1, 2]) + center[1]\\n psf = interp_func(x, y)\\n\\n x, y = np.meshgrid(x, y)\\n f = pl.figure(figsize=(10, 5))\\n\\n pl.gray()\\n ax1 = pl.subplot(121)\\n ax1.imshow(model, interpolation='nearest', origin='lower',\\n extent=(-extent, extent, -extent, extent),\\n norm=LogNorm(vmin=model.min(), vmax=model.max()))\\n ax1.plot(x, y, 's', mec='r', mfc='none', mew=2)\\n\\n pl.xlim(-2.5, 2.5)\\n pl.ylim(-2.5, 2.5)\\n ax2 = pl.subplot(122)\\n ax2.imshow(psf, interpolation='nearest', origin='lower',\\n extent=(-extent, extent, -extent, extent),\\n norm=LogNorm(vmin=model.min(), vmax=model.max()))\\n\\n ax2.set_xticks([-2, -1, 0, 1, 2])\\n ax2.set_yticks([-2, -1, 0, 1, 2])\\n ax2.set_xticklabels(['%0.3f' % v for v in x[0]])\\n ax2.set_yticklabels(['%0.3f' % v for v in y[:, 0]])\\n\\n coordsA, coordsB = \\\"data\\\", \\\"data\\\"\\n pixels = np.array([[0.0, 0.0], [2., 2.], [-1., -1.]])\\n locs = np.array([[-0.5, 0.5], [-0.5, 0.5], [-0.5, -0.5]])\\n rads = [0.15, 0.25, -0.25]\\n for i, p in enumerate(pixels):\\n xy1 = p + center\\n xy2 = p + locs[i]\\n con = ConnectionPatch(xyA=xy2, xyB=xy1, coordsA=coordsA,\\n coordsB=coordsB, axesA=ax2, axesB=ax1,\\n arrowstyle=\\\"<-, head_length=1.2, head_width=0.8\\\", \\n shrinkB=5,\\n connectionstyle='arc3, rad=%s' % rads[i],\\n color='r', lw=2)\\n ax2.add_artist(con)\\n ax2.plot(p[0], p[1], 's', mfc='none', mec='r', mew=2, ms=50)\\n\\n #pl.xlim(-2.5, 2.5)\\n #pl.ylim(-2.5, 2.5)\\n f.savefig(outname)\",\n \"def eos_plot(mat, name, ax,spec='t', vmin=None, vmax=None,\\n linthreshx=3e-5, linthreshy=0.1, nx=300, ny=350, xmax=None, ymax=None):\\n\\n DT_tables = [el for el in mat.tables if el.endswith('{s}_DT'.format(s=spec))]\\n\\n Rmax = np.min([mat.get_table(el)['Rmax'] for el in DT_tables])\\n Rmin = np.max([mat.get_table(el)['Rmin'] for el in DT_tables])\\n\\n Tmax = np.min([mat.get_table(el)['Tmax'] for el in DT_tables])\\n Tmin = np.max([mat.get_table(el)['Tmin'] for el in DT_tables])\\n\\n if Rmin == 0:\\n Xarr = np.logspace(-5, np.log10(Rmax)-0.1, nx)\\n Xarr[0] = 0\\n else:\\n Xarr = np.logspace(np.log10(Rmin), np.log10(Rmax)-0.1, nx)\\n if Tmin == 0:\\n Yarr = np.logspace(1, np.log10(Tmax)-0.1, ny)\\n #Yarr[0] = 0\\n else:\\n Yarr = np.logspace(np.log10(Tmin)+0.1, np.log10(Tmax)-0.1, ny)\\n print Yarr.min()\\n\\n X, Y = np.meshgrid(Xarr, Yarr, indexing='ij')\\n\\n if name in mat.tables:\\n print 'ok'\\n tab = mat.get_table(name, spec)\\n F = tab(X,Y)\\n if vmax is None:\\n vmax = np.percentile(F, 99.5) \\n if vmin is None:\\n vmin = np.percentile(F[F>0], 0.5)\\n\\n cs = ax.pcolormesh(X, Y*K2eV, F, cmap=plt.cm.jet, norm = LogNorm(),\\n vmin=vmin, vmax=vmax)\\n levels = np.arange(np.log10(F[F>0].min()), int(np.log10(F.max())))\\n logF = np.log10(np.where(F>0, F, F[F>0].min()))\\n cl = ax.contour(X, Y/11640, logF, levels, colors='k')\\n plt.clabel(cl, fontsize=10, inline=False, fmt='%1.0d', use_clabeltext=True)\\n plt.title('Table {0}: {1}'.format(tab['Material_ID'], name.replace('_', '\\\\_')))\\n cb = plt.colorbar(cs)\\n if F.min()<0:\\n min_label = ' (min {0:.0e} GPa)'.format(F.min())\\n else:\\n min_label = ''\\n cb.set_label('{0} [{1}] {2}'.format(tab.label.replace('_', '\\\\_'),\\n tab.units, min_label))\\n contour_at_1 = False\\n else:\\n F = mat.derived_quantity[name, spec](X,Y)\\n if vmax is None:\\n vmax = np.percentile(F, 99) \\n cs = ax.pcolormesh(X, Y*K2eV, F, vmin=0, vmax=vmax, cmap=plt.cm.jet)\\n plt.title(ur'Table {0}: total: {1}'.format(\\n mat.get_table(DT_tables[0], spec)['Material_ID'],\\n derived_quantities[name]['description'].decode('utf8').replace('\\\\n','')))\\n plt.colorbar(cs)\\n if name in ['gamma_3']:\\n cl = ax.contour(X, Y/11640, F, [1, 2,3], colors='k')\\n contour_at_1 = True\\n if name in ['G3', 'gamma_3']:\\n contour_at_1 = False\\n if contour_at_1:\\n cl = ax.contour(X, Y*K2eV, F, [1], colors='white', linestyles='solid')\\n\\n\\n cl = ax.contourf(X, Y*K2eV, F>0, [0,0.5], colors='white', hatches=['//'])\\n\\n ax.set_xscale('symlog', linthreshx=3e-5)\\n ax.set_yscale('symlog', linthreshy=0.1)\\n if xmax is None:\\n ax.set_xlim(0, Xarr.max())\\n else:\\n ax.set_xlim(0, xmax)\\n if ymax is None:\\n ax.set_ylim(0, Yarr.max()*K2eV)\\n else:\\n ax.set_ylim(0, ymax)\\n\\n ax.set_xlabel(r'$\\\\rho$ [g.cm$^{-3}$]')\\n ax.set_ylabel(r'$T$ [eV]')\\n return ax\",\n \"def plot_slice(self,res):\\n x = np.linspace(0,1,res)\\n y = np.linspace(0,1,res)\\n X,Y = np.meshgrid(x,y)\\n plt.figure()\\n ax = plt.axes(projection = '3d')\\n ax.plot_surface(X,Y,abs(self.psi)[:,:,math.floor(res/2)])\\n plt.show()\",\n \"def hexapodZernikeTrend(mnts='M20'):\\n Tfile='/home/jghao/research/decamFocus/psf_withseeing/finerGrid_coeff_matrix/zernike_coeff_finerGrid_training.cp'\\n b=p.load(open(Tfile))\\n nobs = len(b)\\n x = b[:,0]\\n y = b[:,1]\\n z = b[:,2]\\n theta = b[:,3]\\n phi = b[:,4]\\n fwhm = b[:,5]\\n e1 = b[:,6]\\n e2 = b[:,7]\\n thetax = theta*np.cos(np.deg2rad(phi))\\n thetay = theta*np.sin(np.deg2rad(phi))\\n if mnts == 'M20':\\n idxBase = 9\\n if mnts == 'M22real':\\n idxBase = 29\\n if mnts == 'M22imag':\\n idxBase = 49\\n idx = np.arange(14)\\n zernikeName=('Piston','Tip','Tilt','Astignism','Defocus','Astignism','Trefoil','Coma','Coma','Trefoil','Ashtray','Astigm.5th','Spherical','Astigm.5th','Ashtray','16','17','18','19','20')\\n for i in range(14):\\n pl.figure(figsize=(21,10))\\n pl.subplot(2,3,1)\\n bp.bin_scatter(b[:,idxBase+idx[i]],x,nbins=20,fmt='bo',scatter=True)\\n pl.ylabel('x-decenter')\\n pl.xlabel(zernikeName[i+1])\\n pl.ylim(-0.1,0.1)\\n pl.title(mnts)\\n pl.subplot(2,3,2)\\n bp.bin_scatter(b[:,idxBase+idx[i]],y,nbins=20,fmt='bo',scatter=True)\\n pl.ylabel('y-decenter')\\n pl.xlabel(zernikeName[i+1])\\n pl.title(mnts)\\n pl.ylim(-0.1,0.1)\\n pl.subplot(2,3,3)\\n bp.bin_scatter(b[:,idxBase+idx[i]],z,nbins=20,fmt='bo',scatter=True)\\n pl.ylabel('z-defocus')\\n pl.xlabel(zernikeName[i+1])\\n pl.title(mnts)\\n pl.ylim(-0.1,0.1)\\n pl.subplot(2,3,4)\\n bp.bin_scatter(b[:,idxBase+idx[i]],thetax,nbins=20,fmt='bo',scatter=True)\\n pl.ylabel('x-tilt')\\n pl.xlabel(zernikeName[i+1])\\n pl.title(mnts)\\n pl.ylim(-40,40)\\n pl.subplot(2,3,5)\\n bp.bin_scatter(b[:,idxBase+idx[i]],thetay,nbins=20,fmt='bo',scatter=True)\\n pl.ylabel('y-tilt')\\n pl.xlabel(zernikeName[i+1])\\n pl.title(mnts)\\n pl.ylim(-40,40)\\n pl.savefig(zernikeName[i+1]+mnts+'_'+str(i+1)+'.png')\\n pl.close()\",\n \"def plot_examples(cms):\\r\\n data = amp_axis\\r\\n\\r\\n fig, axs = plt.subplots(1, 2, figsize=(30, 8)) #create two plots\\r\\n for [ax, cmap] in zip(axs, cms):\\r\\n psm = ax.pcolormesh(time_axis, tof_axis, data, cmap=cmap, rasterized=True, vmin = 250) #specify axis and minimum amplitude value to show on the graph\\r\\n fig.colorbar(psm, ax=ax, label = 'Amplitude') #define the legend of the amplitude data\\r\\n \\r\\n ax.set_ylabel('Time of Flight [\\\\u03bcs]') #set label for y axis\\r\\n ax.set_xlabel('Time [min]') #set label for x axis\\r\\n \\r\\n ax.hlines(8.744, 0, stop_time, colors = 'white') #create two white lines for the safe operating range for ToF\\r\\n ax.hlines(9.555, 0, stop_time, colors = 'white') \\r\\n \\r\\n plt.show()\",\n \"def plot_two_filt(self, ax, x_filts, alphas, tits):\\n if self.filt_type == 'Tikhonov' or self.filt_type == 'GMRF' \\\\\\n or self.filt_type == 'IGMRF':\\n st1 = tits[0] + r', $\\\\alpha = %.2E$'\\n st2 = tits[1] + r', $\\\\alpha = %.2E$'\\n elif self.filt_type == 'TSVD':\\n st1 = tits[0] + r', $\\\\alpha = %.f$'\\n st2 = tits[1] + r', $\\\\alpha = %.f$'\\n \\n t = self.t\\n x_true = self.x_true\\n\\n ax.plot(t, x_true, 'k-', label='true', lw=1.5)\\n ax.plot(t, x_filts[0], 'r-', label=st1 % alphas[0], lw=1.5)\\n ax.plot(t, x_filts[1], 'g-', label=st2 % alphas[1], lw=1.5)\\n ax.set_title(r'Filtered Solutions')\\n ax.set_xlabel(r'$t$')\\n ax.set_ylabel(r'$x$')\\n leg = ax.legend(loc='upper left')\\n leg.get_frame().set_alpha(0.5)\\n ax.grid()\",\n \"def __init__(self):\\n Page.__init__(self, u\\\"Esfera, parametrización por proyecciones estereográficas\\\")\\n\\n r = .998\\n esf = ParametricPlot3D(lambda t, f: (r * sin(t) * cos(f), r * sin(t) * sin(f), r * cos(t)), (0, pi, 70), (0, 2 * pi, 70))\\n# esf.setAmbientColor(_1(99,136,63))\\n esf.setDiffuseColor(_1(99, 136, 63))\\n esf.setSpecularColor(_1(99, 136, 63))\\n\\n\\n def proyZm1(u, v, t1):\\n \\\"\\\"\\\"proy desde el polo norte al plano z=-1\\\"\\\"\\\"\\n den = u ** 2 + v ** 2 + 4\\n x = u - t1 * (u - 4 * u / den)\\n y = v - t1 * (v - 4 * v / den)\\n z = -1 - t1 * (-2 + 8 / den)\\n return (x, y, z)\\n\\n def proyZ1(u, v, t2):\\n \\\"\\\"\\\"proy desde el polo sur al plano z=1\\\"\\\"\\\"\\n den = u ** 2 + v ** 2 + 4\\n x = u - t2 * (u - 4 * u / den)\\n y = v - t2 * (v - 4 * v / den)\\n z = 1 - t2 * (2 - 8 / den)\\n return (x, y, z)\\n\\n stereo = ParametricPlot3D(proyZm1, (-3, 3, 70), (-3, 3, 70))\\n stereo.setLinesVisible(True)\\n stereo.setMeshVisible(False)\\n stereo.setMeshDiffuseColor(_1(117, 55, 79))\\n\\n stereo2 = ParametricPlot3D(proyZ1, (-3, 3, 70), (-3, 3, 70))\\n stereo2.setLinesVisible(True)\\n stereo2.setMeshVisible(False)\\n stereo2.setMeshDiffuseColor(_1(80, 87, 193))\\n stereo2.setTransparency(0.5)\\n stereo2.setTransparencyType(8)\\n\\n\\n baseplane = BasePlane()\\n baseplane.setHeight(-1.005)\\n baseplane.setRange((-4, 4, 7))\\n self.addChild(esf)\\n self.addChild(stereo2)\\n self.addChild(stereo)\\n self.addChild(baseplane)\\n\\n params = [stereo,stereo2]\\n\\n ## no queremos los controles\\n for i,p in enumerate(params):\\n p.parameters['t%d' % (i+1)].hide()\\n\\n anims = [p.parameters['t%d' % (i+1)].asAnimation() for i,p in enumerate(params)]\\n self.setupAnimations(anims)\",\n \"def test_lightcurve_seismology_plot():\\n KeplerLightCurveFile(TABBY_Q8).PDCSAP_FLUX.periodogram().plot()\",\n \"def apolco(a,minfeh=-3,out=None) :\\n apo=np.where((a['TELESCOPE'] == 'apo25m') & (a['RV_FEH']>minfeh) )[0]\\n fig=vscat(a[apo],marker='o',density=True)\\n lco=np.where((a['TELESCOPE'] == 'lco25m') & (a['RV_FEH']>minfeh) )[0]\\n vscat(a[lco],fig=fig,ls=':',marker='+',density=True)\\n if out is not None : \\n fig[0].savefig(out+'_1.png')\\n plt.close()\\n i1,i2=match.match(a['APOGEE_ID'][apo],a['APOGEE_ID'][lco])\\n print('matched {:d} stars'.format(len(i1)))\\n fig,ax=plots.multi(1,2)\\n #plots.plotp(ax[0,0],a['SNR'][apo[i1]],a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],yr=[-3,3],yt=r'$\\\\Delta$ VHELIO_AVG',xt='S/N')\\n #plots.plotp(ax[0,1],a['SNR'][apo[i1]],a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],yr=[-50,50],yt=r'$\\\\Delta$ VHELIO_AVG',xt='S/N')\\n #plots.plotp(ax[1,0],a['SNR'][apo[i1]],a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],yr=[-0.5,0.5],yt=r'$\\\\Delta$ VSCATTER',xt='S/N')\\n #plots.plotp(ax[1,1],a['SNR'][apo[i1]],a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],yr=[-5,5],yt=r'$\\\\Delta$ VSCATTER',xt='S/N')\\n ax[0].hist(a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],bins=np.arange(-0.5,0.5,0.02),histtype='step')\\n ax[0].set_xlabel(r'$\\\\Delta$ VHELIO_AVG')\\n ax[1].hist(a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],bins=np.arange(-0.25,0.25,0.01),histtype='step')\\n ax[1].set_xlabel(r'$\\\\Delta$ VSCATTER')\\n if out is not None : \\n fig.savefig(out+'_2.png')\\n plt.close()\",\n \"def plot_tiltres_xavier(setup, mtilt, ytilt, yfit, fitmask, fwhm, slit=None, outfile=None, show_QA=False, out_dir=None):\\n\\n plt.rcdefaults()\\n plt.rcParams['font.family']= 'times new roman'\\n\\n # Outfil\\n method = inspect.stack()[0][3]\\n if (outfile is None) and (not show_QA):\\n outfile = qa.set_qa_filename(setup, method, slit=slit, out_dir=out_dir)\\n\\n # Setup\\n plt.figure(figsize=(8, 4))\\n plt.clf()\\n ax = plt.gca()\\n\\n # Scatter plot\\n res = (mtilt - ytilt) - yfit\\n xmin = 0.95*np.asarray([ytilt,mtilt]).min()\\n xmax = 1.05*np.asarray([ytilt,mtilt]).max()\\n ax.hlines(0.0, xmin, xmax,linestyle='--', color='green')\\n ax.plot(ytilt[fitmask], (res[fitmask]), 'ko', mfc='k', markersize=5.0, label='Good Points')\\n ax.plot(ytilt[~fitmask],(res[~fitmask]), 'ro', mfc='r', markersize=5.0, label='Rejected Points')\\n #ax.scatter(mtilt, res)\\n rms = np.std(res[fitmask])\\n ax.text(0.90, 0.90, 'Slit {:d}: RMS (pixels) = {:0.5f}'.format(slit, rms),\\n transform=ax.transAxes, size='large', ha='right', color='black',fontsize=16)\\n ax.text(0.90, 0.80, ' Slit {:d}: RMS/FWHM = {:0.5f}'.format(slit, rms/fwhm),\\n transform=ax.transAxes, size='large', ha='right', color='black',fontsize=16)\\n # Label\\n ax.set_xlabel('Spectral Pixel')\\n ax.set_ylabel('RMS (pixels)')\\n ax.set_title('RMS of Each Arc Line Traced')\\n ax.set_xlim((xmin,xmax))\\n # Finish\\n plt.tight_layout(pad=0.2, h_pad=0.0, w_pad=0.0)\\n if show_QA:\\n plt.show()\\n\\n if outfile is not None:\\n plt.savefig(outfile, dpi=400)\\n\\n plt.close()\\n plt.rcdefaults()\\n\\n return\",\n \"def create_parametric_fin_heat_sink(\\n self,\\n hs_height=100,\\n hs_width=100,\\n hs_basethick=10,\\n pitch=20,\\n thick=10,\\n length=40,\\n height=40,\\n draftangle=0,\\n patternangle=10,\\n separation=5,\\n symmetric=True,\\n symmetric_separation=20,\\n numcolumn_perside=2,\\n vertical_separation=10,\\n matname=\\\"Al-Extruded\\\",\\n center=[0, 0, 0],\\n plane_enum=0,\\n rotation=0,\\n tolerance=1e-3,\\n ):\\n all_objs = self.modeler.primitives.object_names\\n self[\\\"FinPitch\\\"] = self.modeler.primitives._arg_with_dim(pitch)\\n self[\\\"FinThickness\\\"] = self.modeler.primitives._arg_with_dim(thick)\\n self[\\\"FinLength\\\"] = self.modeler.primitives._arg_with_dim(length)\\n self[\\\"FinHeight\\\"] = self.modeler.primitives._arg_with_dim(height)\\n self[\\\"DraftAngle\\\"] = draftangle\\n self[\\\"PatternAngle\\\"] = patternangle\\n self[\\\"FinSeparation\\\"] = self.modeler.primitives._arg_with_dim(separation)\\n self[\\\"VerticalSeparation\\\"] = self.modeler.primitives._arg_with_dim(vertical_separation)\\n self[\\\"HSHeight\\\"] = self.modeler.primitives._arg_with_dim(hs_height)\\n self[\\\"HSWidth\\\"] = self.modeler.primitives._arg_with_dim(hs_width)\\n self[\\\"HSBaseThick\\\"] = self.modeler.primitives._arg_with_dim(hs_basethick)\\n if numcolumn_perside > 1:\\n self[\\\"NumColumnsPerSide\\\"] = numcolumn_perside\\n if symmetric:\\n self[\\\"SymSeparation\\\"] = self.modeler.primitives._arg_with_dim(symmetric_separation)\\n # ipk['PatternDirection'] = 'Y'\\n # ipk['LengthDirection'] = 'X'\\n # ipk['HeightDirection'] = 'Z'\\n self[\\\"Tolerance\\\"] = self.modeler.primitives._arg_with_dim(tolerance)\\n\\n self.modeler.primitives.create_box(\\n [\\\"-HSWidth/200\\\", \\\"-HSHeight/200\\\", \\\"-HSBaseThick\\\"],\\n [\\\"HSWidth*1.01\\\", \\\"HSHeight*1.01\\\", \\\"HSBaseThick+Tolerance\\\"],\\n \\\"HSBase\\\",\\n matname,\\n )\\n Fin_Line = []\\n Fin_Line.append(self.Position(0, 0, 0))\\n Fin_Line.append(self.Position(0, \\\"FinThickness\\\", 0))\\n Fin_Line.append(self.Position(\\\"FinLength\\\", \\\"FinThickness + FinLength*sin(PatternAngle*3.14/180)\\\", 0))\\n Fin_Line.append(self.Position(\\\"FinLength\\\", \\\"FinLength*sin(PatternAngle*3.14/180)\\\", 0))\\n Fin_Line.append(self.Position(0, 0, 0))\\n self.modeler.primitives.create_polyline(Fin_Line, cover_surface=True, name=\\\"Fin\\\")\\n Fin_Line2 = []\\n Fin_Line2.append(self.Position(0, \\\"sin(DraftAngle*3.14/180)*FinThickness\\\", \\\"FinHeight\\\"))\\n Fin_Line2.append(self.Position(0, \\\"FinThickness-sin(DraftAngle*3.14/180)*FinThickness\\\", \\\"FinHeight\\\"))\\n Fin_Line2.append(\\n self.Position(\\n \\\"FinLength\\\",\\n \\\"FinThickness + FinLength*sin(PatternAngle*3.14/180)-sin(DraftAngle*3.14/180)*FinThickness\\\",\\n \\\"FinHeight\\\",\\n )\\n )\\n Fin_Line2.append(\\n self.Position(\\n \\\"FinLength\\\", \\\"FinLength*sin(PatternAngle*3.14/180)+sin(DraftAngle*3.14/180)*FinThickness\\\", \\\"FinHeight\\\"\\n )\\n )\\n Fin_Line2.append(self.Position(0, \\\"sin(DraftAngle*3.14/180)*FinThickness\\\", \\\"FinHeight\\\"))\\n self.modeler.primitives.create_polyline(Fin_Line2, cover_surface=True, name=\\\"Fin_top\\\")\\n self.modeler.connect([\\\"Fin\\\", \\\"Fin_top\\\"])\\n self.modeler.primitives[\\\"Fin\\\"].material_name = matname\\n # self.modeler.thicken_sheet(\\\"Fin\\\",'-FinHeight')\\n num = int((hs_width / (separation + thick)) / (max(1 - math.sin(patternangle * 3.14 / 180), 0.1)))\\n self.modeler.duplicate_along_line(\\\"Fin\\\", self.Position(0, \\\"FinSeparation+FinThickness\\\", 0), num, True)\\n self.modeler.duplicate_along_line(\\\"Fin\\\", self.Position(0, \\\"-FinSeparation-FinThickness\\\", 0), num / 4, True)\\n\\n all_names = self.modeler.primitives.object_names\\n list = [i for i in all_names if \\\"Fin\\\" in i]\\n if numcolumn_perside > 0:\\n self.modeler.duplicate_along_line(\\n list,\\n self.Position(\\\"FinLength+VerticalSeparation\\\", \\\"FinLength*sin(PatternAngle*3.14/180)\\\", 0),\\n \\\"NumColumnsPerSide\\\",\\n True,\\n )\\n\\n all_names = self.modeler.primitives.object_names\\n list = [i for i in all_names if \\\"Fin\\\" in i]\\n self.modeler.split(list, self.CoordinateSystemPlane.ZXPlane, \\\"PositiveOnly\\\")\\n all_names = self.modeler.primitives.object_names\\n list = [i for i in all_names if \\\"Fin\\\" in i]\\n self.modeler.create_coordinate_system(self.Position(0, \\\"HSHeight\\\", 0), mode=\\\"view\\\", view=\\\"XY\\\", name=\\\"TopRight\\\")\\n\\n self.modeler.split(list, self.CoordinateSystemPlane.ZXPlane, \\\"NegativeOnly\\\")\\n\\n if symmetric:\\n\\n self.modeler.create_coordinate_system(\\n self.Position(\\\"(HSWidth-SymSeparation)/2\\\", 0, 0),\\n mode=\\\"view\\\",\\n view=\\\"XY\\\",\\n name=\\\"CenterRightSep\\\",\\n reference_cs=\\\"TopRight\\\",\\n )\\n\\n self.modeler.split(list, self.CoordinateSystemPlane.YZPlane, \\\"NegativeOnly\\\")\\n self.modeler.create_coordinate_system(\\n self.Position(\\\"SymSeparation/2\\\", 0, 0),\\n mode=\\\"view\\\",\\n view=\\\"XY\\\",\\n name=\\\"CenterRight\\\",\\n reference_cs=\\\"CenterRightSep\\\",\\n )\\n self.modeler.duplicate_and_mirror(list, self.Position(0, 0, 0), self.Position(1, 0, 0))\\n Center_Line = []\\n Center_Line.append(self.Position(\\\"-SymSeparation\\\", \\\"Tolerance\\\", \\\"-Tolerance\\\"))\\n Center_Line.append(self.Position(\\\"SymSeparation\\\", \\\"Tolerance\\\", \\\"-Tolerance\\\"))\\n Center_Line.append(self.Position(\\\"VerticalSeparation\\\", \\\"-HSHeight-Tolerance\\\", \\\"-Tolerance\\\"))\\n Center_Line.append(self.Position(\\\"-VerticalSeparation\\\", \\\"-HSHeight-Tolerance\\\", \\\"-Tolerance\\\"))\\n Center_Line.append(self.Position(\\\"-SymSeparation\\\", \\\"Tolerance\\\", \\\"-Tolerance\\\"))\\n self.modeler.primitives.create_polyline(Center_Line, cover_surface=True, name=\\\"Center\\\")\\n self.modeler.thicken_sheet(\\\"Center\\\", \\\"-FinHeight-2*Tolerance\\\")\\n all_names = self.modeler.primitives.object_names\\n list = [i for i in all_names if \\\"Fin\\\" in i]\\n self.modeler.subtract(list, \\\"Center\\\", False)\\n else:\\n self.modeler.create_coordinate_system(\\n self.Position(\\\"HSWidth\\\", 0, 0), mode=\\\"view\\\", view=\\\"XY\\\", name=\\\"BottomRight\\\", reference_cs=\\\"TopRight\\\"\\n )\\n self.modeler.split(list, self.CoordinateSystemPlane.YZPlane, \\\"NegativeOnly\\\")\\n all_objs2 = self.modeler.primitives.object_names\\n list_to_move = [i for i in all_objs2 if i not in all_objs]\\n center[0] -= hs_width / 2\\n center[1] -= hs_height / 2\\n center[2] += hs_basethick\\n self.modeler.set_working_coordinate_system(\\\"Global\\\")\\n self.modeler.translate(list_to_move, center)\\n if plane_enum == self.CoordinateSystemPlane.XYPlane:\\n self.modeler.rotate(list_to_move, self.CoordinateSystemAxis.XAxis, rotation)\\n elif plane_enum == self.CoordinateSystemPlane.ZXPlane:\\n self.modeler.rotate(list_to_move, self.CoordinateSystemAxis.XAxis, 90)\\n self.modeler.rotate(list_to_move, self.CoordinateSystemAxis.YAxis, rotation)\\n elif plane_enum == self.CoordinateSystemPlane.YZPlane:\\n self.modeler.rotate(list_to_move, self.CoordinateSystemAxis.YAxis, 90)\\n self.modeler.rotate(list_to_move, self.CoordinateSystemAxis.ZAxis, rotation)\\n self.modeler.unite(list_to_move)\\n self.modeler.primitives[list_to_move[0]].name = \\\"HeatSink1\\\"\\n return True\",\n \"def plot(self):\\n\\t\\tself.plotOfSpect()\",\n \"def plot_tiltres_joe(setup, mtilt, ytilt, yfit, fitmask, fwhm, slit=None, outfile=None, show_QA=False, out_dir=None):\\n\\n plt.rcdefaults()\\n plt.rcParams['font.family']= 'times new roman'\\n\\n # Outfil\\n method = inspect.stack()[0][3]\\n if (outfile is None) and (not show_QA):\\n outfile = qa.set_qa_filename(setup, method, slit=slit, out_dir=out_dir)\\n\\n # Setup\\n plt.figure(figsize=(10, 6))\\n plt.clf()\\n ax = plt.gca()\\n\\n # Scatter plot\\n res = (mtilt - yfit)\\n xmin = 0.95*np.asarray([ytilt,mtilt]).min()\\n xmax = 1.05*np.asarray([ytilt,mtilt]).max()\\n ax.hlines(0.0, xmin, xmax,linestyle='--', color='green')\\n ax.plot(ytilt[fitmask], (res[fitmask]), 'ko', mfc='k', markersize=5.0, label='Good Points')\\n ax.plot(ytilt[~fitmask],(res[~fitmask]), 'ro', mfc='r', markersize=5.0, label='Rejected Points')\\n #ax.scatter(mtilt, res)\\n rms = np.std(res[fitmask])\\n ax.text(0.90, 0.90, 'Slit {:d}: RMS (pixels) = {:0.5f}'.format(slit, rms),\\n transform=ax.transAxes, size='large', ha='right', color='black',fontsize=16)\\n ax.text(0.90, 0.80, ' Slit {:d}: RMS/FWHM = {:0.5f}'.format(slit, rms/fwhm),\\n transform=ax.transAxes, size='large', ha='right', color='black',fontsize=16)\\n # Label\\n ax.set_xlabel('Spectral Pixel')\\n ax.set_ylabel('RMS (pixels)')\\n ax.set_title('RMS of Each Arc Line Traced')\\n ax.set_xlim((xmin,xmax))\\n # Finish\\n plt.tight_layout(pad=0.2, h_pad=0.0, w_pad=0.0)\\n if show_QA:\\n plt.show()\\n\\n if outfile is not None:\\n plt.savefig(outfile, dpi=400)\\n\\n plt.close()\\n plt.rcdefaults()\\n\\n return\",\n \"def grayplot_NH(QC,stage):\\n\\n\\n #set some constants\\n numpts=QC['GMtcs'].shape[1] #number of timepoints\\n rightsignallim = np.arange(-20,21,20) #GS, main plot signal limits - 2% assuming mode 1000 normalization\\n leftsignallim = np.arange(0,21,10) #DVars limits\\n rylimz=[np.min(rightsignallim),np.max(rightsignallim)]\\n lylimz=[np.min(leftsignallim),np.max(leftsignallim)]\\n FDmult = 10 #multiplier to FD to get in range of DVars values\\n FDthresh = 0.2 #FD threshold to mark frame for scrubbing (use 0.1 for filtered FD)\\n\\n #compute data quality metrics -- CG: compute by hand to better understand (separated here for practice)\\n [mvm,ddt_mvm,FD] = compute_FD(QC['MVM'])\\n DVars = compute_DVARS(QC['GMtcs'][:,:,stage]) # compute DVARs for a particular processing stage\\n GS = compute_GS(QC['GMtcs'][:,:,stage]) # compute global signal for a particular processing stage\\n\\n #create plot\\n fig = plt.figure(figsize=(10,10),constrained_layout = True)\\n gs = GridSpec(9,1,figure=fig)\\n\\n #plot individual mvm params\\n ax1 = fig.add_subplot(gs[0:2])\\n pointindex = np.arange(1,numpts+1)\\n plt.plot(pointindex,mvm)\\n\\n plt.xlim([0, numpts])\\n plt.ylim([-1.5, 1.5])\\n plt.ylabel('mvm-XYZPYR')\\n\\n #Next, plot FD, DVARS and GS on the same plot\\n ax2a = fig.add_subplot(gs[2:4])\\n ax2b = ax2a.twinx()\\n ax2a.plot(pointindex,DVars,color=[0,0,1],alpha=0.5)\\n ax2b.plot(pointindex,GS,color=[0,1,0],alpha=0.5)\\n ax2a.plot(pointindex,FD*FDmult,color=[1,0,0],alpha=0.5)\\n ax2a.hlines(FDthresh*FDmult,pointindex[0],pointindex[-1],'k',alpha=0.5)\\n \\n plt.xlim([0, numpts])\\n ax2a.set_ylim(lylimz)\\n ax2a.set_yticks(leftsignallim)\\n ax2b.set_ylim(rylimz)\\n ax2b.set_yticks(rightsignallim)\\n ax2a.set_ylabel('R:FD*' + str(FDmult) +' B:DV G:GS')\\n\\n #next plot gray matter signal\\n ax3 = fig.add_subplot(gs[4:8])\\n new_GMtcs = QC['GMtcs'][:,:,stage]\\n plt.imshow(new_GMtcs,cmap='gray',vmin=-20,vmax=20,aspect='auto') #default: showing 2% signal on mode 1000 norm\\n plt.ylabel('GRAY')\\n\\n #finally, plot WM and CSF ts\\n ax4 = fig.add_subplot(gs[8:])\\n new_WMCSF = np.vstack((QC['WMtcs'][:,:,stage],QC['CSFtcs'][:,:,stage]))\\n plt.imshow(new_WMCSF,cmap='gray',vmin=-20,vmax=20,aspect='auto')\\n plt.ylabel('WM CSF')\\n plt.xlabel('frames')\\n\\n return fig\",\n \"def plotSpectrum(inp,xrng=[],yrng=[],xlabel='',ylabel='',xlog=False,ylog=False,grid=False,\\n legend=[],legend_location='upper right',fontscale=1,legend_fontscale=1,title='',\\n color='k',colormap=None,linestyle='-',linewidth=1.5,alpha=1.,\\n show_noise=True,color_noise='k',linestyle_noise='-',linewidth_noise=1.5,alpha_noise=0.5,\\n comparison=None,color_comparison='grey',linestyle_comparison='-',linewidth_comparison=1.5,alpha_comparison=1,\\n residual=False,color_residual='m',linestyle_residual='-',linewidth_residual=1.5,alpha_residual=0.5,\\n telluric=False,color_telluric='grey',linestyle_telluric='-',linewidth_telluric=1.5,alpha_telluric=0.2,\\n features=[],mdwarf=False,ldwarf=False,tdwarf=False,young=False,binary=False,nsamples=100,\\n band=[],band_color='k',band_alpha=0.2,band_label='',band_label_position='bottom',band_width=0.1,\\n show_zero=True,stack=0.,zeropoint=0.,color_zero='k',linestyle_zero=':',linewidth_zero=1.5,alpha_zero=0.3,\\n inset=False,inset_xrange=[],inset_yrange=[],inset_position=[0.65,0.60,0.20,0.20],inset_features=False,\\n output='',multiplot=False,multipage=False,layout=[1,1],figsize=[],tight=True,\\n interactive=False,**kwargs):\\n\\n# keyword parameters (for backward compatability)\\n for k in ['showZero','showzero']: show_zero=kwargs.get(k,show_zero)\\n for k in ['showNoise','noise','uncertainty','shownoise','showuncertainty','show_uncertainty']: show_noise=kwargs.get(k,show_noise)\\n\\n for k in ['line_style','lineStyle','ls','linestyles','line_styles']: linestyle=kwargs.get(k,linestyle)\\n for k in ['line_width','lineWidth','width','lw','linewidths','line_widths']: linewidth=kwargs.get(k,linewidth)\\n for k in ['colors','colour','colours']: color=kwargs.get(k,color)\\n for k in ['colorScheme','color_scheme','colorscheme','colorMap','color_map']: colormap=kwargs.get(k,colormap)\\n\\n for k in ['colornoise','colorNoise','colorUnc','coloruncertainty','color_uncertainty','colorUncertainty']: color_noise=kwargs.get(k,color_noise)\\n for k in ['linestylenoise','line_style_noise','linestyleNoise']: linestyle_noise=kwargs.get(k,linestyle_noise)\\n for k in ['linewidthnoise','linewidthNoise','line_width_noise']: linewidth_noise=kwargs.get(k,linewidth_noise)\\n for k in ['alphanoise','alphaNoise']: alpha_noise=kwargs.get(k,alpha_noise)\\n\\n for k in ['colorzero','colorZero']: color_zero=kwargs.get(k,color_zero)\\n for k in ['linestylezero','line_style_zero','linestyleZero']: linestyle_zero=kwargs.get(k,linestyle_zero)\\n for k in ['linewidthzero','linewidthZero','line_width_zero']: linewidth_zero=kwargs.get(k,linewidth_zero)\\n for k in ['alphazero','alphaZero']: alpha_zero=kwargs.get(k,alpha_zero)\\n\\n for k in ['colorcomparison','colorComparison']: color_comparison=kwargs.get(k,color_comparison)\\n for k in ['linestyleComparison','line_style_comparison','linestylecomparison']: linestyle_comparison=kwargs.get(k,linestyle_comparison)\\n for k in ['linewidthcomparison','linewidthComparison','line_width_comparison']: linewidth_comparison=kwargs.get(k,linewidth_comparison)\\n for k in ['alphacomparison','alphaComparison']: alpha_comparison=kwargs.get(k,alpha_comparison)\\n\\n for k in ['colorresidual','colorResidual']: color_residual=kwargs.get(k,color_residual)\\n for k in ['linestyleresidual','line_style_residual','linestyleResidual']: linestyle_residual=kwargs.get(k,linestyle_residual)\\n for k in ['linewidthresidual','linewidthResidual','line_width_residual']: linewidth_residual=kwargs.get(k,linewidth_residual)\\n for k in ['alpharesidual','alphaResidual']: alpha_residual=kwargs.get(k,alpha_residual)\\n\\n for k in ['bands']: band=kwargs.get(k,band)\\n if len(band) == 2 and isinstance(band[0],list) == False: band = [band]\\n for k in ['bandcolors','bandcolor','band_colors']: band_color=kwargs.get(k,band_color)\\n for k in ['bandalphas','band_alphas','bandalpha']: band_alpha=kwargs.get(k,band_alpha)\\n for k in ['band_labels','bandlabel','bandlabels']: band_label=kwargs.get(k,band_label)\\n for k in ['band_label_positions','bandlabelposition','bandlabelpositions']: band_label_position=kwargs.get(k,band_label_position)\\n for k in ['bandwidth','bandwidths','band_widths']: band_width=kwargs.get(k,band_width)\\n for par in [band_color,band_alpha,band_label,band_label_position,band_width]:\\n if not isinstance(par,list): par = [par]*len(band)\\n if len(par) < len(band): par.extend([par[-1] for x in range(len(band)-len(par))])\\n\\n for k in ['legends','label','labels']: legend=kwargs.get(k,legend)\\n if not isinstance(legend,list): legend = [legend]\\n for k in ['legendfontscale','legendFontscale']: legend_fontscale=kwargs.get(k,legend_fontscale)\\n legend_fontscale=legend_fontscale*fontscale\\n for k in ['legendLocation','legendlocation','labelLocation','labellocation','label_location']: legend_location=kwargs.get(k,legend_location)\\n\\n for k in ['xrange','x_range','wave_range','wrange','wrng']: xrng=kwargs.get(k,xrng)\\n if not isinstance(xrng,list): xrng = [xrng]\\n for k in ['yrange','y_range','flux_range','frange','frng']: yrng=kwargs.get(k,yrng)\\n if not isinstance(yrng,list): yrng = [yrng]\\n\\n for k in ['multilayout','multiLayout','multi_layout']: layout=kwargs.get(k,layout)\\n for k in ['file','filename']: output=kwargs.get(k,output)\\n if not isinstance(output,str): output=''\\n filetype = '.pdf'\\n if output!='': filetype=output.split('.')[-1]\\n\\n if comparison != None and isinstance(comparison,splat.Spectrum) == False and isinstance(comparison,list) == False: \\n print('plotSpectrum() Warning: comparison spectrum should be a splat Spectrum object, you passed {}'.format(comparison))\\n comparison = None\\n\\n# some plotting constants\\n xlabel_default = 'Wavelength'\\n ylabel_deafult = 'Flux'\\n\\n# telluric bands in micron\\n telluric_bands = [[1.1,1.2]*u.micron,[1.3,1.5]*u.micron,[1.75,2.0]*u.micron]\\n\\n# assign features by group\\n if not isinstance(features,list): features = [features]\\n if ldwarf==True or mdwarf==True: features.extend(['k','na','feh','tio','co','h2o','h2'])\\n if tdwarf==True: features.extend(['k','ch4','h2o','h2'])\\n if young==True: features.extend(['vo'])\\n if binary==True: features.extend(['sb'])\\n\\n# clean repeats in features while maintaining order - set does not do this\\n if len(features)>0:\\n fea = []\\n for i in features:\\n if i not in fea: fea.append(i)\\n features = fea\\n\\n\\n# if a list is passed, use this list\\n splist = copy.deepcopy(inp)\\n if isinstance(splist,list) == False: splist = [splist]\\n \\n# set up for multiplot\\n if len(splist) == 1: multiplot = False\\n \\n# array of lists => force multiplot\\n elif len(splist) > 1 and isinstance(splist[0],list) == True: multiplot = True\\n else: pass\\n\\n# reformat array of spectra of multiplot is used (i.e., user forgot to set)\\n if multiplot == True and isinstance(splist[0],splat.Spectrum):\\n splist = [[s] for s in splist]\\n\\n elif multiplot == False and isinstance(splist[0],splat.Spectrum):\\n splist = [splist]\\n \\n# flatten array if multiplot is not set\\n elif multiplot == False and isinstance(splist[0],list) and len(splist) > 1:\\n splist = [[item for sublist in splist for item in sublist]] # flatten\\n else: pass\\n\\n# total number of spectra - use to assign default legends\\n allsps = [item for sublist in splist for item in sublist] # Total number of spectra\\n if len(legend) == 0: legend=[sp.name for sp in allsps]\\n if len(legend) < len(allsps):\\n legend.extend([allsps[i].name for i in range(len(legend),len(allsps)-len(legend))])\\n \\n\\n# now run a loop through the input subarrays\\n plt.close('all')\\n\\n# set up here for multiple file output\\n nplot = 1\\n if multipage == True or multiplot == True:\\n nplot = layout[0]*layout[1]\\n numpages = int(len(splist) / nplot) + 1\\n if (len(splist) % nplot == 0):\\n numpages -= 1\\n fig = []\\n \\n if multipage == True and filetype.lower() == 'pdf':\\n pdf_pages = PdfPages(output)\\n \\n if multipage == False:\\n if len(splist) > 1:\\n filebase = output.replace('.{}'.format(filetype),'')\\n files = [filebase+'{}.'.format(i+1)+filetype for i in numpy.arange(len(splist))]\\n else:\\n files = [output]\\n\\n pg_n = 0 # page counter\\n plt_n = 0 # plot per page counter\\n lg_n = 0 # legend per plot counter\\n\\n for plts,sp in enumerate(splist):\\n# set specific plot parameters\\n if not isinstance(sp[0],splat.Spectrum):\\n raise ValueError('\\\\nInput to plotSpectrum has wrong format:\\\\n\\\\n{}\\\\n\\\\n'.format(sp[0]))\\n\\n# set up plotting defaults for the list of spectra - REPLACE THIS\\n if not isinstance(zeropoint,list): zeropoint = [zeropoint]*len(sp)\\n if len(zeropoint) < len(sp): zeropoint.extend([zeropoint[-1] for x in range(len(sp)-len(zeropoint))])\\n if not isinstance(color,list): color = [color]*len(sp)\\n if len(color) < len(sp): color.extend([color[-1] for x in range(len(sp)-len(color))])\\n if not isinstance(linestyle,list): linestyle = [linestyle]*len(sp)\\n if len(linestyle) < len(sp): linestyle.extend([linestyle[-1] for x in range(len(sp)-len(linestyle))])\\n if not isinstance(linewidth,list): linewidth = [linewidth]*len(sp)\\n if len(linewidth) < len(sp): linewidth.extend([linewidth[-1] for x in range(len(sp)-len(linewidth))])\\n if not isinstance(alpha,list): alpha = [alpha]*len(sp)\\n if len(alpha) < len(sp): alpha.extend([alpha[-1] for x in range(len(sp)-len(alpha))])\\n if not isinstance(color_noise,list): color_noise = [color_noise]*len(sp)\\n if len(color_noise) < len(sp): color_noise.extend([color_noise[-1] for x in range(len(sp)-len(color_noise))])\\n if not isinstance(linestyle_noise,list): linestyle_noise = [linestyle_noise]*len(sp)\\n if len(linestyle_noise) < len(sp): linestyle_noise.extend([linestyle_noise[-1] for x in range(len(sp)-len(linestyle_noise))])\\n if not isinstance(linewidth_noise,list): linewidth_noise = [linewidth_noise]*len(sp)\\n if len(linewidth_noise) < len(sp): linewidth_noise.extend([linewidth_noise[-1] for x in range(len(sp)-len(linewidth_noise))])\\n if not isinstance(alpha_noise,list): alpha_noise = [alpha_noise]*len(sp)\\n if len(alpha_noise) < len(sp): alpha_noise.extend([alpha_noise[-1] for x in range(len(sp)-len(color_noise))])\\n if not isinstance(color_comparison,list): color_comparison = [color_comparison]*len(sp)\\n if len(color_comparison) < len(sp): color_comparison.extend([color_comparison[-1] for x in range(len(sp)-len(color_comparison))])\\n if not isinstance(linestyle_comparison,list): linestyle_comparison = [linestyle_comparison]*len(sp)\\n if len(linestyle_comparison) < len(sp): linestyle_comparison.extend([linestyle_comparison[-1] for x in range(len(sp)-len(linestyle_comparison))])\\n if not isinstance(linewidth_comparison,list): linewidth_comparison = [linewidth_comparison]*len(sp)\\n if len(linewidth_comparison) < len(sp): linewidth_comparison.extend([linewidth_comparison[-1] for x in range(len(sp)-len(linewidth_comparison))])\\n if not isinstance(alpha_comparison,list): alpha_comparison = [alpha_comparison]*len(sp)\\n if len(alpha_comparison) < len(sp): alpha_comparison.extend([alpha_comparison[-1] for x in range(len(sp)-len(alpha_comparison))])\\n\\n# settings that work if the spectrum was read in as legitmate Spectrum object\\n try:\\n xlabel = kwargs.get('xlabel','{} ({})'.format(sp[0].wave_label,sp[0].wave.unit))\\n ylabel = kwargs.get('ylabel','{} ({})'.format(sp[0].flux_label,sp[0].flux.unit))\\n except:\\n xlabel = kwargs.get('xlabel',xlabel_default)\\n ylabel = kwargs.get('ylabel',ylabel_default)\\n# initial plot range\\n bound = [numpy.nanmin(sp[0].wave.value),numpy.nanmax(sp[0].wave.value)]\\n ymax = [numpy.nanquantile(s.flux.value,0.98) for s in sp]\\n bound.extend(numpy.array([-0.02,1.3])*numpy.nanmax(ymax)+\\\\\\n numpy.array([numpy.nanmin(zeropoint),numpy.nanmax(zeropoint)+stack*(len(sp)-1)]))\\n\\n# set colormap if provided\\n if colormap != None:\\n values = numpy.arange(len(sp))\\n color_map = plt.get_cmap(colormap)\\n norm = colmap.Normalize(vmin=0, vmax=1.0*values[-1])\\n scalarMap = cm.ScalarMappable(norm=norm, cmap=color_map)\\n for i in range(len(sp)): color[i] = scalarMap.to_rgba(values[i])\\n\\n# GENERATE PLOTS\\n if multiplot == True or multipage == True:\\n plt_n = plts % nplot\\n if (plt_n == 0):\\n fig.append(plt.figure())\\n pg_n += 1\\n ax = fig[pg_n-1].add_subplot(layout[0], layout[1], plt_n+1)\\n \\n# plotting a single plot with all spectra\\n else:\\n plt.close('all')\\n plt_n = 0\\n fig = []\\n if len(figsize)>0: fig.append(plt.figure(figsize=figsize))\\n else: fig.append(plt.figure())\\n ax = fig[0].add_subplot(111)\\n \\n for ii, a in enumerate(sp):\\n# zeropoint and stack\\n flx = [i+zeropoint[ii] for i in a.flux.value]\\n if stack > 0: flx = [f + (len(sp)-ii-1)*stack for f in flx]\\n ax.plot(a.wave.value,flx,color=color[ii],linestyle=linestyle[ii], lw=linewidth[ii], alpha=alpha[ii], zorder = 10, label = legend[lg_n]) \\n\\n# add comparison\\n if comparison != None:\\n# zeropoint and stack\\n cflx = [i+zeropoint[ii] for i in comparison.flux.value]\\n if stack > 0: cflx = [f + (len(sp)-ii-1)*stack for f in cflx]\\n ax.plot(comparison.wave.value,cflx,color=color_comparison[ii],linestyle=linestyle_comparison[ii], lw=linewidth_comparison[ii], alpha=alpha_comparison[ii], zorder = 10)\\n \\n# add residual\\n if residual == True and len(sp) == 2:\\n # Save flux values from first spectrum\\n if ii == 0:\\n flx0 = [f - (len(sp)-ii-1)*stack for f in flx]\\n \\n # Subtract fluxes and plot\\n elif ii == 1:\\n res = [flx0[f_n] - f for f_n, f in enumerate(flx)]\\n ax.plot(a.wave.value, res, alpha = alpha_residual[ii], color = color_residual[ii], linsetyle=linestyle_residual[ii], lw=linewidth_residual[ii])\\n \\n # Fix bound[2] if residual goes below 0\\n if numpy.nanmin(res) < bound[2]:\\n b0 = numpy.argmin(a.wave.value[a.wave.value > bound[0]])\\n b1 = numpy.argmax(a.wave.value[a.wave.value < bound[1]])\\n bound[2] = numpy.nanmin(res[b0:b1])\\n\\n# noise\\n if show_noise == True:\\n ns = [i+zeropoint[ii] for i in a.noise.value]\\n ax.plot(a.wave.value,ns,color=color_noise[ii],linestyle=linestyle_noise[ii],alpha=alpha_noise[ii], lw=linewidth_noise[ii], zorder = 10)\\n\\n# zeropoint\\n if show_zero == True:\\n ze = numpy.ones(len(a.flux))*zeropoint[ii]\\n ax.plot(a.wave.value,ze,color=color[ii],linestyle=linestyle_zero,alpha=alpha_zero,lw=linewidth_zero, zorder = 10)\\n\\n# save maximum flux among all spectra for plotting\\n# THIS IS VERY SLOW AND IT WOULD BE BETTER TO FIND AN ALTERNATE APPROACH\\n if len(features)>0:\\n f = interp1d(a.wave,flx,bounds_error=False,fill_value=0.)\\n if ii == 0: \\n wvmax = numpy.linspace(bound[0],bound[1],nsamples)\\n flxmax = numpy.array(f(wvmax))\\n else: flxmax = numpy.maximum(flxmax,numpy.array(f(wvmax)))\\n\\n# legend counter\\n lg_n = lg_n + 1 # Increment legend\\n\\n\\n# label features\\n# THIS NEEDS TO BE FIXED WITH GRETEL'S STUFF\\n if len(features) > 0:\\n yoff = 0.02*(bound[3]-bound[2]) # label offset\\n fontsize = int((10-numpy.nanmin([(layout[0]*layout[1]-1),6]))*fontscale)\\n for ftr in features:\\n ftr = ftr.lower()\\n if ftr in FEATURE_LABELS:\\n ftrc = checkDict(ftr,FEATURE_LABELS)\\n if ftrc != False:\\n for ii,waveRng in enumerate(FEATURE_LABELS[ftrc]['wavelengths']):\\n wRng = waveRng.to(sp[0].wave.unit).value\\n# features must be contained in plot range (may change this)\\n if numpy.nanmin(wRng) > bound[0] and numpy.nanmax(wRng) < bound[1]:\\n wfeature = numpy.where(numpy.logical_and(wvmax >= numpy.nanmin(wRng),wvmax <= numpy.nanmax(wRng)))\\n if len(wvmax[wfeature]) == 0: wfeature = numpy.argmax(numpy.absolute(wvmax-numpy.nanmedian(wRng)))\\n y = numpy.nanmax(flxmax[wfeature])+yoff\\n flxmax[wfeature] = flxmax[wfeature]+3.*yoff\\n\\n if FEATURE_LABELS[ftrc]['type'] == 'band':\\n ax.plot(wRng,[y+yoff]*2,color='k',linestyle='-')\\n ax.plot([wRng[0]]*2,[y,y+yoff],color='k',linestyle='-')\\n ax.text(numpy.mean(wRng),y+1.5*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=fontsize)\\n else:\\n for w in wRng: ax.plot([w]*2,[y,y+yoff],color='k',linestyle='-')\\n ax.text(numpy.mean(wRng),y+1.5*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=fontsize)\\n bound[3] = numpy.nanmax([numpy.nanmax(flxmax)+2.*yoff,bound[3]])\\n\\n# add grid\\n if grid == True: ax.grid() \\n\\n# axis labels \\n fontsize = (numpy.round(numpy.max([13./((layout[0]*layout[1])**0.33),5]))) * fontscale\\n legend_fontsize = (13-numpy.min([(layout[0]*layout[1]-1),8])) * legend_fontscale\\n ax.set_xlabel(xlabel, fontsize = fontsize)\\n ax.set_ylabel(ylabel, fontsize = fontsize)\\n ax.tick_params(axis='x', labelsize=fontsize)\\n ax.tick_params(axis='y', labelsize=fontsize)\\n\\n# add title\\n if title!='': ax.set_title(title)\\n\\n# log scale?\\n if kwargs.get('xlog',False): ax.set_xscale('log',nonposx='clip')\\n if kwargs.get('ylog',False): ax.set_yscale('log',nonposy='clip')\\n\\n# place legend\\n if len(legend) > 0:\\n if legend_location == 'outside':\\n box = ax.get_position()\\n ax.set_position([box.x0, box.y0 + box.height * 0.15, box.width * 0.7, box.height * 0.7])\\n ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), prop={'size':legend_fontsize})\\n else:\\n ax.legend(loc=legend_location, prop={'size':legend_fontsize})\\n bound[3] = bound[3]+0.1*(bound[3]-bound[2]) # extend axis for in-plot legends\\n\\n# overplot telluric absorption\\n if telluric == True:\\n yoff = 0.02*(bound[3]-bound[2]) # label offset\\n for waveRng in telluric_bands:\\n wR = waveRng.to(sp[0].wave.unit).value\\n rect = patches.Rectangle((wR[0],bound[2]),wR[1]-wR[0],bound[3]-bound[2],facecolor=color_telluric,alpha=alpha_telluric,color=color_telluric)\\n ax.add_patch(rect)\\n ax.text(numpy.mean(wR),bound[2]+3*yoff,r'$\\\\oplus$',horizontalalignment='center',fontsize=fontsize)\\n\\n# overplot color swaths for pre-specified bands\\n if len(band) > 0:\\n for i,b in enumerate(band):\\n if not isinstance(b,list): \\n try: b = [float(b)-0.5*band_width,float(b)+0.5*band_width]\\n except:\\n print('\\\\nWarning: plotSpectrum bands variables should be array of 2-element arrays; you passed {}'.format(band))\\n b = [0.,0.]\\n rect = patches.Rectangle((b[0],bound[2]),b[1]-b[0],bound[3]-bound[2],facecolor=band_color[i],color=band_color[i],alpha=band_alpha[i])\\n ax.add_patch(rect)\\n if band_label_position[i].lower() == 'top':\\n ax.text(numpy.mean(b),bound[3]-3*yoff,band_label[i],horizontalalignment='center',fontsize=fontsize)\\n elif band_label_position[i].lower() == 'middle':\\n ax.text(numpy.mean(b),0.5*(bound[2]+bound[3]),band_label[i],horizontalalignment='center',fontsize=fontsize)\\n else:\\n ax.text(numpy.mean(b),bound[2]+3*yoff,band_label[i],horizontalalignment='center',fontsize=fontsize)\\n\\n# place inset - RIGHT NOW ONLY SETTING LIMITS WITH FIRST SPECTRUM IN LIST\\n if inset == True and len(inset_xrange) == 2:\\n ax_inset = fig[pg_n-1].add_axes(inset_position) #, axisbg='white')\\n bound2 = inset_xrange\\n if len(inset_yrange) == 0:\\n b0 = numpy.argmax(sp[0].wave.value > bound2[0])\\n b1 = numpy.argmin(sp[0].wave.value < bound2[1])\\n inset_yrange = [numpy.nanmin(sp[0].flux.value[b0:b1]),numpy.nanmax(sp[0].flux.value[b0:b1])]\\n bound2.extend(inset_yrange)\\n db = (bound2[3]-bound2[2])\\n bound2[2] = bound2[2]-0.05*db\\n bound2[3] = bound2[3]+0.05*db\\n ax_inset.axis(bound2)\\n inset_fontsize = fontsize*0.7\\n\\n for ii,a in enumerate(sp):\\n flx = [i+zeropoint[ii] for i in a.flux.value]\\n ax_inset.plot(a.wave.value,flx,color=colors[ii],linestyle=linestyle[ii],linewidth=linewidth[ii],alpha=alpha[ii]) \\n ax_inset.set_xlabel('')\\n ax_inset.set_ylabel('')\\n ax_inset.tick_params(axis='x', labelsize=inset_fontsize)\\n ax_inset.tick_params(axis='y', labelsize=inset_fontsize)\\n# ax_inset.legend()\\n\\n# inset feature labels\\n if len(inset_features) > 0:\\n yoff = 0.05*(bound2[3]-bound2[2])\\n for ftr in inset_features:\\n ftrc = checkDict(ftr,FEATURE_LABELS)\\n if ftrc != False:\\n for ii,waveRng in enumerate(FEATURE_LABELS[ftrc]['wavelengths']):\\n wRng = waveRng.to(sp[0].wave.unit).value\\n if (numpy.min(wRng) > bound2[0] and numpy.max(wRng) < bound2[1]):\\n wfeature = numpy.where(numpy.logical_and(wvmax >= numpy.nanmin(wRng),wvmax <= numpy.nanmax(wRng)))\\n if len(wvmax[wfeature]) == 0: wfeature = numpy.argmax(numpy.absolute(wvmax-numpy.nanmedian(wRng)))\\n y = numpy.nanmax(flxmax[wfeature])+yoff\\n flxmax[wfeature] = flxmax[wfeature]+3.*yoff\\n \\n if FEATURE_LABELS[ftrc]['type'] == 'band':\\n ax_inset.plot(wR,[y+yoff]*2,color='k',linestyle='-')\\n ax_inset.plot([wR[0]]*2,[y,y+yoff],color='k',linestyle='-')\\n ax_inset.text(numpy.mean(wR),y+2*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=inset_fontsize)\\n else:\\n for w in waveRng:\\n ax_inset.plot([w]*2,[y,y+yoff],color='k',linestyle='-')\\n ax_inset.text(numpy.mean(wR),y+2*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=inset_fontsize)\\n waveRng = [wR[0]-0.02,wR[1]+0.02] # for overlap\\n \\n# update offset\\n if len(inset_features) > 0: bound2[3] = numpy.nanmax([bound2[3],numpy.nanmax(flxmax)+5.*yoff])\\n ax_inset.axis(bound2)\\n\\n# finalize bounding\\n if len(xrng) > 0: bound[0:2] = xrng\\n if len(yrng) > 0: bound[2:4] = yrng\\n if isUnit(bound[0]): bound = [x.value for x in bound]\\n ax.axis(bound)\\n \\n# save to file or display\\n# ERROR HERE - CHECK WHAT FILES\\n if multipage == False:\\n if files[plts] != '' and (plts % nplot == 3 or plts == len(splist)-1):\\n if kwargs.get('tight',True) == True: \\n plt.savefig(files[plts], bbox_inches='tight')\\n else:\\n plt.savefig(files[plts])\\n if output == '' and not kwargs.get('web',False):\\n plt.show()\\n if (kwargs.get('interactive',False) != False): plt.ion()\\n else: plt.ioff()\\n\\n\\n# save figures in multipage format and write off pdf file\\n if multipage == True: \\n for pg_n in numpy.arange(numpages):\\n# fig[pg_n].text(0.5, 0.04, xlabel, ha = 'center', va = 'center')\\n# fig[pg_n].text(0.06, 0.5, ylabel, ha = 'center', va = 'center', rotation = 'vertical')\\n fig[pg_n].tight_layout\\n fig[pg_n].suptitle(title, fontsize = int(14*fontsize), fontweight = 'bold')\\n pdf_pages.savefig(fig[pg_n])\\n if filetype.lower() == 'pdf':\\n pdf_pages.close()\\n\\n plt.clf()\\n return fig\",\n \"def DT(time_lvl = 0, date = 160924 ):\\n \\n #-------Customised color in RGB ------------\\n C = [[232,232,230],#grey\\n [203,203,203], #grey\\n [161,161,161], #grey\\n [130,130,130], #grey\\n [149,53,229], #lillac, 39\\t64\\t197\\t149,53,229\\n [39,64,197], #blue dark,7,67,194\\n [15,110,229], #blue\\n [80,149,240], #blue\\n [74,192,243], #blue\\n [152,219,248], #blue\\n [183,237,247], #blue\\n [251,217,198], #redish\\n [255,197,166], #redish\\n [255,172,164], #redish\\n [253,139,142], #redish\\n [253,101,105], #redish\\n [255,66,74], #redish\\n [238,13,28], #red\\n [214,78,166], #pink\\n [214,102,201], \\n [217,155,210],\\n [216,181,211]]\\n C = np.array( C )\\n C = np.divide( C, 255. ) # RGB has to be between 0 and 1 in python\\n #-----------------------------------------------------------\\n \\n fig = plt.figure()\\n \\n \\n #-----Setting our map area and projection of interest-------\\n m = Basemap( llcrnrlon = -90., llcrnrlat = 0., urcrnrlon = 50., urcrnrlat=70.,\\\\\\n resolution = 'l', area_thresh = 10000., projection = 'merc' )\\n #m = Basemap(width=11500000,height=8500000,resolution='l',projection='eqdc',\\\\\\n # lat_1=07.,lat_2=40,lat_0=44,lon_0=-30.)\\n #m = Basemap(width=190000,height=2200000,resolution='l', projection='tmerc',lon_0=-30,lat_0=44)\\n \\n map_area( m ) # ploting background\\n path = \\\"gribs/\\\"\\n file = path +\\\"DT_var.grib\\\"\\n obj = pygrib.open( file )\\n \\n #-FETCHING ALL THE VALUES----------------------------------------\\n #-----Potential temperature---------------------------------------\\n lat, lon, data = get_data( obj,'Potential temperature', 2000, date, timelevel = time_lvl )\\n contour_val = np.linspace( 264, 384, 22 ) #contours for potential tempeature\\n plot_contourf( m, lat, lon, data, C, contour_val )\\n \\n #-----Relative vorticity, diff level------------------------------\\n contour=[ 2.8E-4, 3.5E-4, 4.5E-4, 6.5E-4, 7.E-4, 7.5E-4, 8.E-4 ] #1.5E-4,2.5E-4]#\\n lat, lon, data925 = get_data( obj, 'Vorticity (relative)', 925, date, timelevel = time_lvl )\\n lat, lon, data900 = get_data( obj, 'Vorticity (relative)', 900, date, timelevel = time_lvl )\\n lat, lon, data850 = get_data( obj, 'Vorticity (relative)', 850, date, timelevel = time_lvl )\\n \\n #->--->---->--mean value over height and filtering----------------\\n data = np.sqrt( data900**2 + 2*data850**2 + data925**2 ) #Vertical \\\"average\\\", weightet values at 850hpa double.\\n footprint = np.array([[0,0,0,1,1,1,1,0,0,0], #footprint=np.ones((3,10))\\n [0,0,1,1,1,2,1,1,0,0],\\n [1,1,1,2,2,1,2,1,1,1],\\n [0,1,1,1,1,2,1,1,1,0],\\n [0,0,1,1,1,1,1,1,0,0]])\\n \\n data = ndimage.generic_filter( data, np.mean, footprint = footprint, mode='wrap' )\\n plot_contour( m, lat,lon, data,contour, clr = 'k' )\\n \\n #-----Wind barbs----------------------------------------------------\\n lat, lon, data_u = get_data( obj , 'U component of wind', 2000, date, timelevel = time_lvl )\\n lat, lon, data_v = get_data( obj , 'V component of wind', 2000, date, timelevel = time_lvl )\\n plot_wind_bar( m, lat, lon, data_u, data_v )\\n #-----------------------------------------------\\n #-----------------------------------------------\\n \\n \\n \\n #-SAVE AND CLOSE----------------------------------------------------\\n #------------------------------------------------------------------\\n obj.close()\\n if time_lvl == 0:\\n t = \\\"0000\\\"\\n elif time_lvl == 1:\\n t = \\\"1200\\\"\\n elif time_lvl == 2:\\n t = \\\"1800\\\"\\n else: \\n t = \\\"t_not_set\\\"\\n \\n fig_name = \\\"DT/DT_\\\" + str( date ) + \\\"_\\\" + str( t )+ \\\".TIFF\\\" \\n \\n ax = plt.gca( )\\n plt.rc( 'font', size = 6 )\\n fig.set_size_inches( 12.80, 7.15 )\\n \\n fig.savefig( fig_name, dpi = 600 )\\n plt.close( )\\n #plt.show()\\n #--------------------------\\n #----------------------------\",\n \"def showCl(ell,temps,title='CAMB ISWout power spectrum'):\\n plt.plot(ell,temps*ell*(ell+1)/(2*np.pi) *1e12) #1e12 to convert to microK**2\\n plt.xlabel('multipole moment l')\\n plt.ylabel('l(l+1)C_l/(2pi) [microK**2]')\\n plt.title(title)\\n plt.show()\",\n \"def oceansim(sun_az,sun_zen,cam_head,cam_elev=0,m2=1.33,npart=1.08,mu=3.483, debug=True):\\n\\n #Water surface norm\\n n = np.array([0,0,1])\\n m1 = 1.0\\n #vector from sun:\\n ki = -np.asarray([np.sin(sun_az)*np.sin(sun_zen),\\n np.cos(sun_az)*np.sin(sun_zen),\\n np.cos(sun_zen)])\\n xi = norm_cross(n,ki)\\n #transmitted sunlight\\n #tx, ty are the transmission amplitude coefficients in the xt, yt directions\\n kt,tx,ty = Fresnel.transmission(ki,n,m1,m2)\\n xt = xi\\n #vector to camera\\n kc = -np.asarray([np.sin(cam_head)*np.cos(cam_elev),\\n np.cos(cam_head)*np.cos(cam_elev),\\n np.sin(cam_elev)])*np.linalg.norm(kt)\\n xc = norm_cross(n, kc) #right\\n yc = norm_cross(kc, xc) #up\\n #vectors for scattering\\n ys = norm_cross(kt, kc) # y-axis of scattering event\\n xst = norm_cross(ys, kt) # x-axis of scattering event relative to transmitted sunlight\\n xsc = norm_cross(ys, kc) # x-axis of scattering event relative to camera\\n #Mueller matrices\\n # transmission through water surface:\\n mm1 = Mueller.polarizer(tx,ty)\\n # rotate to scattering plane\\n mm2 = Mrotv(kt,xt,xst)\\n # scatter\\n th_s = vector_angle(kt,kc)\\n #mm3 = Mocean(rad2deg(th_s)) #using Empirical ocean scattering\\n mm3 = Mueller.rayleigh_norm(th_s) #normalized Rayleigh scattering matrix\\n #b = Scattering.bsf_fournier(npart,mu)\\n b = Scattering.vspf_fournier(th_s,npart,mu)\\n # transform to camera's horizontal and up vectors\\n mm4 = Mxform(xsc,ys, xc,yc)\\n #Combined: mm4 . (b*mm3) . mm2 . mm1\\n m = mm4.dot(b*mm3.dot(mm2.dot(mm1)))\\n #stokes vector\\n s = m.dot([1,0,0,0])\\n if debug:\\n return s,m,(ki,xi),(kt,xt,xst),(kc,xc,xsc),(mm1,mm2,mm3,b,mm4)\\n else:\\n return s,m\",\n \"def plot5(self):\\n\\n cond = ((self.ds.freq<32.6) & (self.ds.freq>17))\\n freq = self.ds.freq[cond]\\n power = self.ds.power[cond]\\n\\n # the modes for KIC 9205705\\n m = pd.read_csv('/home/mxs191/Desktop/MathewSchofield/TRG/GetData/Modes/modes_9205705.csv')\\n m1 = [17.65, 20.6, 23.7, 26.9, 30.1] # l=1\\n\\n plt.rc('font', size=18)\\n fig, ax = plt.subplots()\\n plt.plot(freq, power, zorder=1, alpha=0.4)\\n\\n # NOTE: annotate mode angular degrees\\n plt.scatter(m['f0'].as_matrix(), np.full(len(m), 150000), c='k', zorder=2, s=80)\\n plt.scatter(m['f2'].as_matrix(), np.full(len(m), 130000), c='mediumseagreen', zorder=2, s=80, marker='^')\\n plt.scatter(m1, np.full(len(m1), 140000), c='grey', zorder=2, s=80, marker='v')\\n\\n # NOTE: plot envelope\\n numax = info['numax'].as_matrix() # mu Hz\\n env_width = 0.66 * numax**0.88\\n plt.plot(freq, 40004*np.exp( -( (freq-24.7)**2 / (2*7.**2) ) ), c='k', linestyle='--')\\n\\n # NOTE: annotate envelope\\n style = dict(size=16, color='k')\\n ax.text(24.1, 49167, r\\\"$\\\\nu_{\\\\rm max}$\\\", color='k', size=18)\\n ax.text(24.1, 20994, r\\\"$\\\\Gamma_{\\\\rm env}$\\\", color='k', size=18)\\n ax.text(23, 162944, r\\\"$\\\\Delta \\\\nu$\\\", **style)\\n plt.annotate(s='', xy=(25.3, 158610), xytext=(21.91, 158610),\\n arrowprops=dict(arrowstyle='<->')) # dnu\\n plt.annotate(s='', xy=((24.7-env_width/2.), 15861), xytext=((24.7+env_width/2.), 15861),\\n arrowprops=dict(arrowstyle='<->')) # env width\\n\\n ax.set_xlabel(r'Frequency ($\\\\rm \\\\mu Hz$)')\\n ax.set_ylabel(r'PSD ($\\\\rm ppm^{2} \\\\, \\\\mu Hz^{-1}$)')\\n plt.xlim(17, 32.6)\\n plt.ylim(17, 195181)\\n plt.tight_layout()\\n plt.show()\\n fig.savefig(os.getcwd() + '/DetTest1_plots/Plot5_ps_' + str(self.ds.epic) + '.pdf')\",\n \"def oifits_show(dic, unit='arcsec', setlog=False, vmin=0, vmax=1.05, cmin=-4, cmax=4, unit_cp='rad'):\\n unit = 'arcsec'\\n uv_scale = {'m': 1,\\n 'rad': 1/dic['OI_WAVELENGTH']['EFF_WAVE'],\\n 'arcsec': 1/dic['OI_WAVELENGTH']['EFF_WAVE']/rad2mas(1e-3),\\n 'lambda': 1/dic['OI_WAVELENGTH']['EFF_WAVE']/1e6}\\n\\n U = dic['OI_VIS2']['UCOORD']*uv_scale[unit]\\n V = dic['OI_VIS2']['VCOORD']*uv_scale[unit]\\n\\n sp_freq_vis = dic['OI_VIS2']['FREQ'] * uv_scale[unit]\\n\\n V2 = dic['OI_VIS2']['VIS2DATA']\\n e_V2 = dic['OI_VIS2']['VIS2ERR'] * 1\\n\\n sp_freq_cp = dic['OI_T3']['FREQ'] * uv_scale[unit] # Anand KeyError: 'FREQ' \\n cp = dic['OI_T3']['T3PHI']\\n e_cp = dic['OI_T3']['T3PHIERR']\\n\\n bmax = 1.2*np.max(np.sqrt(U**2+V**2))\\n\\n # Configuration fenetre\\n fig = plt.figure(figsize=(16, 5.5))\\n ax1 = plt.subplot2grid((2, 6), (0, 0), rowspan=2, colspan=2)\\n ax2 = plt.subplot2grid((2, 6), (0, 2), colspan=4)\\n ax3 = plt.subplot2grid((2, 6), (1, 2), colspan=4)\\n\\n # Plot plan UV\\n # -------\\n fig.subplots_adjust(top=0.974,\\n bottom=0.091,\\n left=0.038,\\n right=0.996,\\n hspace=0.127,\\n wspace=0.35)\\n\\n #ax1.set_title('(u-v) plan', fontsize=12, color = 'grey', weight = 'bold')\\n\\n ax1.scatter(U, V, s=50, c='#00adb5',\\n edgecolors='#364f6b', marker='o', alpha=1)\\n ax1.scatter(-1*np.array(U), -1*np.array(V), s=50, c='#fc5185',\\n edgecolors='#364f6b', marker='o', alpha=1)\\n ax1.axis([bmax, -bmax, -bmax, bmax])\\n ax1.spines['left'].set_visible(False)\\n ax1.spines['right'].set_visible(False)\\n ax1.spines['bottom'].set_visible(False)\\n ax1.spines['top'].set_visible(False)\\n ax1.patch.set_facecolor('#f7f9fc')\\n ax1.patch.set_alpha(1)\\n ax1.xaxis.set_ticks_position('none')\\n ax1.yaxis.set_ticks_position('none')\\n # ax1.yaxis.set_ticks_position('left')\\n\\n unitlabel = {'m': 'm',\\n 'rad': 'rad$^{-1}$',\\n 'arcsec': 'arcsec$^{-1}$',\\n 'lambda': 'M$\\\\lambda$'}\\n\\n ax1.set_xlabel(r'U [%s]' % unitlabel[unit])\\n ax1.set_ylabel(r'V [%s]' % unitlabel[unit])\\n ax1.grid(alpha=0.2)\\n\\n # Plot V2\\n # -------\\n #ax2.set_title('Visibility and closure phase', fontsize=12,color = 'grey', weight = 'bold')\\n ax2.errorbar(sp_freq_vis, V2, yerr=e_V2, linestyle=\\\"None\\\", capsize=1, ecolor='#364f6b', mfc='#00adb5', mec='#364f6b',\\n marker='.', elinewidth=0.5, alpha=1, ms=8)\\n\\n ax2.hlines(1, 0, 1.2*np.max(sp_freq_vis),\\n lw=1, color='k', alpha=.2, linestyle='--')\\n\\n ax2.set_ylim([vmin, vmax])\\n ax2.set_xlim([0, 1.2*np.max(sp_freq_vis)])\\n ax2.set_ylabel(r'$V^2$')\\n ax2.spines['left'].set_visible(False)\\n ax2.spines['right'].set_visible(False)\\n ax2.spines['bottom'].set_visible(False)\\n ax2.spines['top'].set_visible(False)\\n ax2.patch.set_facecolor('#f7f9fc') \\n ax2.patch.set_alpha(1)\\n ax2.xaxis.set_ticks_position('none')\\n ax2.yaxis.set_ticks_position('none')\\n #ax2.set_xticklabels([])\\n\\n if setlog:\\n ax2.set_yscale('log')\\n ax2.grid(which='both', alpha=.2)\\n\\n # Plot CP\\n # -------\\n\\n if unit_cp == 'rad':\\n h1 = np.pi\\n pass\\n else:\\n cp = np.rad2deg(cp).copy()\\n e_cp = np.rad2deg(e_cp).copy()\\n h1 = np.rad2deg(np.pi)\\n \\n cmin = -cmax\\n\\n ax3.errorbar(sp_freq_cp, cp, yerr=e_cp, linestyle=\\\"None\\\", capsize=1, ecolor='#364f6b', mfc='#00adb5', mec='#364f6b',\\n marker='.', elinewidth=0.5, alpha=1, ms=8)\\n ax3.hlines(h1, 0, 1.2*np.max(sp_freq_vis),\\n lw=1, color='k', alpha=.2, ls='--')\\n ax3.hlines(-h1, 0, 1.2*np.max(sp_freq_vis),\\n lw=1, color='k', alpha=.2, ls='--')\\n ax3.spines['left'].set_visible(False)\\n ax3.spines['right'].set_visible(False)\\n ax3.spines['bottom'].set_visible(False)\\n ax3.spines['top'].set_visible(False)\\n ax3.patch.set_facecolor('#f7f9fc')\\n ax3.patch.set_alpha(1)\\n ax3.xaxis.set_ticks_position('none')\\n ax3.yaxis.set_ticks_position('none')\\n ax3.set_xlabel('Spatial frequency [cycle/arcsec]')\\n ax3.set_ylabel('Clos. $\\\\phi$ [%s]'%unit_cp)\\n ax3.axis([0, 1.2*np.max(sp_freq_vis), cmin, cmax])\\n ax3.grid(which='both', alpha=.2)\\n plt.show()\\n return fig\",\n \"def n27_and_stark():\\n fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(4.5, 4))\\n # n=27 without static field.\\n folder = os.path.join(\\\"..\\\", \\\"..\\\", \\\"2018-09-09\\\")\\n fname = \\\"11_freq_diode.txt\\\"\\n fname = os.path.join(folder, fname)\\n data = pmu.fscan_import(fname)\\n data['afpoly'] = data['fpoly'] + 4511\\n ax.axhline(0, color='grey')\\n data.plot(x='afpoly', y='sig', c='k', ax=ax)\\n # n=27 with static field.\\n fname = \\\"10_freq_diode.txt\\\"\\n fname = os.path.join(folder, fname)\\n data = pmu.fscan_import(fname)\\n data['afpoly'] = data['fpoly'] + 4511\\n data['asig'] = data['sig'] + 0.15\\n ax.axhline(0.15, color='grey')\\n data.plot(x='afpoly', y='asig', c='k', ax=ax)\\n # text\\n ax.text(-5.5, 0.2, \\\"3 V/cm\\\", horizontalalignment='right')\\n ax.text(-5.5, 0.01, \\\"0 V/cm\\\", horizontalalignment='right')\\n # pretty figure\\n ax.legend().remove()\\n ax.set_ylabel(r\\\"$e^-$ Signal\\\")\\n ax.set_yticks([])\\n ax.set_xlabel(r\\\"Frequency (GHz from $3d_{5/2} \\\\rightarrow 27f$)\\\")\\n ax.set_xlim(-8, 7)\\n # save\\n fig.tight_layout()\\n fig.savefig('n27_and_stark.pdf')\\n return\",\n \"def example():\\n # --- input data filename ---\\n infile = os.path.join(os.path.dirname(__file__),\\n '../../ExampleDataFiles/MarsTopo719.shape')\\n coeffs, lmax = pysh.shio.shread(infile)\\n\\n # --- plot grid ---\\n grid = pysh.expand.MakeGridDH(coeffs, csphase=-1)\\n fig_map = plt.figure()\\n plt.imshow(grid)\\n\\n # ---- compute spectrum ----\\n ls = np.arange(lmax + 1)\\n pspectrum = pysh.spectralanalysis.spectrum(coeffs, unit='per_l')\\n pdensity = pysh.spectralanalysis.spectrum(coeffs, unit='per_lm')\\n\\n # ---- plot spectrum ----\\n fig_spectrum, ax = plt.subplots(1, 1)\\n ax.set_xscale('log')\\n ax.set_yscale('log')\\n ax.set_xlabel('degree l')\\n ax.grid(True, which='both')\\n\\n ax.plot(ls[1:], pspectrum[1:], label='power per degree l')\\n ax.plot(ls[1:], pdensity[1:], label='power per degree l and order m')\\n\\n ax.legend()\\n\\n fig_map.savefig('SHRtopography_mars.png')\\n fig_spectrum.savefig('SHRspectrum_mars.png')\\n print('mars topography and spectrum saved')\\n\\n # plt.show()\",\n \"def setplot(plotdata):\\n#-------------------------- \\n\\n\\n from pyclaw.plotters import colormaps, geoplot\\n\\n plotdata.clearfigures() # clear any old figures,axes,items data\\n\\n def set_drytol(current_data):\\n # The drytol parameter is used in masking land and water and\\n # affects what color map is used for cells with small water depth h.\\n # The cell will be plotted as dry if h < drytol.\\n # The best value to use often depends on the application and can\\n # be set here (measured in meters):\\n current_data.user.drytol = 1.e-4\\n\\n\\n plotdata.beforeframe = set_drytol\\n\\n # To plot gauge locations on pcolor or contour plot, use this as\\n # an afteraxis function:\\n\\n def addgauges(current_data):\\n from pyclaw.plotters import gaugetools\\n gaugetools.plot_gauge_locations(current_data.plotdata, \\\\\\n gaugenos='all', format_string='ko', add_labels=True)\\n \\n\\n #-----------------------------------------\\n # Figure for imshow plot\\n #-----------------------------------------\\n plotfigure = plotdata.new_plotfigure(name='imshow', figno=0)\\n plotfigure.show = False\\n\\n # Set up for axes in this figure:\\n plotaxes = plotfigure.new_plotaxes('imshow')\\n plotaxes.title = 'Surface'\\n plotaxes.scaled = True\\n\\n # Water\\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\\n #plotitem.plot_var = geoplot.surface\\n plotitem.plot_var = geoplot.surface_or_depth\\n plotitem.imshow_cmap = geoplot.tsunami_colormap\\n plotitem.imshow_cmin = -0.02\\n plotitem.imshow_cmax = 0.02\\n plotitem.add_colorbar = True\\n plotitem.amr_gridlines_show = [0,0,0]\\n plotitem.amr_gridedges_show = [1]\\n\\n # Land\\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\\n plotitem.plot_var = geoplot.land\\n plotitem.imshow_cmap = geoplot.land_colors\\n plotitem.imshow_cmin = 0.0\\n plotitem.imshow_cmax = 0.05\\n plotitem.add_colorbar = False\\n plotitem.amr_gridlines_show = [0,0,0]\\n plotaxes.xlimits = 'auto'\\n plotaxes.ylimits = 'auto'\\n\\n \\n\\n #-----------------------------------------\\n # Figure for imshow plot\\n #-----------------------------------------\\n plotfigure = plotdata.new_plotfigure(name='Surface and Gauge 1', figno=20)\\n\\n # Set up for axes in this figure:\\n plotaxes = plotfigure.new_plotaxes('imshow')\\n plotaxes.axescmd = \\\"axes([.1,.5,.8,.4])\\\"\\n plotaxes.title = 'Surface'\\n plotaxes.scaled = True\\n plotaxes.afteraxes = addgauges\\n\\n # Water\\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\\n #plotitem.plot_var = geoplot.surface\\n plotitem.plot_var = geoplot.surface_or_depth\\n plotitem.imshow_cmap = geoplot.tsunami_colormap\\n plotitem.imshow_cmin = -0.03\\n plotitem.imshow_cmax = 0.03\\n plotitem.add_colorbar = True\\n plotitem.amr_gridlines_show = [0,0,0]\\n plotitem.amr_gridedges_show = [1]\\n\\n # Land\\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\\n plotitem.plot_var = geoplot.land\\n plotitem.imshow_cmap = geoplot.land_colors\\n plotitem.imshow_cmin = 0.0\\n plotitem.imshow_cmax = 0.05\\n plotitem.add_colorbar = False\\n plotitem.amr_gridlines_show = [0,0,0]\\n plotaxes.xlimits = 'auto'\\n plotaxes.ylimits = 'auto'\\n\\n\\n # Gauge trace:\\n plotaxes = plotfigure.new_plotaxes()\\n plotaxes.show = False\\n plotaxes.axescmd = \\\"axes([.1,.1,.8,.3])\\\"\\n plotaxes.xlimits = 'auto'\\n plotaxes.ylimits = [-0.02, 0.05]\\n plotaxes.title = 'Gauge 1'\\n\\n # Plot surface as blue curve:\\n plotitem = plotaxes.new_plotitem(plot_type='1d_gauge_trace')\\n plotitem.plot_var = 3\\n plotitem.plotstyle = 'b-'\\n plotitem.gaugeno = 1\\n\\n\\n #-----------------------------------------\\n # Figure for zoom\\n #-----------------------------------------\\n plotfigure = plotdata.new_plotfigure(name='Zoom', figno=10)\\n #plotfigure.show = False\\n plotfigure.kwargs = {'figsize':[7,7]}\\n\\n # Set up for axes in this figure:\\n plotaxes = plotfigure.new_plotaxes('monai')\\n #plotaxes.axescmd = 'axes([0.0,0.1,0.6,0.6])'\\n plotaxes.title = 'Monai Valley'\\n plotaxes.scaled = True\\n #plotaxes.xlimits = [4.0, 5.2]\\n #plotaxes.ylimits = [1.3, 2.5]\\n plotaxes.xlimits = [4.7, 5.2]\\n plotaxes.ylimits = [1.5, 2.2]\\n\\n # Water\\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\\n #plotitem.plot_var = geoplot.surface\\n plotitem.plot_var = geoplot.surface_or_depth\\n plotitem.imshow_cmap = geoplot.tsunami_colormap\\n plotitem.imshow_cmin = -0.02\\n plotitem.imshow_cmax = 0.02\\n plotitem.add_colorbar = False\\n plotitem.amr_gridlines_show = [0]\\n plotitem.amr_gridedges_show = [1]\\n\\n # Land\\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\\n plotitem.plot_var = geoplot.land\\n plotitem.imshow_cmap = geoplot.land_colors\\n plotitem.imshow_cmin = 0.0\\n plotitem.imshow_cmax = 0.05\\n plotitem.add_colorbar = False\\n plotitem.amr_gridlines_show = [0]\\n\\n # Add contour lines of bathymetry:\\n plotitem = plotaxes.new_plotitem(plot_type='2d_contour')\\n plotitem.plot_var = geoplot.topo\\n from numpy import arange, linspace\\n plotitem.contour_levels = arange(-0.02, 0., .0025)\\n plotitem.amr_contour_colors = ['k'] # color on each level\\n plotitem.kwargs = {'linestyles':'solid'}\\n plotitem.amr_contour_show = [1] # show contours only on finest level\\n plotitem.gridlines_show = 0\\n plotitem.gridedges_show = 0\\n plotitem.show = True\\n \\n # Add contour lines of topography:\\n plotitem = plotaxes.new_plotitem(plot_type='2d_contour')\\n plotitem.plot_var = geoplot.topo\\n from numpy import arange, linspace\\n plotitem.contour_levels = arange(0., .2, .01)\\n plotitem.amr_contour_colors = ['w'] # color on each level\\n plotitem.kwargs = {'linestyles':'solid'}\\n plotitem.amr_contour_show = [1] # show contours only on finest level\\n plotitem.gridlines_show = 0\\n plotitem.gridedges_show = 0\\n plotitem.show = True\\n\\n # Add dashed contour line for current shoreline\\n plotitem = plotaxes.new_plotitem(plot_type='2d_contour')\\n plotitem.plot_var = 0\\n plotitem.contour_levels = [0.002]\\n plotitem.amr_contour_colors = ['k'] # color on each level\\n plotitem.kwargs = {'linestyles':'dashed','linewidths':2}\\n plotitem.amr_contour_show = [1] # show contours only on finest level\\n plotitem.gridlines_show = 0\\n plotitem.gridedges_show = 0\\n plotitem.show = True\\n\\n\\n\\n\\n #-----------------------------------------\\n # Figures for gauges\\n #-----------------------------------------\\n plotfigure = plotdata.new_plotfigure(name='Surface & topo', figno=300, \\\\\\n type='each_gauge')\\n\\n # Set up for axes in this figure:\\n plotaxes = plotfigure.new_plotaxes()\\n plotaxes.xlimits = [0,25]\\n plotaxes.ylimits = [-0.02, 0.05]\\n plotaxes.title = 'Surface'\\n\\n # Plot surface as blue curve:\\n plotitem = plotaxes.new_plotitem(plot_type='1d_plot')\\n plotitem.plot_var = 3\\n plotitem.plotstyle = 'b-'\\n\\n # Plot topo as green curve:\\n plotitem = plotaxes.new_plotitem(plot_type='1d_plot')\\n\\n def gaugetopo(current_data):\\n q = current_data.q\\n h = q[:,0]\\n eta = q[:,3]\\n topo = eta - h\\n return topo\\n \\n plotitem.plot_var = gaugetopo\\n plotitem.clf_each_gauge = False\\n plotitem.plotstyle = 'g-'\\n def afteraxes(current_data):\\n from pylab import plot, legend, loadtxt\\n t = current_data.t\\n plot(t, 0*t, 'k')\\n gaugeno = current_data.gaugeno\\n \\n if gaugeno in [5,7,9]:\\n col = (gaugeno-3)/2\\n plot(labgage[:,0],0.01*labgage[:,col],'r')\\n legend(('GeoClaw','topography','sea level','lab data'),loc='upper left')\\n else:\\n legend(('GeoClaw','topography','sea level'),loc='upper right')\\n \\n \\n\\n plotaxes.afteraxes = afteraxes\\n\\n\\n #-----------------------------------------\\n # Figure for grids alone\\n #-----------------------------------------\\n plotfigure = plotdata.new_plotfigure(name='grids', figno=2)\\n plotfigure.show = False\\n\\n # Set up for axes in this figure:\\n plotaxes = plotfigure.new_plotaxes()\\n plotaxes.xlimits = [0,1]\\n plotaxes.ylimits = [0,1]\\n plotaxes.title = 'grids'\\n plotaxes.scaled = True\\n\\n # Set up for item on these axes:\\n plotitem = plotaxes.new_plotitem(plot_type='2d_grid')\\n plotitem.amr_grid_bgcolor = ['#ffeeee', '#eeeeff', '#eeffee']\\n plotitem.amr_gridlines_show = [1,1,0] \\n plotitem.amr_gridedges_show = [1] \\n\\n #-----------------------------------------\\n \\n # Parameters used only when creating html and/or latex hardcopy\\n # e.g., via pyclaw.plotters.frametools.printframes:\\n\\n plotdata.printfigs = True # print figures\\n plotdata.print_format = 'png' # file format\\n #plotdata.print_framenos = [4,6,8,10,12]\\n plotdata.print_framenos = [5,7,9,11,13]\\n plotdata.print_gaugenos = [0,5,7,9] # list of gauges to print\\n plotdata.print_fignos = 'all' # list of figures to print\\n plotdata.html = True # create html files of plots?\\n plotdata.html_homelink = '../README.html' # pointer for top of index\\n plotdata.latex = True # create latex file of plots?\\n plotdata.latex_figsperline = 2 # layout of plots\\n plotdata.latex_framesperline = 1 # layout of plots\\n plotdata.latex_makepdf = False # also run pdflatex?\\n\\n return plotdata\",\n \"def plot(self):\\n\\t\\t\\n\\t\\ttf=tfData(self.shotno,tStart=None,tStop=None)\\n\\t\\t\\n\\t\\t_plt.figure()\\n\\t\\tax1 = _plt.subplot2grid((3,2), (0,1), rowspan=3) #tf\\n\\t\\tax2 = _plt.subplot2grid((3,2), (0,0)) #vf\\n\\t\\tax3 = _plt.subplot2grid((3,2), (1,0),sharex=ax2) #oh\\n\\t\\tax4 = _plt.subplot2grid((3,2), (2, 0),sharex=ax2) #sh\\n\\t\\tfig=_plt.gcf()\\n\\t\\tfig.set_size_inches(10,5)\\n\\t\\t\\t\\t\\n\\t\\ttStart=-2\\n\\t\\ttStop=20\\n\\t\\t\\n\\t\\tax1.plot(tf.time*1e3,tf.tfBankField)\\n\\t\\tax1.axvspan(tStart,tStop,color='r',alpha=0.3)\\n\\t\\t_plot.finalizeSubplot(ax1,xlabel='Time (s)',xlim=[-150,450],ylabel='TF Field (T)')#,title=self.title\\n\\t\\t\\n\\t\\tax2.plot(self.vfTime*1e3,self.vfBankCurrent*1e-3)\\n\\t\\t_plot.finalizeSubplot(ax2,ylabel='VF Current\\\\n(kA)')\\n\\t\\t\\n\\t\\tax3.plot(self.ohTime*1e3,self.ohBankCurrent*1e-3)\\n\\t\\t_plot.finalizeSubplot(ax3,ylim=[-20,30],ylabel='OH Current\\\\n(kA)')\\n\\t\\t\\n\\t\\tax4.plot(self.shTime*1e3,self.shBankCurrent*1e-3)\\n\\t\\t_plot.finalizeSubplot(ax4,ylim=[tStart,tStop],xlabel='Time (s)',ylabel='SH Current\\\\n(kA)')\\n\\t\\t\\n\\t\\t_plot.finalizeFigure(fig,title=self.title)\\n#\\t\\tfig.set_tight_layout(True)\\n\\t\\t\\n\\t\\treturn fig\",\n \"def make_hexplot(XX,VV,gs=100):\\n coord = [[0,0,0],[0,400,-400],[-400,400,0],[-400,0,400],[0,-400,400],[400,-400,0],[400,0,-400],[0,800,-800],[-800,800,0],[-800,0,800],[0,-800,800],[800,-800,0],[800,0,-800],[800,0,0],[-400,800,-400],[-400,-800,400],[-800,0,0],[400,-800,400],[400,800,-400]]\\n\\n # Horizontal cartesian coords\\n hcoord = [c[0] for c in coord]\\n\\n # Vertical cartersian coords\\n vcoord = [2. * np.sin(np.radians(60)) * (c[1] - c[2]) /3. for c in coord]\\n\\n fig, ax = plt.subplots(1,figsize=(20,20))\\n ax.set_aspect('equal')\\n\\n nhex=len(coord)\\n # Add some coloured hexagons\\n for i in range(0,nhex):\\n xi=(XX[:,0])+hcoord[i]/1000.\\n yi=(YY[:,1])+vcoord[i]/1000.\\n idist=np.sqrt(xi**2+yi**2)\\n iindx=(idist<0.2)*(np.fabs(XX[:,2])<0.2)\\n hex = RegularPolygon((hcoord[i], vcoord[i]), numVertices=6, radius=800./3., \\n orientation=np.radians(30), \\n facecolor='white', alpha=1., edgecolor='k',zorder=i*2)\\n ax.add_patch(hex)\\n ax.hist2d(VV[:,0][iindx]*1.5+hcoord[i],VV[:,1][iindx]*2.-375.+220.+vcoord[i],range=[[hcoord[i]-220.,hcoord[i]+220],[vcoord[i]-220,vcoord[i]+220]],bins=gs,cmin=1.0e-50,rasterized=True,density=True,zorder=i*2+1)\\n ax.set_xlim(-1200,1200)\\n ax.set_ylim(-1200,1200)\\n ax.set_xlabel(r'$x\\\\ (\\\\mathrm{pc})$',fontsize=20)\\n ax.set_ylabel(r'$y\\\\ (\\\\mathrm{pc})$',fontsize=20)\\n ax.tick_params(axis='both', labelsize=20)\\n\\n #hex2 = RegularPolygon((800,2.*np.sin(np.radians(60))*(1600) /3.), numVertices=6, radius=800./3.,orientation=np.radians(30), \\n # facecolor='white', alpha=1., edgecolor='k',zorder=0)\\n #ax.add_patch(hex2)\\n plt.savefig('Hexgrid.pdf',bbox_inches='tight')\\n #plt.show()\\n plt.close()\",\n \"def view_datashade(self):\\n # Select only sufficient data\\n if self.x in self.y:\\n self.y.remove(self.x)\\n if self.y == []:\\n return self.gif\\n\\n df = self.dataframe[[self.x] + self.y].copy()\\n plot_opts = {\\n 'Scatter': {'color': self.color_key, 'marker': self.marker_keys, 'size':10},\\n 'Curve': {'color': self.color_key}\\n }\\n lines_overlay = df.hvplot.scatter(**self.plot_options).options(plot_opts)\\n\\n def hover_curve(x_range=[df.index.min(), df.index.max()]): # , y_range):\\n # Compute\\n dataframe = df.copy()\\n if x_range is not None:\\n dataframe = dataframe[(dataframe[self.x] > x_range[0]) & (dataframe[self.x] < x_range[1])]\\n data_length = len(dataframe) * len(dataframe.columns)\\n step = 1 if data_length < self.max_step else data_length // self.max_step\\n \\n plot_df = dataframe[::step].hvplot.line(**self.plot_options) * \\\\\\n dataframe[::step*60].hvplot.scatter(**self.plot_options) \\n plot_opts = {\\n 'Scatter': {'color': 'k', 'marker': self.marker_keys, 'size':10},\\n 'Curve': {'color': self.color_key}\\n }\\n if len(self.y) != 1:\\n plot_opts['Scatter']['color'] = self.color_key\\n return plot_df.options(plot_opts)\\n\\n # Define a RangeXY stream linked to the image\\n rangex = hv.streams.RangeX(source=lines_overlay)\\n data_shade_plot = hv.DynamicMap(hover_curve, streams=[rangex])\\n if len(self.y) == 1:\\n data_shade_plot *= datashade(lines_overlay)\\n else:\\n data_shade_plot *= datashade(lines_overlay, aggregator=ds.count_cat('Variable'))\\n return pn.panel(data_shade_plot)\",\n \"def plot_field_uncertainties():\\n\\n resize_size = (1000, 1000)\\n\\n\\n dirs = [os.path.join(path_to_here, '../data/landscape_visualizations/{}/{}/'.format(drug_name, j)) for j in ['original', 'repeat_a', 'repeat_b']]\\n if drug_name == 'DMSO':\\n dirs = [os.path.join(path_to_here, '../data/landscape_visualizations/{}/{}/30_hours/'.format(drug_name, j)) for j in ['original', 'repeat_a', 'repeat_b']]\\n\\n def transform(x):\\n if type(x) is np.ndarray:\\n x = change_array_lims(x)\\n x = np.log(x)\\n return x\\n\\n F_unc_vmin = -7\\n F_unc_vmax = -4\\n sigma_vmin = -5\\n sigma_vmax = 0 #0.4\\n sigma_unc_vmin = -6\\n sigma_unc_vmax = -2\\n\\n fig_Fs = [plt.figure() for _ in range(3)]\\n fig_uncertainty = plt.figure()\\n sigma_lists, F_arrays = [], []\\n for idx_fig, dir in enumerate(dirs):\\n\\n p_list = _load_and_resize_list(dir+'p_list_0.pickle')\\n D_list = _load_and_resize_list(dir+'D_list_0.pickle')\\n U_array = pickle.load(open(dir+'U.pickle', 'rb'))\\n U_array = cv2.resize(U_array, resize_size, interpolation = cv2.INTER_LINEAR)\\n Gx, Gy = np.gradient(U_array, 26./resize_size[0], 26./resize_size[0]) # gradients with respect to x and y\\n F_array = (Gx**2+Gy**2)**.5 # gradient magnitude\\n F_array[np.isinf(F_array)] = np.nan\\n F_array[p_list[-1]<1e-3]=np.nan # final PDF\\n sigma_list = []\\n for j in range(9):\\n arr = D_list[2*j] # current PDF\\n arr[p_list[j]<1e-3]=np.nan\\n sigma_list.append(np.sqrt(2*arr))\\n\\n\\n sigma_lists.append(sigma_list)\\n F_arrays.append(F_array)\\n\\n ax = fig_Fs[idx_fig].add_subplot(111)\\n ax.imshow(transform(F_array)[::-1, :], cmap = cmap, vmin = -4.6, vmax = -2)\\n ax.set_title(dir)\\n\\n all_axes = [i for j in fig_Fs for i in j.axes]\\n for ax in all_axes:\\n ax.axis('off')\\n\\n # uncertainties\\n\\n std = np.std(F_arrays, axis = 0)\\n ax = fig_uncertainty.add_subplot(121)\\n ax.imshow(transform(std)[::-1, :], cmap = cmap, vmin = F_unc_vmin, vmax = F_unc_vmax)\\n ax.set_title('F_uncertainty')\\n\\n fig_sigma = plt.figure()\\n ax = fig_sigma.add_subplot(111)\\n ax.imshow(transform(np.nanmean(sigma_lists[0], axis = 0))[::-1, :], cmap = cmap, vmin = sigma_vmin, vmax = sigma_vmax) # index 0 (i.3 'original' is corresponds to the landscapes in other figures)\\n ax.set_title('sigma_mean')\\n\\n sigma_means = [np.nanmean(sigma_list, axis = 0) for sigma_list in sigma_lists]\\n std_array = np.nanstd(sigma_means, axis = 0)\\n ax = fig_uncertainty.add_subplot(122)\\n ax.imshow(transform(std_array)[::-1, :], cmap = cmap, vmin = sigma_unc_vmin, vmax = sigma_unc_vmax)\\n ax.set_title('sigma_uncertainty')\\n\\n fig_sigma.savefig(path_to_here+'/../outputs/{}_mean_sigma.png'.format(drug_name), dpi = 1200)\\n fig_uncertainty.savefig(path_to_here+'/../outputs/{}_uncertainties.png'.format(drug_name), dpi = 1200)\",\n \"def plot_all(self) -> None:\\n self.__plot_si_cf_plane()\\n self.__plot_convex_hull()\\n self.__plot_fixed_radius()\\n self.__plot_delaunay()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.668535","0.60801226","0.6054332","0.59788936","0.5932414","0.5875222","0.5846639","0.57671297","0.5711864","0.57099444","0.5647215","0.5645391","0.5641379","0.5634341","0.5630049","0.56289643","0.5628059","0.562422","0.5621892","0.5609679","0.56076366","0.5585685","0.5559724","0.551522","0.55135804","0.5504126","0.5498697","0.5498159","0.5495989","0.5489027","0.5484838","0.5481873","0.5478845","0.5477301","0.54695356","0.5461199","0.5456571","0.54529834","0.545263","0.54491776","0.543393","0.54328555","0.54325485","0.54247963","0.5420787","0.54104006","0.540661","0.5405142","0.5404075","0.54019415","0.5397628","0.5387641","0.53866076","0.5386176","0.53831303","0.5381434","0.5380347","0.5378255","0.53761697","0.53741187","0.5372333","0.5367014","0.5360038","0.53573936","0.5346366","0.53456736","0.5337413","0.5334645","0.53335506","0.5332009","0.5330812","0.53278923","0.53246933","0.53226733","0.5321613","0.53207904","0.5320245","0.53146183","0.5314578","0.5313219","0.5303561","0.530352","0.5300202","0.5297078","0.5297039","0.529671","0.5295002","0.52941734","0.5287441","0.5283554","0.5282738","0.5280658","0.52801085","0.52751803","0.5273669","0.527057","0.52670383","0.5266979","0.5265644","0.5263851"],"string":"[\n \"0.668535\",\n \"0.60801226\",\n \"0.6054332\",\n \"0.59788936\",\n \"0.5932414\",\n \"0.5875222\",\n \"0.5846639\",\n \"0.57671297\",\n \"0.5711864\",\n \"0.57099444\",\n \"0.5647215\",\n \"0.5645391\",\n \"0.5641379\",\n \"0.5634341\",\n \"0.5630049\",\n \"0.56289643\",\n \"0.5628059\",\n \"0.562422\",\n \"0.5621892\",\n \"0.5609679\",\n \"0.56076366\",\n \"0.5585685\",\n \"0.5559724\",\n \"0.551522\",\n \"0.55135804\",\n \"0.5504126\",\n \"0.5498697\",\n \"0.5498159\",\n \"0.5495989\",\n \"0.5489027\",\n \"0.5484838\",\n \"0.5481873\",\n \"0.5478845\",\n \"0.5477301\",\n \"0.54695356\",\n \"0.5461199\",\n \"0.5456571\",\n \"0.54529834\",\n \"0.545263\",\n \"0.54491776\",\n \"0.543393\",\n \"0.54328555\",\n \"0.54325485\",\n \"0.54247963\",\n \"0.5420787\",\n \"0.54104006\",\n \"0.540661\",\n \"0.5405142\",\n \"0.5404075\",\n \"0.54019415\",\n \"0.5397628\",\n \"0.5387641\",\n \"0.53866076\",\n \"0.5386176\",\n \"0.53831303\",\n \"0.5381434\",\n \"0.5380347\",\n \"0.5378255\",\n \"0.53761697\",\n \"0.53741187\",\n \"0.5372333\",\n \"0.5367014\",\n \"0.5360038\",\n \"0.53573936\",\n \"0.5346366\",\n \"0.53456736\",\n \"0.5337413\",\n \"0.5334645\",\n \"0.53335506\",\n \"0.5332009\",\n \"0.5330812\",\n \"0.53278923\",\n \"0.53246933\",\n \"0.53226733\",\n \"0.5321613\",\n \"0.53207904\",\n \"0.5320245\",\n \"0.53146183\",\n \"0.5314578\",\n \"0.5313219\",\n \"0.5303561\",\n \"0.530352\",\n \"0.5300202\",\n \"0.5297078\",\n \"0.5297039\",\n \"0.529671\",\n \"0.5295002\",\n \"0.52941734\",\n \"0.5287441\",\n \"0.5283554\",\n \"0.5282738\",\n \"0.5280658\",\n \"0.52801085\",\n \"0.52751803\",\n \"0.5273669\",\n \"0.527057\",\n \"0.52670383\",\n \"0.5266979\",\n \"0.5265644\",\n \"0.5263851\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5718604"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":21296,"cells":{"query":{"kind":"string","value":"Defaults setup for pressurization history"},"document":{"kind":"string","value":"def plot_powerlawDB(timeDB, xunits='yr', yunits='MPa', skip=8, P0=33.0):\n workdir = '/home/scott/research/models/pylith/powerlaws/iavcei_diorite'\n\n # Plot geotherm\n z, T = np.loadtxt('geotherm.txt', usecols=(2,3), unpack=True)\n plt.figure()\n plt.plot(time,pressure,'b.-',lw=3,label='pressure')\n plt.xlabel('Time [{}]'.format(xunits))\n plt.ylabel('Pressure [{}]'.format(yunits))\n plt.title('Time History')\n plt.show()\n\n # Print lab data used (last line of powerlaw_params.spatialdb)\n # NOTE: can specify these at various depths to have different mineralogies\n with open('powerlaw_params.spatialdb') as f:\n lines = f.readlines()\n vals = lines[-1].split()\n A = float(vals[3]) #flow constant\n R = float(vals[4]) #activation energy\n n = float(vals[5]) #exponent\n Q = float(vals[6]) #activation energy multiplier\n\n # Get strain rate from powerlaw_gendb.cfg\n with open('powerlaw_gendb.cfg') as f:\n lines = f.readlines()\n line = [l for l in lines if l.startswith('reference_strain_rate')]\n rate = float(line[0].split('=')[-1].rstrip('/s\\n'))\n\n #NOTE: use functino in IAVCEI_plots.py to plot effective strength or viscosity versus depth"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def history():","def initialize(self):\n PostProcessorInterfaceBase.initialize(self)\n self.inputFormat = 'HistorySet'\n self.outputFormat = 'HistorySet'","def Modifier_History(self):\n\t\tpass","def __init__(self, history=None):\n\n self.__history = history if history else []","def onRegisterHistory(self):\n pass","def set_defaults():\n\tglobal defaults\n\n\tdefaults = {}\n\tdefaults[\"aliase\"] = {}\n\n\tdefaults[\"nigiri\"] = {}\n\tdefaults[\"nigiri\"][\"wrap_input\"] = \"True\"\n\tdefaults[\"nigiri\"][\"command_char\"] = \"/\"\n\tdefaults[\"nigiri\"][\"shortcut_pattern\"] = \"meta [0-9]\"\n\tdefaults[\"nigiri\"][\"server_shortcuts\"] = \"true\"\n\tdefaults[\"nigiri\"][\"show_debug\"] = \"True\"\n\tdefaults[\"nigiri\"][\"logfile\"] = os.path.join(xdg_cache_home, \"sushi\", \"nigiri.txt\")\n\tdefaults[\"nigiri\"][\"locale_dir\"] = get_path(\"..\", \"locale\")\n\tdefaults[\"nigiri\"][\"plugin_dirs\"] = escape_join(\",\", (\n\t\t\tos.path.join(xdg_data_home, \"nigiri\", \"plugins\"),\n\t\t\tos.path.join(xdg_data_home, \"chirashi\"),\n\t\t\tget_path(\"plugins\"),\n\t\t\tget_path(\"..\", \"chirashi\")\n\t\t))\n\n\tdefaults[\"chatting\"] = {}\n\tdefaults[\"chatting\"][\"quit_message\"] = \"Quit.\"\n\tdefaults[\"chatting\"][\"part_message\"] = \"Part.\"\n\tdefaults[\"chatting\"][\"last_log_lines\"] = \"15\"\n\tdefaults[\"chatting\"][\"nick_separator\"] = \": \"\n\n\tdefaults[\"colors\"] = {}\n\tdefaults[\"colors\"][\"messages\"] = \"gray\"\n\tdefaults[\"colors\"][\"messages_own\"] = \"white\"\n\tdefaults[\"colors\"][\"messages_highlight\"] = \"red\"\n\tdefaults[\"colors\"][\"actions\"] = \"gray\"\n\tdefaults[\"colors\"][\"actions_own\"] = \"white\"\n\tdefaults[\"colors\"][\"informative\"] = \"blue\"\n\n\tdefaults[\"templates\"] = {}\n\t# misc\n\tdefaults[\"templates\"][\"datestring\"] = \"%H:%M\"\n\t# messages\n\tdefaults[\"templates\"][\"action\"] = \"%(time)s %(nick)s %(message)s\"\n\tdefaults[\"templates\"][\"action_own\"] = \"%(time)s %(nick)s %(message)s\"\n\tdefaults[\"templates\"][\"message\"] = \"%(time)s <%(prefix)s%(nick)s> %(message)s\"\n\tdefaults[\"templates\"][\"message_own\"] = \"%(time)s <%(prefix)s%(nick)s> %(message)s\"\n\tdefaults[\"templates\"][\"ctcp\"] = \"%(time)s -%(nick)s/%(target)s- %(message)s\"\n\tdefaults[\"templates\"][\"ctcp_own\"] = \"%(time)s -%(nick)s/%(target)s- %(message)s\"\n\tdefaults[\"templates\"][\"notice\"] = \"%(time)s *%(nick)s/%(target)s* %(message)s\"\n\tdefaults[\"templates\"][\"notice_own\"] = \"%(time)s *%(nick)s/%(target)s* %(message)s\"\n\n\t# actions\n\tdefaults[\"templates\"][\"invite\"] = \"%(time)s * %(nick)s invites %(who)s to %(channel)s\"\n\tdefaults[\"templates\"][\"invite_own\"] = \"%(time)s * You were invited by %(nick)s to %(channel)s.\"\n\tdefaults[\"templates\"][\"join\"] = \"%(time)s * %(nick)s (%(host)s) has joined %(channel)s.\"\n\tdefaults[\"templates\"][\"join_own\"] = \"%(time)s * You have joined %(channel)s.\"\n\tdefaults[\"templates\"][\"kick\"] = \"%(time)s * %(who)s got kicked from %(channel)s by %(nick)s (%(reason)s)\"\n\tdefaults[\"templates\"][\"kick_own\"] = \"%(time)s * You got kicked from %(channel)s by %(nick)s (%(reason)s)\"\n\tdefaults[\"templates\"][\"nick\"] = \"%(time)s * %(nick)s is now known as %(new_nick)s.\"\n\tdefaults[\"templates\"][\"nick_own\"] = \"%(time)s * You are now known as %(new_nick)s.\"\n\tdefaults[\"templates\"][\"mode_list\"] = \"%(time)s * Modes for %(target)s: %(modes)s.\"\n\tdefaults[\"templates\"][\"mode_list_own\"] = \"%(time)s * Modes set on you: %(modes)s.\"\n\tdefaults[\"templates\"][\"mode\"] = \"%(time)s %(nick)s set %(mode)s%(param)s on %(target)s.\"\n\tdefaults[\"templates\"][\"mode_own\"] = \"%(time)s You set %(mode)s%(param)s on %(target)s.\"\n\tdefaults[\"templates\"][\"oper\"] = \"%(time)s * %(nick)s is now an OPER.\"\n\tdefaults[\"templates\"][\"oper_own\"] = \"%(time)s * You are now an OPER.\"\n\tdefaults[\"templates\"][\"part\"] = \"%(time)s * %(nick)s has left %(channel)s (%(reason)s).\"\n\tdefaults[\"templates\"][\"part_own\"] = \"%(time)s * You have left %(channel)s (%(reason)s).\"\n\tdefaults[\"templates\"][\"quit\"] = \"%(time)s * %(nick)s has quit (%(reason)s).\"\n\tdefaults[\"templates\"][\"quit_own\"] = \"%(time)s * You have quit (%(reason)s).\"\n\tdefaults[\"templates\"][\"topic\"] = \"%(time)s * %(nick)s has set the topic on %(channel)s to \\\"%(topic)s\\\".\"\n\tdefaults[\"templates\"][\"topic_own\"] = \"%(time)s * You have set the topic on %(channel)s to \\\"%(topic)s\\\".\"\n\tdefaults[\"templates\"][\"topic_anonymous\"] = \"* Topic of %(channel)s: %(topic)s\"\n\n\t# informative\n\tdefaults[\"templates\"][\"banlist_begin\"] = \"%(time)s Begin of banlist on channel %(channel)s.\"\n\tdefaults[\"templates\"][\"banlist_item\"] = \">> %(who)s %(mask)s %(when)s\"\n\tdefaults[\"templates\"][\"banlist_end\"] = \"%(time)s End of banlist. (%(channel)s)\"\n\tdefaults[\"templates\"][\"cannot_join\"] = \"%(time)s Can't join channel %(channel)s: %(reason)s\"\n\tdefaults[\"templates\"][\"list_begin\"] = \"%(time)s Begin of list.\"\n\tdefaults[\"templates\"][\"list_item\"] = \">> %(channel)s %(user)s %(topic)s\"\n\tdefaults[\"templates\"][\"list_end\"] = \"%(time)s End of list.\"\n\tdefaults[\"templates\"][\"names_begin\"] = \"%(time)s Begin of names (%(channel)s).\"\n\tdefaults[\"templates\"][\"names_item\"] = \"[ %(row)s ]\"\n\tdefaults[\"templates\"][\"names_end\"] = \"%(time)s End of names.\"\n\tdefaults[\"templates\"][\"no_such\"] = \"%(time)s No such %(type)s: %(target)s.\"\n\tdefaults[\"templates\"][\"whois_begin\"] = \"%(time)s Begin of whois (%(target)s).\"\n\tdefaults[\"templates\"][\"whois_item\"] = \">> %(nick)s: %(message)s\"\n\tdefaults[\"templates\"][\"whois_end\"] = \"%(time)s End of whois.\"\n\tdefaults[\"templates\"][\"dcc_new_incoming\"] = \"%(time)s Incoming file transfer (ID:%(id)d) from %(sender)s: \\\"%(filename)s\\\" (%(size)d).\"\n\tdefaults[\"templates\"][\"dcc_file_auto_accept\"] = \"%(time)s Auto accepted file transfer from %(sender)s: \\\"%(filename)s\\\" (%(size)d).\"\n\n\t# Add default sections to config parser\n\t# so setting is easier\n\tfor section in defaults.keys():\n\t\ttry:\n\t\t\tconfig_parser.add_section(section)\n\t\texcept ConfigParser.DuplicateSectionError:\n\t\t\tcontinue\n\n\t# sections defined below are not added to the configParser and\n\t# can't be set by the set method (will raise NoSectionError)\n\tpass","def setup_hooks(self):\n pass","def defaults():\n return {}","def historical():\n\n return {\n 'page': 'historical',\n }","def tweaks(self) -> None:\n pass","def set_app_defaults(self):\n self.curve_render = 0\n self.image_render = 0\n self.image_height = 200\n self.image_data = []\n self.auto_scale = True\n\n self.create_actions()\n self.setup_signals()\n self.reset_graph()\n\n self.fps = utils.SimpleFPS()\n\n # Click the live button\n self.ui.actionContinue_Live_Updates.trigger()","def defaults() -> dict:\n pass","def history():\n return apology(\"TODO\")","def history():\n return apology(\"TODO\")","def history():\n return apology(\"TODO\")","def autodefaults (self):\r\n\r\n self.defaults_from_notes(identifying_key=EMPTYCHAR,\r\n mark=EQUAL,\r\n obj=self.default_dict['commands'],\r\n entrytext=COMMANDMACROSCRIPT)","def default_config():\n config = Config()\n config.TerminalInteractiveShell.colors = 'NoColor'\n config.TerminalTerminalInteractiveShell.term_title = False,\n config.TerminalInteractiveShell.autocall = 0\n f = tempfile.NamedTemporaryFile(suffix=u'test_hist.sqlite', delete=False)\n config.HistoryManager.hist_file = Path(f.name)\n f.close()\n config.HistoryManager.db_cache_size = 10000\n return config","def __init__( settings={} ):","def initialise(self):","def __init__(self, environment):\n super(HistoricalExtension, self).__init__(environment)\n environment.filters['titlecase'] = titlecase","def initDefaults(self):\n return _libsbml.Event_initDefaults(self)","def add_earlydefault_settings(self):\n self.add_default_settings_config()\n self.add_default_settings_aliases()","def default_forage_args():\n\n forage_args = {\n 'prop_legume': 0.0,\n 'steepness': 1.,\n 'DOY': 1,\n 'start_year': 2016,\n 'start_month': 1,\n 'num_months': 24,\n 'mgmt_threshold': 0.01,\n 'century_dir': 'C:/Users/ginge/Dropbox/NatCap_backup/Forage_model/CENTURY4.6/Century46_PC_Jan-2014',\n 'template_level': 'GH',\n 'fix_file': 'drygfix.100',\n 'user_define_protein': 1,\n 'user_define_digestibility': 0,\n 'herbivore_csv': r\"C:/Users/ginge/Dropbox/NatCap_backup/Mongolia/model_inputs/cashmere_goats.csv\",\n 'grass_csv': r\"C:/Users/ginge/Dropbox/NatCap_backup/Mongolia/model_inputs/grass.csv\",\n 'restart_monthly': 0,\n }\n return forage_args","def post_init(self):\n\t\tpass","def _post_hooks(self):","def presets (self):\n assert False, \"To be implemented by child\"","def setup_default_terms(self):\n # Setting config with pattern -\n # default_dict[\"json config key\"] = (\"Default Value\", \"Ask User\", \"Value Type\")\n\n self.default_terms[Keys.first_run] = (Values.first_run, False, None)\n self.default_terms[Keys.nas_mount] = (Values.nas_mount_path, True, str)\n self.default_terms[Keys.secs_between_checks] = (Values.check_time, True, int)\n self.default_terms[Keys.redmine_api_key] = ('none', False, str)","def set_default_parameters(self):\n super().set_default_parameters()","def _post_init(self):\n pass","def _set_defaults(self):\n self.api_protocol = 'https'\n self.api_host = 'nhl-score-api.herokuapp.com'\n self.current_score = 0\n self.sleep_seconds = 30 # Time to sleep after calling the API\n self.desired_game_state = 'LIVE' # Desired game state is LIVE","def defaults(self):\n self.lib.iperf_defaults(self._test)","def init_tab(self):","def without_defaults(self):\n ...","def initialize_default(self):\n self.initialize_navigation()\n self.initialize_viewport()","def initialize(self, src_sentence):\n self.history = ['<s>'] if self.history_len > 0 else []","def __init__(self):\n self.analytics = Analytics()\n self.menu_options = {\n \"1\": self.add_habit,\n \"2\": self.check_off,\n \"3\": self.delete_habit,\n \"4\": self.see_habit,\n \"5\": self.show_all_habits,\n \"6\": self.habits_same_periodicity,\n \"7\": self.habit_longest_streak,\n \"0\": self.exit,\n\n }","def initDefaults(self):\n return _libsbml.Reaction_initDefaults(self)","def initialize_options(self):","def defaults(self):\n\n return None","def defaults(self):\n\n return None","def _initialize_defaults(self):\n for key, value in defaults.items():\n if key not in self.source_params:\n self.source_params[key] = value","def _initialize_defaults(self):\n for key, value in defaults.items():\n if key not in self.source_params:\n self.source_params[key] = value","def make_initial_state(self):\n pass","def add_settings_early(self):\n pass","def initialize(self):","def initialize(self):","def initialize(self):","def initialize(self):","def set_defaults(self):\n self.plastic = False\n self.unset_output()\n self.reward = False\n self.patmod = config.impact_modulation_default","def __init__(self):\n self.last_reward_pos = 0\n super().__init__()\n self.TERRAIN_VARIANCE = 0.0\n self.stump_spacing = 4.0\n self.stump_height = 1.0\n self.my_init({'leg_length': 35, 'walker_type': 'default'})","def _restore_default(self):\n raise NotImplementedError(\"Should have implemented this.\")","def reset(self):\n # This also resets the history.\n self.__init__(**self.init_kwargs)","def _post_init(self) -> None:\n return","def quick_set_manual_settings(self):\n self.logger.debug(\"Manual conversion settings\")\n self.quick_setting = 'manual'\n self.front_matter_format = 'none'\n self.metadata_schema = []\n if self.conversion_input == 'nsx':\n self.metadata_schema = ['title', 'ctime', 'mtime', 'tag']\n self.spaces_in_tags = False\n self.split_tags = False\n self.first_row_as_header = False\n self.first_column_as_header = False\n self.chart_image = True\n self.chart_csv = True\n self.chart_data_table = True","def _hook(self):","def navigation_hook(self):\r\n pass","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def initialize(context):","def user_init(self):\n pass","def init_game_setting(self):\r\n pass","def history(self, history):\n self._history = history","def general(self):\n self.dir = 'Stories'\n if not os.path.isdir(self.dir):\n os.mkdir(self.dir)\n\n self.langLock = Semaphore(0)\n self.setLanguage('en-US')\n self.setEyeColour('greenyellow')\n\n self.langLock.acquire()\n\n # pass Google Dialogflow parameters\n self.setDialogflowKey('nao.json')\n self.setDialogflowAgent('nao-wksstn')\n\n self.speechLock = Semaphore(0)","def __init__(self):\n self.__load_settings()\n self.__load_history()\n self.__clear_context()\n\n if self.DELETE_ALL_ON_STARTUP:\n sublime.set_timeout_async(lambda: self.delete_all_history(), 0)\n elif self.CLEANUP_ON_STARTUP:\n sublime.set_timeout_async(lambda: self.clean_history(False), 0)","def _problem_set_up(self):\n self.curr_best_reward = -np.inf\n self.curr_reward = -np.inf\n # Set up history\n self.history.curr_best_reward = []\n self.history.curr_reward = []","def test_hist_init():\n FNAME = 'xonsh-SESSIONID.json'\n FNAME += '.init'\n History(filename=FNAME, here='yup', **HIST_TEST_KWARGS)\n with LazyJSON(FNAME) as lj:\n obs = lj['here']\n assert_equal('yup', obs)\n os.remove(FNAME)","def init():","def __init__(self):\n super(APTHistoryLogTextPlugin, self).__init__()\n self._event_data = None","def loadDefaults(self):\n # (025) Merged into settings.RawSettings.\n pass","def create_default_hooks(self):\n\n self.create_hooks(\"commands\")\n self.create_hooks(\"commands_out\")\n self.create_hooks(\"hooks\")","def save_defaults(self):\n\n pass","def default_start(self, data):\n return {}","def default_start(self, data):\n return {}","def __set_defaults_to_runtime_variables(self) -> None:\n self.current_time_in_eighths = N_EIGHTHS_PER_MEASURE\n self.current_measure_durations = []\n self.past_movements = []\n self.current_motion_start_element = self.counterpoint[0]\n self.is_last_element_consonant = True","def init(self):","def init(self):","def _setup(self):","def _setup(self):","def startup():\n menuhook.register(\n \"quickpreview\",\n \"howtos\",\n quickpreview,\n menu=[\"&Scripting\", \"Python3 Development\", \"How To\"],\n text=\"Create a quick preview\",\n tooltip=\"Create a quick preview\")","def initialise(self):\r\n return","def initialise(self):\r\n return","def notes_setup(self):\n pass","def init(lang):\n pass","def __init__(self, config):\n self.config = config.config\n self.staff = []\n self.history = {}\n self.pub_auth_all = {}\n self.pub_auth_top = {}\n self.pub_inst_all = {}\n self.pub_inst_top = {}","def post_setup(self, context):\n pass"],"string":"[\n \"def history():\",\n \"def initialize(self):\\n PostProcessorInterfaceBase.initialize(self)\\n self.inputFormat = 'HistorySet'\\n self.outputFormat = 'HistorySet'\",\n \"def Modifier_History(self):\\n\\t\\tpass\",\n \"def __init__(self, history=None):\\n\\n self.__history = history if history else []\",\n \"def onRegisterHistory(self):\\n pass\",\n \"def set_defaults():\\n\\tglobal defaults\\n\\n\\tdefaults = {}\\n\\tdefaults[\\\"aliase\\\"] = {}\\n\\n\\tdefaults[\\\"nigiri\\\"] = {}\\n\\tdefaults[\\\"nigiri\\\"][\\\"wrap_input\\\"] = \\\"True\\\"\\n\\tdefaults[\\\"nigiri\\\"][\\\"command_char\\\"] = \\\"/\\\"\\n\\tdefaults[\\\"nigiri\\\"][\\\"shortcut_pattern\\\"] = \\\"meta [0-9]\\\"\\n\\tdefaults[\\\"nigiri\\\"][\\\"server_shortcuts\\\"] = \\\"true\\\"\\n\\tdefaults[\\\"nigiri\\\"][\\\"show_debug\\\"] = \\\"True\\\"\\n\\tdefaults[\\\"nigiri\\\"][\\\"logfile\\\"] = os.path.join(xdg_cache_home, \\\"sushi\\\", \\\"nigiri.txt\\\")\\n\\tdefaults[\\\"nigiri\\\"][\\\"locale_dir\\\"] = get_path(\\\"..\\\", \\\"locale\\\")\\n\\tdefaults[\\\"nigiri\\\"][\\\"plugin_dirs\\\"] = escape_join(\\\",\\\", (\\n\\t\\t\\tos.path.join(xdg_data_home, \\\"nigiri\\\", \\\"plugins\\\"),\\n\\t\\t\\tos.path.join(xdg_data_home, \\\"chirashi\\\"),\\n\\t\\t\\tget_path(\\\"plugins\\\"),\\n\\t\\t\\tget_path(\\\"..\\\", \\\"chirashi\\\")\\n\\t\\t))\\n\\n\\tdefaults[\\\"chatting\\\"] = {}\\n\\tdefaults[\\\"chatting\\\"][\\\"quit_message\\\"] = \\\"Quit.\\\"\\n\\tdefaults[\\\"chatting\\\"][\\\"part_message\\\"] = \\\"Part.\\\"\\n\\tdefaults[\\\"chatting\\\"][\\\"last_log_lines\\\"] = \\\"15\\\"\\n\\tdefaults[\\\"chatting\\\"][\\\"nick_separator\\\"] = \\\": \\\"\\n\\n\\tdefaults[\\\"colors\\\"] = {}\\n\\tdefaults[\\\"colors\\\"][\\\"messages\\\"] = \\\"gray\\\"\\n\\tdefaults[\\\"colors\\\"][\\\"messages_own\\\"] = \\\"white\\\"\\n\\tdefaults[\\\"colors\\\"][\\\"messages_highlight\\\"] = \\\"red\\\"\\n\\tdefaults[\\\"colors\\\"][\\\"actions\\\"] = \\\"gray\\\"\\n\\tdefaults[\\\"colors\\\"][\\\"actions_own\\\"] = \\\"white\\\"\\n\\tdefaults[\\\"colors\\\"][\\\"informative\\\"] = \\\"blue\\\"\\n\\n\\tdefaults[\\\"templates\\\"] = {}\\n\\t# misc\\n\\tdefaults[\\\"templates\\\"][\\\"datestring\\\"] = \\\"%H:%M\\\"\\n\\t# messages\\n\\tdefaults[\\\"templates\\\"][\\\"action\\\"] = \\\"%(time)s %(nick)s %(message)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"action_own\\\"] = \\\"%(time)s %(nick)s %(message)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"message\\\"] = \\\"%(time)s <%(prefix)s%(nick)s> %(message)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"message_own\\\"] = \\\"%(time)s <%(prefix)s%(nick)s> %(message)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"ctcp\\\"] = \\\"%(time)s -%(nick)s/%(target)s- %(message)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"ctcp_own\\\"] = \\\"%(time)s -%(nick)s/%(target)s- %(message)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"notice\\\"] = \\\"%(time)s *%(nick)s/%(target)s* %(message)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"notice_own\\\"] = \\\"%(time)s *%(nick)s/%(target)s* %(message)s\\\"\\n\\n\\t# actions\\n\\tdefaults[\\\"templates\\\"][\\\"invite\\\"] = \\\"%(time)s * %(nick)s invites %(who)s to %(channel)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"invite_own\\\"] = \\\"%(time)s * You were invited by %(nick)s to %(channel)s.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"join\\\"] = \\\"%(time)s * %(nick)s (%(host)s) has joined %(channel)s.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"join_own\\\"] = \\\"%(time)s * You have joined %(channel)s.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"kick\\\"] = \\\"%(time)s * %(who)s got kicked from %(channel)s by %(nick)s (%(reason)s)\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"kick_own\\\"] = \\\"%(time)s * You got kicked from %(channel)s by %(nick)s (%(reason)s)\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"nick\\\"] = \\\"%(time)s * %(nick)s is now known as %(new_nick)s.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"nick_own\\\"] = \\\"%(time)s * You are now known as %(new_nick)s.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"mode_list\\\"] = \\\"%(time)s * Modes for %(target)s: %(modes)s.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"mode_list_own\\\"] = \\\"%(time)s * Modes set on you: %(modes)s.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"mode\\\"] = \\\"%(time)s %(nick)s set %(mode)s%(param)s on %(target)s.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"mode_own\\\"] = \\\"%(time)s You set %(mode)s%(param)s on %(target)s.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"oper\\\"] = \\\"%(time)s * %(nick)s is now an OPER.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"oper_own\\\"] = \\\"%(time)s * You are now an OPER.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"part\\\"] = \\\"%(time)s * %(nick)s has left %(channel)s (%(reason)s).\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"part_own\\\"] = \\\"%(time)s * You have left %(channel)s (%(reason)s).\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"quit\\\"] = \\\"%(time)s * %(nick)s has quit (%(reason)s).\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"quit_own\\\"] = \\\"%(time)s * You have quit (%(reason)s).\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"topic\\\"] = \\\"%(time)s * %(nick)s has set the topic on %(channel)s to \\\\\\\"%(topic)s\\\\\\\".\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"topic_own\\\"] = \\\"%(time)s * You have set the topic on %(channel)s to \\\\\\\"%(topic)s\\\\\\\".\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"topic_anonymous\\\"] = \\\"* Topic of %(channel)s: %(topic)s\\\"\\n\\n\\t# informative\\n\\tdefaults[\\\"templates\\\"][\\\"banlist_begin\\\"] = \\\"%(time)s Begin of banlist on channel %(channel)s.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"banlist_item\\\"] = \\\">> %(who)s %(mask)s %(when)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"banlist_end\\\"] = \\\"%(time)s End of banlist. (%(channel)s)\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"cannot_join\\\"] = \\\"%(time)s Can't join channel %(channel)s: %(reason)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"list_begin\\\"] = \\\"%(time)s Begin of list.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"list_item\\\"] = \\\">> %(channel)s %(user)s %(topic)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"list_end\\\"] = \\\"%(time)s End of list.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"names_begin\\\"] = \\\"%(time)s Begin of names (%(channel)s).\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"names_item\\\"] = \\\"[ %(row)s ]\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"names_end\\\"] = \\\"%(time)s End of names.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"no_such\\\"] = \\\"%(time)s No such %(type)s: %(target)s.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"whois_begin\\\"] = \\\"%(time)s Begin of whois (%(target)s).\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"whois_item\\\"] = \\\">> %(nick)s: %(message)s\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"whois_end\\\"] = \\\"%(time)s End of whois.\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"dcc_new_incoming\\\"] = \\\"%(time)s Incoming file transfer (ID:%(id)d) from %(sender)s: \\\\\\\"%(filename)s\\\\\\\" (%(size)d).\\\"\\n\\tdefaults[\\\"templates\\\"][\\\"dcc_file_auto_accept\\\"] = \\\"%(time)s Auto accepted file transfer from %(sender)s: \\\\\\\"%(filename)s\\\\\\\" (%(size)d).\\\"\\n\\n\\t# Add default sections to config parser\\n\\t# so setting is easier\\n\\tfor section in defaults.keys():\\n\\t\\ttry:\\n\\t\\t\\tconfig_parser.add_section(section)\\n\\t\\texcept ConfigParser.DuplicateSectionError:\\n\\t\\t\\tcontinue\\n\\n\\t# sections defined below are not added to the configParser and\\n\\t# can't be set by the set method (will raise NoSectionError)\\n\\tpass\",\n \"def setup_hooks(self):\\n pass\",\n \"def defaults():\\n return {}\",\n \"def historical():\\n\\n return {\\n 'page': 'historical',\\n }\",\n \"def tweaks(self) -> None:\\n pass\",\n \"def set_app_defaults(self):\\n self.curve_render = 0\\n self.image_render = 0\\n self.image_height = 200\\n self.image_data = []\\n self.auto_scale = True\\n\\n self.create_actions()\\n self.setup_signals()\\n self.reset_graph()\\n\\n self.fps = utils.SimpleFPS()\\n\\n # Click the live button\\n self.ui.actionContinue_Live_Updates.trigger()\",\n \"def defaults() -> dict:\\n pass\",\n \"def history():\\n return apology(\\\"TODO\\\")\",\n \"def history():\\n return apology(\\\"TODO\\\")\",\n \"def history():\\n return apology(\\\"TODO\\\")\",\n \"def autodefaults (self):\\r\\n\\r\\n self.defaults_from_notes(identifying_key=EMPTYCHAR,\\r\\n mark=EQUAL,\\r\\n obj=self.default_dict['commands'],\\r\\n entrytext=COMMANDMACROSCRIPT)\",\n \"def default_config():\\n config = Config()\\n config.TerminalInteractiveShell.colors = 'NoColor'\\n config.TerminalTerminalInteractiveShell.term_title = False,\\n config.TerminalInteractiveShell.autocall = 0\\n f = tempfile.NamedTemporaryFile(suffix=u'test_hist.sqlite', delete=False)\\n config.HistoryManager.hist_file = Path(f.name)\\n f.close()\\n config.HistoryManager.db_cache_size = 10000\\n return config\",\n \"def __init__( settings={} ):\",\n \"def initialise(self):\",\n \"def __init__(self, environment):\\n super(HistoricalExtension, self).__init__(environment)\\n environment.filters['titlecase'] = titlecase\",\n \"def initDefaults(self):\\n return _libsbml.Event_initDefaults(self)\",\n \"def add_earlydefault_settings(self):\\n self.add_default_settings_config()\\n self.add_default_settings_aliases()\",\n \"def default_forage_args():\\n\\n forage_args = {\\n 'prop_legume': 0.0,\\n 'steepness': 1.,\\n 'DOY': 1,\\n 'start_year': 2016,\\n 'start_month': 1,\\n 'num_months': 24,\\n 'mgmt_threshold': 0.01,\\n 'century_dir': 'C:/Users/ginge/Dropbox/NatCap_backup/Forage_model/CENTURY4.6/Century46_PC_Jan-2014',\\n 'template_level': 'GH',\\n 'fix_file': 'drygfix.100',\\n 'user_define_protein': 1,\\n 'user_define_digestibility': 0,\\n 'herbivore_csv': r\\\"C:/Users/ginge/Dropbox/NatCap_backup/Mongolia/model_inputs/cashmere_goats.csv\\\",\\n 'grass_csv': r\\\"C:/Users/ginge/Dropbox/NatCap_backup/Mongolia/model_inputs/grass.csv\\\",\\n 'restart_monthly': 0,\\n }\\n return forage_args\",\n \"def post_init(self):\\n\\t\\tpass\",\n \"def _post_hooks(self):\",\n \"def presets (self):\\n assert False, \\\"To be implemented by child\\\"\",\n \"def setup_default_terms(self):\\n # Setting config with pattern -\\n # default_dict[\\\"json config key\\\"] = (\\\"Default Value\\\", \\\"Ask User\\\", \\\"Value Type\\\")\\n\\n self.default_terms[Keys.first_run] = (Values.first_run, False, None)\\n self.default_terms[Keys.nas_mount] = (Values.nas_mount_path, True, str)\\n self.default_terms[Keys.secs_between_checks] = (Values.check_time, True, int)\\n self.default_terms[Keys.redmine_api_key] = ('none', False, str)\",\n \"def set_default_parameters(self):\\n super().set_default_parameters()\",\n \"def _post_init(self):\\n pass\",\n \"def _set_defaults(self):\\n self.api_protocol = 'https'\\n self.api_host = 'nhl-score-api.herokuapp.com'\\n self.current_score = 0\\n self.sleep_seconds = 30 # Time to sleep after calling the API\\n self.desired_game_state = 'LIVE' # Desired game state is LIVE\",\n \"def defaults(self):\\n self.lib.iperf_defaults(self._test)\",\n \"def init_tab(self):\",\n \"def without_defaults(self):\\n ...\",\n \"def initialize_default(self):\\n self.initialize_navigation()\\n self.initialize_viewport()\",\n \"def initialize(self, src_sentence):\\n self.history = ['<s>'] if self.history_len > 0 else []\",\n \"def __init__(self):\\n self.analytics = Analytics()\\n self.menu_options = {\\n \\\"1\\\": self.add_habit,\\n \\\"2\\\": self.check_off,\\n \\\"3\\\": self.delete_habit,\\n \\\"4\\\": self.see_habit,\\n \\\"5\\\": self.show_all_habits,\\n \\\"6\\\": self.habits_same_periodicity,\\n \\\"7\\\": self.habit_longest_streak,\\n \\\"0\\\": self.exit,\\n\\n }\",\n \"def initDefaults(self):\\n return _libsbml.Reaction_initDefaults(self)\",\n \"def initialize_options(self):\",\n \"def defaults(self):\\n\\n return None\",\n \"def defaults(self):\\n\\n return None\",\n \"def _initialize_defaults(self):\\n for key, value in defaults.items():\\n if key not in self.source_params:\\n self.source_params[key] = value\",\n \"def _initialize_defaults(self):\\n for key, value in defaults.items():\\n if key not in self.source_params:\\n self.source_params[key] = value\",\n \"def make_initial_state(self):\\n pass\",\n \"def add_settings_early(self):\\n pass\",\n \"def initialize(self):\",\n \"def initialize(self):\",\n \"def initialize(self):\",\n \"def initialize(self):\",\n \"def set_defaults(self):\\n self.plastic = False\\n self.unset_output()\\n self.reward = False\\n self.patmod = config.impact_modulation_default\",\n \"def __init__(self):\\n self.last_reward_pos = 0\\n super().__init__()\\n self.TERRAIN_VARIANCE = 0.0\\n self.stump_spacing = 4.0\\n self.stump_height = 1.0\\n self.my_init({'leg_length': 35, 'walker_type': 'default'})\",\n \"def _restore_default(self):\\n raise NotImplementedError(\\\"Should have implemented this.\\\")\",\n \"def reset(self):\\n # This also resets the history.\\n self.__init__(**self.init_kwargs)\",\n \"def _post_init(self) -> None:\\n return\",\n \"def quick_set_manual_settings(self):\\n self.logger.debug(\\\"Manual conversion settings\\\")\\n self.quick_setting = 'manual'\\n self.front_matter_format = 'none'\\n self.metadata_schema = []\\n if self.conversion_input == 'nsx':\\n self.metadata_schema = ['title', 'ctime', 'mtime', 'tag']\\n self.spaces_in_tags = False\\n self.split_tags = False\\n self.first_row_as_header = False\\n self.first_column_as_header = False\\n self.chart_image = True\\n self.chart_csv = True\\n self.chart_data_table = True\",\n \"def _hook(self):\",\n \"def navigation_hook(self):\\r\\n pass\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def initialize(context):\",\n \"def user_init(self):\\n pass\",\n \"def init_game_setting(self):\\r\\n pass\",\n \"def history(self, history):\\n self._history = history\",\n \"def general(self):\\n self.dir = 'Stories'\\n if not os.path.isdir(self.dir):\\n os.mkdir(self.dir)\\n\\n self.langLock = Semaphore(0)\\n self.setLanguage('en-US')\\n self.setEyeColour('greenyellow')\\n\\n self.langLock.acquire()\\n\\n # pass Google Dialogflow parameters\\n self.setDialogflowKey('nao.json')\\n self.setDialogflowAgent('nao-wksstn')\\n\\n self.speechLock = Semaphore(0)\",\n \"def __init__(self):\\n self.__load_settings()\\n self.__load_history()\\n self.__clear_context()\\n\\n if self.DELETE_ALL_ON_STARTUP:\\n sublime.set_timeout_async(lambda: self.delete_all_history(), 0)\\n elif self.CLEANUP_ON_STARTUP:\\n sublime.set_timeout_async(lambda: self.clean_history(False), 0)\",\n \"def _problem_set_up(self):\\n self.curr_best_reward = -np.inf\\n self.curr_reward = -np.inf\\n # Set up history\\n self.history.curr_best_reward = []\\n self.history.curr_reward = []\",\n \"def test_hist_init():\\n FNAME = 'xonsh-SESSIONID.json'\\n FNAME += '.init'\\n History(filename=FNAME, here='yup', **HIST_TEST_KWARGS)\\n with LazyJSON(FNAME) as lj:\\n obs = lj['here']\\n assert_equal('yup', obs)\\n os.remove(FNAME)\",\n \"def init():\",\n \"def __init__(self):\\n super(APTHistoryLogTextPlugin, self).__init__()\\n self._event_data = None\",\n \"def loadDefaults(self):\\n # (025) Merged into settings.RawSettings.\\n pass\",\n \"def create_default_hooks(self):\\n\\n self.create_hooks(\\\"commands\\\")\\n self.create_hooks(\\\"commands_out\\\")\\n self.create_hooks(\\\"hooks\\\")\",\n \"def save_defaults(self):\\n\\n pass\",\n \"def default_start(self, data):\\n return {}\",\n \"def default_start(self, data):\\n return {}\",\n \"def __set_defaults_to_runtime_variables(self) -> None:\\n self.current_time_in_eighths = N_EIGHTHS_PER_MEASURE\\n self.current_measure_durations = []\\n self.past_movements = []\\n self.current_motion_start_element = self.counterpoint[0]\\n self.is_last_element_consonant = True\",\n \"def init(self):\",\n \"def init(self):\",\n \"def _setup(self):\",\n \"def _setup(self):\",\n \"def startup():\\n menuhook.register(\\n \\\"quickpreview\\\",\\n \\\"howtos\\\",\\n quickpreview,\\n menu=[\\\"&Scripting\\\", \\\"Python3 Development\\\", \\\"How To\\\"],\\n text=\\\"Create a quick preview\\\",\\n tooltip=\\\"Create a quick preview\\\")\",\n \"def initialise(self):\\r\\n return\",\n \"def initialise(self):\\r\\n return\",\n \"def notes_setup(self):\\n pass\",\n \"def init(lang):\\n pass\",\n \"def __init__(self, config):\\n self.config = config.config\\n self.staff = []\\n self.history = {}\\n self.pub_auth_all = {}\\n self.pub_auth_top = {}\\n self.pub_inst_all = {}\\n self.pub_inst_top = {}\",\n \"def post_setup(self, context):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61749583","0.61044705","0.5923172","0.56847167","0.5676686","0.56484216","0.56409806","0.5607612","0.5604941","0.5588264","0.55781215","0.5554692","0.55457157","0.55457157","0.55457157","0.55185014","0.550989","0.5501374","0.5485809","0.5464516","0.5439006","0.54371053","0.5417329","0.54038584","0.54007804","0.53926885","0.5391507","0.5383697","0.5378607","0.53646284","0.5358165","0.5351959","0.5345799","0.5335719","0.5323103","0.5316181","0.5307506","0.52990794","0.5267731","0.5267731","0.5258845","0.5258845","0.5251816","0.5246731","0.5244931","0.5244931","0.5244931","0.5244931","0.5238551","0.5232229","0.5227036","0.52166486","0.5214728","0.5209886","0.5208528","0.51881576","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51877624","0.51837325","0.5175456","0.51645076","0.5164357","0.51631385","0.5158922","0.51557857","0.5155698","0.5151827","0.51510334","0.5146235","0.5145782","0.51390415","0.51390415","0.5126872","0.5122385","0.5122385","0.51187235","0.51187235","0.51178366","0.51118356","0.51118356","0.51105917","0.51081437","0.50912327","0.50905323"],"string":"[\n \"0.61749583\",\n \"0.61044705\",\n \"0.5923172\",\n \"0.56847167\",\n \"0.5676686\",\n \"0.56484216\",\n \"0.56409806\",\n \"0.5607612\",\n \"0.5604941\",\n \"0.5588264\",\n \"0.55781215\",\n \"0.5554692\",\n \"0.55457157\",\n \"0.55457157\",\n \"0.55457157\",\n \"0.55185014\",\n \"0.550989\",\n \"0.5501374\",\n \"0.5485809\",\n \"0.5464516\",\n \"0.5439006\",\n \"0.54371053\",\n \"0.5417329\",\n \"0.54038584\",\n \"0.54007804\",\n \"0.53926885\",\n \"0.5391507\",\n \"0.5383697\",\n \"0.5378607\",\n \"0.53646284\",\n \"0.5358165\",\n \"0.5351959\",\n \"0.5345799\",\n \"0.5335719\",\n \"0.5323103\",\n \"0.5316181\",\n \"0.5307506\",\n \"0.52990794\",\n \"0.5267731\",\n \"0.5267731\",\n \"0.5258845\",\n \"0.5258845\",\n \"0.5251816\",\n \"0.5246731\",\n \"0.5244931\",\n \"0.5244931\",\n \"0.5244931\",\n \"0.5244931\",\n \"0.5238551\",\n \"0.5232229\",\n \"0.5227036\",\n \"0.52166486\",\n \"0.5214728\",\n \"0.5209886\",\n \"0.5208528\",\n \"0.51881576\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51877624\",\n \"0.51837325\",\n \"0.5175456\",\n \"0.51645076\",\n \"0.5164357\",\n \"0.51631385\",\n \"0.5158922\",\n \"0.51557857\",\n \"0.5155698\",\n \"0.5151827\",\n \"0.51510334\",\n \"0.5146235\",\n \"0.5145782\",\n \"0.51390415\",\n \"0.51390415\",\n \"0.5126872\",\n \"0.5122385\",\n \"0.5122385\",\n \"0.51187235\",\n \"0.51187235\",\n \"0.51178366\",\n \"0.51118356\",\n \"0.51118356\",\n \"0.51105917\",\n \"0.51081437\",\n \"0.50912327\",\n \"0.50905323\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":21297,"cells":{"query":{"kind":"string","value":"Plot stress contours by extracting nearest stresses resolved on a point for 4 vertices per cell (tetrahedra)"},"document":{"kind":"string","value":"def contour_stresses(matFile, infoFile, ax=0, esize=100):\n # NOTE: some bug to work out here\n vertices, cells, moduli, stress, strain = pu.load_h5_material(matFile, infoFile)\n\n # NOTE: could get list of all elements that have a vertex on a particular surface\n # or get list of all cells that have a centroid within a certain distane of the surface\n centroids = 0.25 * (vertices[cells[:,0]] +\n vertices[cells[:,1]] +\n vertices[cells[:,2]] +\n vertices[cells[:,3]] )\n\n # get list of cell centroids that are within a certain distance to x-plane\n ind = (np.abs(centroids[:,0]) <= esize) # X=0 plane\n\n # yz location of centroids\n a = centroids[ind,1] / 1e3 #y-axis points [km]\n b = centroids[ind,2] / 1e3 #z-axis points\n\n pointStresses = stress[ind] / 1e6 #report in MPa\n\n sigma_mean = []\n tau_max = []\n for tensor in pointStresses:\n #sm, tm = pu.stress_analysis(tensor)\n sm, tm = pt.util.stress_analysis(tensor)\n sigma_mean.append(sm)\n tau_max.append(tm)\n sigma_mean = np.array(sigma_mean)\n tau_max = np.array(tau_max)\n\n #z = sigma_mean\n z = tau_max\n\n # Figure after 7.7 in segall 2010\n # NOTE: set axis is equal?\n #f, (ax1, ax2) = plt.subplots(1, 2, sharex=True, sharey=True) #not sure about this\n plt.figure()\n plt.gca().set_aspect('equal')\n\n # contour\n #A,B = np.meshgrid(a,b)\n ai = np.linspace(a.min(), a.max(), a.size)\n bi = np.linspace(b.min(), b.max(), b.size)\n zi = griddata(a,b,z,ai,bi)\n plt.pcolormesh(ai,bi,zi)\n\n plt.scatter(a,b,c=sigma_mean) #show actual points\n cb = plt.colorbar()\n cb.set_label('MPa')\n\n plt.xlabel('Y-axis')\n plt.ylabel('Z-axis')\n plt.title('Max Shear Stress Contours on X=0 plane')"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def highlight_cells_on_tsne(tsne, cells, fig=None, ax=None):\n fig, ax = get_fig(fig=fig, ax=ax)\n ax.scatter(tsne['x'], tsne['y'], s=3, color='lightgrey')\n ax.scatter(tsne.loc[cells, 'x'], tsne.loc[cells, 'y'], s=3, color='b')\n ax.set_axis_off()\n return fig, ax","def _uniform_refine_tetrahedra(mesh):\n\n # get current cells and edges\n cells = mesh.cells\n edges = mesh.edges\n\n assert np.size(cells, axis=1) == 4\n\n # get number of current nodes\n n_nodes = np.size(mesh.nodes, axis=0)\n \n # first we create additional nodes as midpoints of the current edges\n midpoints = 0.5 * mesh.nodes.take(edges - 1, axis=0).sum(axis=1)\n\n # add them to the existing mesh nodes\n new_nodes = np.vstack([mesh.nodes, midpoints])\n \n # then we generate the indices of the newly created nodes\n #\n # their indices start at the current number of nodes (`n_nodes`) + 1\n # and end after additional `n_edges` nodes\n n_edges = np.size(edges, axis=0)\n new_node_indices = np.arange(n_nodes + 1, n_nodes + n_edges + 1, dtype=int)\n\n # refine elements\n #\n # for every element we need the indices of the edges at which the\n # corresponding new nodes are created\n indices_3_1 = mesh.topology.get_connectivity(3, 1, return_indices=True) - 1\n \n # next we augment the indices that define each element as if\n # they were defined by 10 nodes (including those of the edge midpoints)\n cells_ = np.hstack([cells, new_node_indices.take(indices_3_1, axis=0)])\n \n # now we can generate the eight new elements for each existing one\n new_cells_1 = np.vstack([cells_[:,0], cells_[:,4], cells_[:,5], cells_[:,6]]).T\n new_cells_2 = np.vstack([cells_[:,1], cells_[:,4], cells_[:,7], cells_[:,8]]).T\n new_cells_3 = np.vstack([cells_[:,2], cells_[:,5], cells_[:,7], cells_[:,9]]).T\n new_cells_4 = np.vstack([cells_[:,3], cells_[:,6], cells_[:,8], cells_[:,9]]).T\n new_cells_5 = np.vstack([cells_[:,4], cells_[:,5], cells_[:,6], cells_[:,9]]).T\n new_cells_6 = np.vstack([cells_[:,4], cells_[:,5], cells_[:,7], cells_[:,9]]).T\n new_cells_7 = np.vstack([cells_[:,4], cells_[:,6], cells_[:,8], cells_[:,9]]).T\n new_cells_8 = np.vstack([cells_[:,4], cells_[:,7], cells_[:,8], cells_[:,9]]).T\n \n new_cells = np.vstack([new_cells_1, new_cells_2, new_cells_3, new_cells_4,\n new_cells_5, new_cells_6, new_cells_7, new_cells_8])\n\n return new_nodes, new_cells","def visualize_routes(self):\n visualize_tsp.plotTSP([self.best_solution], self.coords)","def plotMesh(verts,tris):\n x = verts[:,0]\n y = verts[:,1]\n\n plt.figure()\n plt.gca().set_aspect('equal')\n plt.triplot(x, y, tris, 'k-')\n plt.title('Unstructured Mesh')\n plt.xlabel('distance (m)')\n plt.ylabel('distance (m)')","def watershed_segment(M,xM=None,yM=None):\n\n if xM != None and yM != None:\n sel = np.ones((int(ceil(23.9*xM)),int(ceil(23.9*yM)))) # for opening\n sel2 = np.ones((int(ceil(127.2*xM)),int(ceil(127.2*yM)))) # for local thresholding\n sel3 = np.ones((int(ceil(11.9*xM)),int(ceil(11.9*yM)))) # for erosion\n ma,mi =(44245.21*xM*yM),(316.037*xM*yM) \n else:\n selD = np.array([int(M.shape[0]*.012),int(M.shape[1]*.012)])\n selD = np.where(selD!=0,selD,1)\n \n sel2D = np.array([int(M.shape[0]*.12),int(M.shape[1]*.12)])\n sel2D = np.where(sel2D!=0,sel2D,1)\n\n sel3D = np.array([int(M.shape[0]*.01),int(M.shape[1]*.01)])\n sel3D = np.where(sel3D!=0,sel3D,1)\n\n\n sel = np.ones(selD) # for opening\n sel2 = np.ones(sel2D) # for local thresholding\n sel3 = np.ones(sel3D) # for erosion\n ma,mi = (M.shape[0]*M.shape[1]*.0075),(M.shape[0]*M.shape[1]*.0003)\n\n # get a few points in the center of each blob\n \n # threshold\n bw = ((M>=ndi.percentile_filter(M,80,footprint=sel2)))\n #& (M>=stats.scoreatpercentile(M.flatten(),80)))\n\n # open and erode\n blobs = snm.binary_opening(bw,structure=sel)\n blobs = snm.binary_erosion(blobs,structure=sel3,iterations=2)\n \n # label\n labels,_ = ndi.label(blobs)\n labels[labels > 0] += 1\n labels[0,0] = 1\n\n # rescale and cast to int16, then use watershed\n #M2 = rescaled(M,0,65000).astype(np.uint16)\n #newlabels = ndi.watershed_ift(M2,labels)\n newlabels = labels\n \n # get rid of groups unless they have the right number of pixels\n\n counts = np.bincount(newlabels.flatten())\n old2new = np.arange(len(counts)) \n old2new[(counts < int(mi)) | (counts > int(ma))] = 0\n newlabels = old2new[newlabels]\n\n return newlabels","def plot_simplex(self, num_contours: int = 100, num_sub_div: int = 8,\n color_map: str = 'viridis', border: bool = True, ax: Axes = None) -> Axes:\n\n corners = array([[0, 0], [1, 0], [0.5, 0.75 ** 0.5]])\n triangle = Triangulation(corners[:, 0], corners[:, 1])\n mid_points = [\n (corners[(i + 1) % 3] + corners[(i + 2) % 3]) / 2\n for i in range(3)\n ]\n\n def to_barycentric(cartesian):\n \"\"\"\n Converts 2D Cartesian to barycentric coordinates.\n\n :param cartesian: A length-2 sequence containing the x and y value.\n \"\"\"\n s = [(corners[i] - mid_points[i]).dot(cartesian - mid_points[i]) / 0.75\n for i in range(3)]\n s_clipped = clip(a=s, a_min=0, a_max=1)\n return s_clipped / norm(s_clipped, ord=1)\n\n refiner = UniformTriRefiner(triangle)\n tri_mesh = refiner.refine_triangulation(subdiv=num_sub_div)\n f = [self._method(to_barycentric(xy))\n for xy in zip(tri_mesh.x, tri_mesh.y)]\n ax = ax or new_axes()\n ax.tricontourf(tri_mesh, f, num_contours, cmap=color_map)\n ax.set_aspect('equal')\n ax.set_xlim(0, 1)\n ax.set_ylim(0, 0.75 ** 0.5)\n ax.set_axis_off()\n if border:\n ax.triplot(triangle, linewidth=1)\n\n return ax","def test_plot_cspad(geometry, fname_data, amp_range=(0,0.5)):\n #rad1 = 93\n #rad2 = 146\n rad1 = 655\n rad2 = 670\n\n # get pixel coordinate index arrays:\n xyc = xc, yc = 500, 500# None\n\n #rows, cols = geometry.get_pixel_coord_indexes(xy0_off_pix=None)\n rows, cols = geometry.get_pixel_coord_indexes(xy0_off_pix=xyc, do_tilt=True)\n\n ixo, iyo = geometry.point_coord_indexes(xy0_off_pix=xyc, do_tilt=True)\n logger.info('Detector origin indexes ixo:%d iyo:%d' % (ixo, iyo))\n\n root, ext = os.path.splitext(fname_data)\n arr = np.load(fname_data) if ext == '.npy' else np.loadtxt(fname_data, dtype=np.float)\n arr.shape= (4,8,185,388)\n\n logger.info('shapes rows: %s cols: %s weight: %s' % (str(rows.shape), str(cols.shape), str(arr.shape)))\n\n arr.shape = rows.shape\n img = img_from_pixel_arrays(rows, cols, W=arr)\n\n rcc_ring = (iyo, ixo)\n axim = gg.plotImageLarge(img,amp_range=amp_range)\n gg.drawCircle(axim, rcc_ring, rad1, linewidth=1, color='w', fill=False)\n gg.drawCircle(axim, rcc_ring, rad2, linewidth=1, color='w', fill=False)\n gg.drawCenter(axim, rcc_ring, rad1, linewidth=1, color='w')\n gg.move(500,10)\n gg.show()","def hexapodZernikeLinearModel_hexapodcoordinate():\n Tfile='/home/jghao/research/decamFocus/psf_withseeing/finerGrid_coeff_matrix/zernike_coeff_finerGrid_training.cp'\n b=p.load(open(Tfile))\n nobs = len(b)\n x = b[:,0]\n y = b[:,1]\n z = b[:,2]\n theta = b[:,3]\n phi = b[:,4]\n fwhm = b[:,5]\n e1 = b[:,6]\n e2 = b[:,7]\n thetax = theta*np.cos(np.deg2rad(phi))\n thetay = theta*np.sin(np.deg2rad(phi))\n xh = x*1000 # convert to hexapod coordinate\n yh = -y*1000\n zh = -z*1000\n xtilth = - thetay\n ytilth = - thetax\n\n M22realTrefoil2 = b[:,37] # for x decenter\n M22imagTrefoil1 = b[:,54] \n M22TrefoilXshift = 0.5*(M22realTrefoil2+M22imagTrefoil1)\n\n M22realTrefoil1 = b[:,34] # for y decenter\n M22imagTrefoil2 = b[:,57] \n M22TrefoilYshift = 0.5*(M22realTrefoil1 - M22imagTrefoil2)\n\n M20defocus = b[:,12] # for defocus\n\n M22realComa2 = b[:,36] # for x-tilt\n M22imagComa1 = b[:,55]\n M22ComaXtilt = 0.5*(M22realComa2+M22imagComa1)\n\n M22realComa1 = b[:,35] # for y-tilt\n M22imagComa2 = b[:,56]\n M22ComaYtilt = 0.5*(M22realComa1 - M22imagComa2)\n \n pl.figure(figsize=(21,12))\n pl.subplot(2,3,1)\n t=bp.bin_scatter(M22TrefoilXshift,xh,nbins=20,fmt='bo',scatter=True)\n res = linefit(M22TrefoilXshift,xh)\n pl.plot(M22TrefoilXshift,M22TrefoilXshift*res[1]+res[0],'r,')\n pl.ylabel('x-decenter [micron]')\n pl.xlabel('(M22realTrefoil2+M22imagTrefoil1)/2')\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\n pl.grid()\n pl.subplot(2,3,2)\n t=bp.bin_scatter(M22TrefoilYshift,yh,nbins=20,fmt='bo',scatter=True)\n res = linefit(M22TrefoilYshift,yh)\n pl.plot(M22TrefoilYshift,M22TrefoilYshift*res[1]+res[0],'r,')\n pl.ylabel('y-decenter [micron]')\n pl.xlabel('(M22realTrefoil1 - M22imagTrefoil2)/2')\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\n pl.grid()\n pl.subplot(2,3,3)\n t=bp.bin_scatter(M20defocus,zh,nbins=20,fmt='bo',scatter=True)\n res = linefit(M20defocus,zh)\n pl.plot(M20defocus,M20defocus*res[1]+res[0],'r,')\n pl.ylabel('z-defocus [micron]')\n pl.xlabel('M20defocus')\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\n pl.grid()\n pl.subplot(2,3,4)\n t=bp.bin_scatter(M22ComaXtilt,ytilth,nbins=20,fmt='bo',scatter=True)\n res = linefit(M22ComaXtilt,ytilth)\n pl.plot(M22ComaXtilt,M22ComaXtilt*res[1]+res[0],'r,')\n pl.ylabel('y-tilt [arcsec]') # in hexapod coordiate, xtilt and y tilt is switched from the CRAY coordiante\n pl.xlabel('(M22realComa2+M22imagComa1)/2')\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\n pl.grid()\n pl.subplot(2,3,5)\n t=bp.bin_scatter(M22ComaYtilt,xtilth,nbins=20,fmt='bo',scatter=True)\n res = linefit(M22ComaYtilt,xtilth)\n pl.plot(M22ComaYtilt,M22ComaYtilt*res[1]+res[0],'r,')\n pl.ylabel('x-tilt [arcsec]')\n pl.xlabel('(M22realComa1 - M22imagComa2)/2')\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\n pl.grid()\n pl.savefig('linearModel_hexapod_coordinate.png')\n pl.close()","def quadrants (ax, T, neq, color='k', zorder=1):\n \n da = np.pi/180. # \n R = 6370. # Mean Earth Radius in km\n\n for n in range(len(T['lon'])):\n x = T['lon'][n]\n y = T['lat'][n]\n\n if T[neq][n] is not None:\n\n #Convert Quadrant values to km\n ne = T[neq][n][0]*1.852\n se = T[neq][n][1]*1.852\n sw = T[neq][n][2]*1.852\n nw = T[neq][n][3]*1.852\n\n label = neq\n if neq == 'rmax':\n label = str (int(T['vmax'][n])) \n \n xiso = []\n yiso = []\n for a in np.arange(0., 0.5*np.pi, da):\n \n dx = 180./(np.pi*R)*ne/np.cos( np.radians(y))\n dy = 180./(np.pi*R)*ne\n xiso.append( x + dx*np.cos(a) )\n yiso.append( y + dy*np.sin(a) )\n \n ax.text(x + dx + 0.05*dx, y, label, color=color, fontsize=7)\n \n for a in np.arange(0.5*np.pi, np.pi, da):\n dx = 180./(np.pi*R)*nw/np.cos( np.radians(y))\n dy = 180./(np.pi*R)*nw\n xiso.append( x + dx*np.cos(a) )\n yiso.append( y + dy*np.sin(a) ) \n\n for a in np.arange(np.pi, 1.5*np.pi, da):\n dx = 180./(np.pi*R)*sw/np.cos( np.radians(y))\n dy = 180./(np.pi*R)*sw\n xiso.append( x + dx*np.cos(a) )\n yiso.append( y + dy*np.sin(a) ) \n\n for a in np.arange(1.5*np.pi, 2.*np.pi, da):\n dx = 180./(np.pi*R)*se/np.cos( np.radians(y))\n dy = 180./(np.pi*R)*se\n xiso.append( x + dx*np.cos(a) )\n yiso.append( y + dy*np.sin(a) ) \n \n ax.plot(xiso, yiso, color=color, zorder=zorder)\n ax.plot((xiso[0],xiso[-1]), (yiso[0],yiso[-1]), color=color, zorder=zorder)\n\n return ax","def plot_neighbors(data, indices, ax):\n\n indices = [item.tolist() for item in indices]\n counter_removed = 0\n\n for j in range(data.shape[0]):\n def remove_repetitions(indices, j, counter_removed):\n for item in indices[j]:\n try:\n indices[item].remove(j)\n counter_removed = counter_removed + 1\n except ValueError:\n pass\n # print(\"removed\", counter_removed)\n return counter_removed, indices\n\n counter_removed, indices = remove_repetitions(indices, j, counter_removed)\n origin = data[j, :]\n targets = [data[i, :] for i in indices[j]]\n\n for target in targets:\n x = [origin[0], target[0]]\n y = [origin[1], target[1]]\n z = [origin[2], target[2]]\n ax.plot(x, y, z, 'ro-', linewidth='1', markersize=1)","def plot_contour(xynodes, stress, mytitle='contour plot'):\n\n stress = np.array(stress)\n fig2 = plt.figure()\n\n fig2 = plt.figure()\n sigma1 = stress[:, 0]\n sigma2 = stress[:, 1]\n sigma12 = stress[:, 2]\n vonmises = np.sqrt(sigma1 ** 2 - sigma1 * sigma2 + sigma2 ** 2 + 3 * sigma12 ** 2)\n prins1 = (sigma1 + sigma2) / 2 + np.sqrt(((sigma1 - sigma2) / 2) ** 2 + sigma12 ** 2)\n prins2 = (sigma1 + sigma2) / 2 - np.sqrt(((sigma1 - sigma2) / 2) ** 2 + sigma12 ** 2)\n\n sigma1norm = sigma1 / np.max(np.abs(sigma1))\n sigma2norm = sigma2 / np.max(np.abs(sigma2))\n sigma12norm = sigma12 / np.max(np.abs(sigma12))\n vonmisesnorm = vonmises / np.max(np.abs(vonmises))\n prins1norm = prins1 / np.max(np.abs(prins1))\n prins2norm = prins2 / np.max(np.abs(prins2))\n\n pltsigma = sigma1norm\n for i, xy in enumerate(xynodes):\n x = [k[0] for k in xy]\n y = [k[1] for k in xy]\n # red for tension, blue for compression\n pltcolor = 'r' if pltsigma[i] >= 0 else 'b'\n sigmavalnorm = pltsigma[i] if pltsigma[i] > 0 else pltsigma[i] * -1\n plt.fill(x, y, pltcolor, alpha=sigmavalnorm)\n plt.plot(x, y, 'k')\n\n title(mytitle)\n tmpx = [x[0] for k in xynodes for x in k]\n tmpy = [x[1] for k in xynodes for x in k]\n plt.xlim([np.min(tmpx) - 3, np.max(tmpx) + 3])\n plt.ylim([np.min(tmpy) - 3, np.max(tmpy) + 3])\n plt.show()","def voronoi_sub_mask_1d_index_to_pixeliztion_1d_index_from_grids_and_geometry(\n grid,\n mask_1d_index_to_nearest_pixelization_1d_index,\n sub_mask_1d_index_to_mask_1d_index,\n pixel_centres,\n pixel_neighbors,\n pixel_neighbors_size,\n):\n\n sub_mask_1d_index_to_pixeliztion_1d_index = np.zeros((grid.shape[0]))\n\n for sub_mask_1d_index in range(grid.shape[0]):\n\n nearest_pixelization_1d_index = mask_1d_index_to_nearest_pixelization_1d_index[\n sub_mask_1d_index_to_mask_1d_index[sub_mask_1d_index]\n ]\n\n while True:\n\n nearest_pixelization_pixel_center = pixel_centres[\n nearest_pixelization_1d_index\n ]\n\n sub_pixel_to_nearest_pixelization_distance = (\n (grid[sub_mask_1d_index, 0] - nearest_pixelization_pixel_center[0]) ** 2\n + (grid[sub_mask_1d_index, 1] - nearest_pixelization_pixel_center[1])\n ** 2\n )\n\n closest_separation_from_pixelization_to_neighbor = 1.0e8\n\n for neighbor_pixelization_1d_index in range(\n pixel_neighbors_size[nearest_pixelization_1d_index]\n ):\n\n neighbor = pixel_neighbors[\n nearest_pixelization_1d_index, neighbor_pixelization_1d_index\n ]\n\n separation_from_neighbor = (\n grid[sub_mask_1d_index, 0] - pixel_centres[neighbor, 0]\n ) ** 2 + (grid[sub_mask_1d_index, 1] - pixel_centres[neighbor, 1]) ** 2\n\n if (\n separation_from_neighbor\n < closest_separation_from_pixelization_to_neighbor\n ):\n closest_separation_from_pixelization_to_neighbor = (\n separation_from_neighbor\n )\n closest_neighbor_pixelization_1d_index = (\n neighbor_pixelization_1d_index\n )\n\n neighboring_pixelization_1d_index = pixel_neighbors[\n nearest_pixelization_1d_index, closest_neighbor_pixelization_1d_index\n ]\n sub_pixel_to_neighboring_pixelization_distance = (\n closest_separation_from_pixelization_to_neighbor\n )\n\n if (\n sub_pixel_to_nearest_pixelization_distance\n <= sub_pixel_to_neighboring_pixelization_distance\n ):\n sub_mask_1d_index_to_pixeliztion_1d_index[\n sub_mask_1d_index\n ] = nearest_pixelization_1d_index\n break\n else:\n nearest_pixelization_1d_index = neighboring_pixelization_1d_index\n\n return sub_mask_1d_index_to_pixeliztion_1d_index","def trapezoid_decomposition_pl(polygons, bounds):\n polygons = Polygons(polygons)\n # print(bounds)\n point_locator = PointLocator(bounds)\n for edge in polygons.random_edge_sampler():\n point_locator.add_line(edge)\n return point_locator","def touching_hexagons(point: Point):\n # get all 6 touching points\n if point.y % 2 == 0:\n return [Point(point.x + 1, point.y), Point(point.x, point.y - 1), Point(point.x - 1, point.y - 1),\n Point(point.x - 1, point.y), Point(point.x - 1, point.y + 1), Point(point.x, point.y + 1)]\n else:\n return [Point(point.x + 1, point.y), Point(point.x + 1, point.y - 1), Point(point.x, point.y - 1),\n Point(point.x - 1, point.y), Point(point.x, point.y + 1), Point(point.x + 1, point.y + 1)]","def plotpy (tvec=tvec, ind=ind, synclines=True):\n plt.scatter(tvec,ind) \n if synclines:\n for spkt in np.array(tvec): plt.plot((spkt, spkt), (0, ncells), 'r-', linewidth=0.1)","def hexapodZernikeTrend(mnts='M20'):\n Tfile='/home/jghao/research/decamFocus/psf_withseeing/finerGrid_coeff_matrix/zernike_coeff_finerGrid_training.cp'\n b=p.load(open(Tfile))\n nobs = len(b)\n x = b[:,0]\n y = b[:,1]\n z = b[:,2]\n theta = b[:,3]\n phi = b[:,4]\n fwhm = b[:,5]\n e1 = b[:,6]\n e2 = b[:,7]\n thetax = theta*np.cos(np.deg2rad(phi))\n thetay = theta*np.sin(np.deg2rad(phi))\n if mnts == 'M20':\n idxBase = 9\n if mnts == 'M22real':\n idxBase = 29\n if mnts == 'M22imag':\n idxBase = 49\n idx = np.arange(14)\n zernikeName=('Piston','Tip','Tilt','Astignism','Defocus','Astignism','Trefoil','Coma','Coma','Trefoil','Ashtray','Astigm.5th','Spherical','Astigm.5th','Ashtray','16','17','18','19','20')\n for i in range(14):\n pl.figure(figsize=(21,10))\n pl.subplot(2,3,1)\n bp.bin_scatter(b[:,idxBase+idx[i]],x,nbins=20,fmt='bo',scatter=True)\n pl.ylabel('x-decenter')\n pl.xlabel(zernikeName[i+1])\n pl.ylim(-0.1,0.1)\n pl.title(mnts)\n pl.subplot(2,3,2)\n bp.bin_scatter(b[:,idxBase+idx[i]],y,nbins=20,fmt='bo',scatter=True)\n pl.ylabel('y-decenter')\n pl.xlabel(zernikeName[i+1])\n pl.title(mnts)\n pl.ylim(-0.1,0.1)\n pl.subplot(2,3,3)\n bp.bin_scatter(b[:,idxBase+idx[i]],z,nbins=20,fmt='bo',scatter=True)\n pl.ylabel('z-defocus')\n pl.xlabel(zernikeName[i+1])\n pl.title(mnts)\n pl.ylim(-0.1,0.1)\n pl.subplot(2,3,4)\n bp.bin_scatter(b[:,idxBase+idx[i]],thetax,nbins=20,fmt='bo',scatter=True)\n pl.ylabel('x-tilt')\n pl.xlabel(zernikeName[i+1])\n pl.title(mnts)\n pl.ylim(-40,40)\n pl.subplot(2,3,5)\n bp.bin_scatter(b[:,idxBase+idx[i]],thetay,nbins=20,fmt='bo',scatter=True)\n pl.ylabel('y-tilt')\n pl.xlabel(zernikeName[i+1])\n pl.title(mnts)\n pl.ylim(-40,40)\n pl.savefig(zernikeName[i+1]+mnts+'_'+str(i+1)+'.png')\n pl.close()","def zernikeHexapodTrend(mnts='M20'):\n Tfile='/home/jghao/research/decamFocus/psf_withseeing/finerGrid_coeff_matrix/zernike_coeff_finerGrid_training.cp'\n b=p.load(open(Tfile))\n nobs = len(b)\n x = b[:,0]\n y = b[:,1]\n z = b[:,2]\n theta = b[:,3]\n phi = b[:,4]\n fwhm = b[:,5]\n e1 = b[:,6]\n e2 = b[:,7]\n thetax = theta*np.cos(np.deg2rad(phi))\n thetay = theta*np.sin(np.deg2rad(phi))\n if mnts == 'M20':\n idxBase = 9\n if mnts == 'M22real':\n idxBase = 29\n if mnts == 'M22imag':\n idxBase = 49\n idx = np.arange(14)\n zernikeName=('Piston','Tip','Tilt','Astignism','Defocus','Astignism','Trefoil','Coma','Coma','Trefoil','Ashtray','Astigm.5th','Spherical','Astigm.5th','Ashtray','16','17','18','19','20')\n for i in range(14):\n pl.figure(figsize=(21,10))\n pl.subplot(2,3,1)\n bp.bin_scatter(x,b[:,idxBase+idx[i]],binsize=0.01,fmt='bo',scatter=True)\n pl.xlabel('x decenter')\n pl.ylabel(zernikeName[i+1])\n pl.title(mnts)\n pl.subplot(2,3,2)\n bp.bin_scatter(y,b[:,idxBase+idx[i]],binsize=0.01,fmt='bo',scatter=True)\n pl.xlabel('y decenter')\n pl.ylabel(zernikeName[i+1])\n pl.title(mnts)\n pl.subplot(2,3,3)\n bp.bin_scatter(z,b[:,idxBase+idx[i]],binsize=0.01,fmt='bo',scatter=True)\n pl.xlabel('z-defocus')\n pl.ylabel(zernikeName[i+1])\n pl.title(mnts)\n pl.subplot(2,3,4)\n bp.bin_scatter(thetax,b[:,idxBase+idx[i]],binsize=5,fmt='bo',scatter=True)\n pl.xlabel('x-tilt')\n pl.ylabel(zernikeName[i+1])\n pl.title(mnts)\n pl.subplot(2,3,5)\n bp.bin_scatter(thetay,b[:,idxBase+idx[i]],binsize=5,fmt='bo',scatter=True)\n pl.xlabel('y-tilt')\n pl.ylabel(zernikeName[i+1])\n pl.title(mnts)\n pl.savefig(mnts+'_'+str(i+1)+'_'+zernikeName[i+1]+'.png')\n pl.close()","def integrate(coords,data,fault_pts,dshape_hex8,gll_weights,elmt):\n norm=0.0\n normx=0.0\n normy=0.0\n normz=0.0\n div=0.0 #normalizing factor to divide by\n divx=0.\n divy=0.\n divz=0.\n\n eps=1.0*g.mesh_spacing/(g.ngllx-1.)\n print 'eps=', eps\n f=open('eliminated_coords.vtk','w')\n\n #create integer versions of arrays to use in pulling out gll pts for each element\n data_round=np.rint(data)\n dati=data_round.astype(int)\n coord_round=np.rint(coords)\n coordi=coord_round.astype(int)\n\n #remove duplicates from data array\n dat_struc=np.ascontiguousarray(dati).view(np.dtype((np.void,dati.dtype.itemsize *dati.shape[1])))\n _,idx=np.unique(dat_struc,return_index=True)\n datu=dati[idx]\n data_unique=data[idx]\n\n for i_elmt in range(g.nelmt):\n #pull out geometric coordinates for this element\n elmt_coord_id=[j-1 for j in elmt[i_elmt]]\n elmt_coord=coordi[elmt_coord_id]\n\n #find corresponding gll pts for this element\n xmin=min(elmt_coord[:,0]);xmax=max(elmt_coord[:,0])\n ymin=min(elmt_coord[:,1]);ymax=max(elmt_coord[:,1])\n zmin=min(elmt_coord[:,2]);zmax=max(elmt_coord[:,2])\n gll_coord_id=np.nonzero((datu[:,0]>=xmin) & (datu[:,0]<=xmax) & (datu[:,1]>=ymin) & (datu[:,1]<=ymax) & (datu[:,2]>=zmin) & (datu[:,2]<=zmax))\n elmt_data=data_unique[gll_coord_id]\n if len(gll_coord_id[0]) != g.ngll:\n print \"elmt=\", elmt_coord_id\n print xmin,xmax,ymin,ymax,zmin,zmax\n print 'elmt_data=', elmt_data\n print \"gll pts found=\", len(gll_coord_id[0])\n raise ValueError(\"incorrect number of gll points found in element!\")\n exit\n\n #sort the gll coords so they correspond the order of the arrays giving the weights and shape function\n dat_sorted=elmt_data[npi.argsort((elmt_data[:,0], elmt_data[:,1],elmt_data[:,2]))]\n func=dat_sorted[:,3:]\n\n #if any gll pt is too close to fault, remove the element from the integration\n dist=distance.cdist(fault_pts,dat_sorted[:,0:3],'euclidean')\n if (dist<eps).any():\n print \"eliminated element #\", i_elmt\n np.savetxt(f,dat_sorted[:,0:3],fmt='%3.3f')\n continue\n\n for i_gll in range(g.ngll):\n\n #compute jacobian, its derivative and inverse\n jac=np.matmul(dshape_hex8[:,:,i_gll],elmt_coord)\n det_jac=np.linalg.det(jac)\n\n #perform the integration\n norm=norm+det_jac*gll_weights[i_gll]*np.dot((func[i_gll,3:6]-func[i_gll,0:3]),(func[i_gll,3:6]-func[i_gll,0:3]))\n div=div+det_jac*gll_weights[i_gll]*np.dot(func[i_gll,3:6],func[i_gll,3:6])\n normx=normx+det_jac*gll_weights[i_gll]*(func[i_gll,3]-func[i_gll,0])**2\n divx=divx+det_jac*gll_weights[i_gll]*(func[i_gll,3])**2\n normy=normy+det_jac*gll_weights[i_gll]*(func[i_gll,4]-func[i_gll,1])**2\n divy=divy+det_jac*gll_weights[i_gll]*(func[i_gll,4])**2\n normz=normz+det_jac*gll_weights[i_gll]*(func[i_gll,5]-func[i_gll,2])**2\n divz=divz+det_jac*gll_weights[i_gll]*(func[i_gll,5])**2\n\n norm_finalx=sqrt(normx/divx)\n norm_finaly=sqrt(normy/divy)\n norm_finalz=sqrt(normz/divz)\n norm_final=sqrt(norm/div)\n\n f.close()\n\n return norm_finalx, norm_finaly, norm_finalz,norm_final","def test_nearest_neighbour_regular_1d():\n # test with regular grid and 1d coords\n grid_lon = np.arange(100)\n grid_lat = np.arange(50)\n data = np.zeros((50, 100))\n\n # the four nearest values for the first point\n data[20:22, 10:12] = 7\n\n # the four nearest values for the second point\n data[17:19, 13:15] = 8\n\n # the actual test\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, (10.2, 13.2), (20.2, 17.2), npoints=4)(data)\n np.testing.assert_array_almost_equal(res, [7, 8])\n\n # same test, but with 3d-data (e.g., level, lat, lon)\n data2 = np.zeros((10, 50, 100))\n for i in range(10):\n data2[i, :, :] = data + i\n\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, (10.2, 13.2), (20.2, 17.2), npoints=4)(data2)\n np.testing.assert_array_almost_equal(res, np.asarray([np.arange(7, 17, 1), np.arange(8, 18, 1)]).transpose())\n\n # same test with only one neighbour or only one target point\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, (10.2, 13.2), (20.2, 17.2), npoints=1)(data)\n np.testing.assert_array_almost_equal(res, [7, 8])\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, 10.2, 20.2, npoints=1)(data)\n np.testing.assert_array_almost_equal(res, 7)\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, 13.2, 17.2, npoints=1)(data2)\n np.testing.assert_array_almost_equal(res, np.arange(8, 18, 1).reshape(10, 1))","def plotSolitonIntersection():\n \n cells = np.loadtxt('cells.txt') #file with several cell [x0 y0 x1 y1 x2 y2 x3 y3], each cell in seperate row (at least 2 needed)\n cells = np.hstack([cells,cells[:,:2]])\n for cell in cells:\n plt.plot(cell[::2],cell[1::2])\n\n np.savetxt('X.txt',sorted(cells.flatten()[::2]))\n subprocess.call('solitonEta 0.3 15 0 X.txt',shell=True)\n soliton = np.loadtxt('eta.txt')\n plt.plot(soliton[:,0],soliton[:,1])\n\n #ipdb.set_trace()\n plt.savefig('boxes.png')\n plt.show()","def check_interp(self):\n\n points = np.loadtxt(\"skeleton_temp/\" + cell + \"_points.txt\", delimiter=',')\n\n self.initial_scatter = ax.scatter(points[:, 0],\n points[:, 1],\n points[:, 2], s=5, c='r')\n self.cell_points = self.get_cell_xyz()\n ax.scatter(self.cell_points[::5, 0],\n self.cell_points[::5, 1],\n self.cell_points[::5, 2], s=3, c='b', alpha=.03)\n ax.set_xlabel('X (um)')\n ax.set_ylabel('Y (um)')\n ax.set_zlabel('Z (um)')","def print_components_sizes(distance, points):\n SortedX = sorted([point for point in points], key = abscisse)\n\n result = prochesX(SortedX, distance)\n dernier_pointX_1 = result[len(result)-1]\n dernier_indice = SortedX.index(dernier_pointX_1)\n\n origine = Point([0.0, 0.0])\n segment_1 = Segment([Point([dernier_pointX_1.x, 0]), Point([dernier_pointX_1.x, 1])])\n\n SortedY = sorted([point for point in result], key = ordonnee)\n result_bis = prochesY(SortedY, distance)\n dernier_pointXbis_1 = result_bis[len(result_bis)-1]\n dernier_indice_bis = SortedX.index(dernier_pointXbis_1)\n\n segment_2 = Segment([Point([0, dernier_pointXbis_1.y]), Point([1, dernier_pointXbis_1.y])])\n tycat(origine, points, (segment_1, segment_2))\n \"\"\"\n affichage des tailles triees de chaque composante\n \"\"\"\n segments = []\n research_base = [point for point in points]\n origine = Point([0.0, 0.0])\n total = research_base.copy()\n s = 0\n enveloppe = []\n while len(research_base) > 0:\n current = research_base[0]\n research_base.pop(0)\n for point in research_base:\n if current.distance_to(point) < distance:\n s += 1\n segments.append(Segment([current, point]))\n enveloppe.append(s)\n tycat(origine, total, segments)","def plotVoronoiCell(self, cells):\n for i in cells:\n #i indexes volumes\n i = self.nonBI[i] #now i indexes vor.point_region\n\n vI = self.vor.regions[self.vor.point_region[i]]\n v = self.vor.vertices[vI, :]\n r = v\n\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n fig.set_size_inches(18.5, 9.5)\n ax.set_title('Voronoi Cell of Particle ' + str(i))\n ax.set_xlabel('x [m]')\n ax.set_ylabel('y [m]')\n ax.set_zlabel('z [m]')\n ax.scatter(r[:, 0], r[:, 1], r[:, 2], s=5, alpha=0.5, label='Cell Boundaries')\n ax.scatter(self.data[i, 0], self.data[i, 1], self.data[i, 2], s=25, label='Cell Center')\n ax.set_xlim3d(np.min(self.data[:, 0]), np.max(self.data[:, 0]))\n ax.set_ylim3d(np.min(self.data[:, 1]), np.max(self.data[:, 1]))\n ax.set_zlim3d(np.min(self.data[:, 2]), np.max(self.data[:, 2]))\n # limits = np.vstack((np.array([np.max(self.data[:, 0]), np.max(self.data[:, 1]), np.max(self.data[:, 2])]), np.array([np.min(self.data[:, 0]), np.min(self.data[:, 1]), np.min(self.data[:, 2])])))\n # ax.scatter(limits[:, 0], limits[:, 1], limits[:, 2], s=1)\n ax.legend()","def plot_timeres(timeres):\n tint = 24 / timeres\n step = 255 / (tint + 1)\n\n cont = np.zeros((scale, scale))\n for i in range(self.dataset.shape[0]):\n posy = int(((self.dataset[i][0] - minLat) * normLat))\n posx = int(((self.dataset[i][1] - minLon) * normLon))\n if distrib:\n cont[scale - posy - 1, posx - 1] += 1\n else:\n cont[scale - posy - 1, posx - 1] = 1\n mxcont = np.max(cont)\n\n if distrib:\n cont = cont / mxcont\n for i in range(cont.shape[0]):\n for j in range(cont.shape[1]):\n if cont[i, j] > 0.01:\n mymap.circle_marker(\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\n radius=cont[i, j] * (circlesize / scale),\n line_color='#000000',\n fill_color='#110000', fill_opacity=0.3)\n # mymap.addradpoint(minLat+(((scale - i)-0.5)/normLat), minLon+((j+1.5)/normLon),\n # cont[i,j]*(circlesize/scale), \"#FF0000\")\n else:\n for i in range(cont.shape[0]):\n for j in range(cont.shape[1]):\n if cont[i, j] > 0.01:\n mymap.circle_marker(\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\n radius=30,\n line_color='#000000',\n fill_color='#110000', fill_opacity=0.3)\n # mymap.addradpoint(minLat+(((scale - i )-0.5)/normLat),\n # minLon+((j+1.5)/normLon), 30, \"#FF0000\")\n for t in range(tint):\n color = '#' + (str(hex((t + 1) * step))[2:]) + (\n str(hex((t + 1) * step))[2:]) + 'FF' # (str(hex((t+1)*step))[2:])\n cont = np.zeros((scale, scale))\n for i in range(self.dataset.shape[0]):\n posy = int(((self.dataset[i][0] - minLat) * normLat))\n posx = int(((self.dataset[i][1] - minLon) * normLon))\n stime = time.localtime(np.int32(self.dataset[i][2]))\n evtime = stime[3]\n if (evtime / timeres) == t:\n if distrib:\n cont[scale - posy - 1, posx - 1] += 1\n else:\n cont[scale - posy - 1, posx - 1] = 1\n if distrib:\n cont = cont / mxcont\n for i in range(cont.shape[0]):\n for j in range(cont.shape[1]):\n if cont[i, j] > 0.01:\n mymap.circle_marker(\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\n radius=cont[i, j] * (circlesize / scale),\n line_color=color,\n fill_color='#110000', fill_opacity=0.2)\n else:\n for i in range(cont.shape[0]):\n for j in range(cont.shape[1]):\n if cont[i, j] > 0.01:\n mymap.circle_marker(\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\n radius=30,\n line_color=color,\n fill_color='#110000', fill_opacity=0.2)","def svm_add_2d_hyperplane(model, ax, plotted_points):\n X_MIN = np.min(plotted_points[:, 0])\n X_MAX = np.max(plotted_points[:, 0])\n Y_MIN = np.min(plotted_points[:, 1])\n Y_MAX = np.max(plotted_points[:, 1])\n # plot the line, the points, and the nearest vectors to the plane\n xx, yy = np.mgrid[X_MIN:X_MAX:200j, Y_MIN:Y_MAX:200j]\n Z = model.decision_function(np.c_[xx.ravel(), yy.ravel()])\n Z = Z.reshape(xx.shape)\n plot.contourf(xx, yy, Z, levels=np.linspace(\n Z.min(), 0, 7), cmap=plot.cm.PuBu)\n a = plot.contour(xx, yy, Z, levels=[0], linewidths=2, colors='darkred')\n plot.contourf(xx, yy, Z, levels=[0, Z.max()], colors='palevioletred')\n return a.collections[0]","def plotSurface(surfaceFile, comp=2, points=False, tris=False,\n profile=False, ax=None, annotate=True, norm=None,xscale=1, yscale=1):\n verts,data,tris = load_h5(surfaceFile)\n\n if comp==3: #radial displacements\n z = np.hypot(data[:,:,0], data[:,:,1]).flatten()\n else:\n z = data[:,:,comp].flatten()\n #z = data[:,:,comp].flatten()\n x = verts[:,0] / xscale\n y = verts[:,1] / yscale\n\n #NOTE: need to change grid for linear spacing to work properly\n xi = np.linspace(x.min(), x.max(), x.size)\n yi = np.linspace(y.min(), y.max(), y.size)\n zi = griddata(x,y,z, xi,yi, interp='nn') #'nn'\n\n #NOTE: getting error message here...\n # linear interpolation requires exactly the same limits\n #xi=np.arange(-15000.0,15000.0+1e-14,30000.0/x.size)\n #yi=np.arange(-15000.0,15000.0+1e-14,30000.0/x.size)\n #zi = griddata(x,y,z, xi,yi, interp='linear') #'nn'\n #ValueError: output grid must have constant spacing when using interp='linear'\n\n if ax==None:\n plt.figure()\n else:\n ax = plt.axes(ax)\n\n #plt.pcolor(xi, yi, zi, cmap=plt.cm.jet) #Very slow...\n x1, x2, y1, y2 = [x.min(), x.max(), y.min(), y.max()]\n im = plt.imshow(zi, cmap=plt.cm.jet, norm=norm, extent=[x1, x2, y1, y2])\n\n if annotate:\n compdict = {0:'Ux',1:'Uy',2:'Uz',3:'Ur'}\n plt.title('{} Displacement'.format(compdict[comp]))\n plt.xlabel('Distance [m]')\n plt.ylabel('Distance [m]')\n cb = plt.colorbar()\n cb.set_label('[m]')\n\n if points:\n plt.plot(x,y,'k.')\n\n if type(tris) is np.ndarray:\n plt.triplot(x, y, tris, 'k-')\n\n # EW profile line through the x-axis\n if profile:\n plt.axhline(linewidth=2, color='r')\n Zi = zi[x.size/2,:]\n plt.figure()\n plt.plot(xi, Zi, 'b.-')\n plt.title('Profile')\n plt.xlabel('Distance [m]')\n plt.ylabel('{} Displacement [m]'.format(compdict[comp]))\n\n return im","def test_nearest_neighbour_unstructured():\n # create coordinates\n grid_lon = np.arange(100)\n grid_lat = np.ones(100)\n data = np.zeros(100)\n\n # the nearest 3 points\n data[10:13] = 7\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, (11.2, 2.2), (11.2, 13.2), npoints=3, src_grid=\"unstructured\")(data)\n np.testing.assert_array_almost_equal(res, [7, 0])\n\n # same test, but with 2d-data (e.g., level, ncell)\n data2 = np.zeros((10, 100))\n for i in range(10):\n data2[i, :] = data + i\n\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, (11.2, 2.2), (11.2, 13.2), npoints=3, src_grid=\"unstructured\")(data2)\n np.testing.assert_array_almost_equal(res, np.asarray([np.arange(7, 17, 1), np.arange(0, 10, 1)]).transpose())\n\n # only one point\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, 11.2, 13.2, npoints=3, src_grid=\"unstructured\")(data)\n np.testing.assert_almost_equal(res, 7)\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, 11.2, 13.2, npoints=3, src_grid=\"unstructured\")(data2)\n np.testing.assert_array_almost_equal(res, np.arange(7, 17, 1).reshape(10, 1))\n\n # same test with one one neighbour point\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, 11.2, 13.2, npoints=1, src_grid=\"unstructured\")(data)\n np.testing.assert_almost_equal(res, 7)\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, 11.2, 13.2, npoints=1, src_grid=\"unstructured\")(data2)\n np.testing.assert_almost_equal(res, np.arange(7, 17, 1).reshape(10, 1))","def getEps(data):\r\n X = pdist(data)\r\n\r\n Sq = squareform(X)\r\n\r\n FourthDist = []\r\n firstDist = []\r\n k = 10\r\n kNeighbors = []\r\n for idx in range(len(Sq)):\r\n Sq[idx] = np.sort(Sq[idx])\r\n\r\n for i in range(k):\r\n kNeighbors.append(Sq[:, i + 1])\r\n for i in range(k):\r\n kNeighbors[i] = np.sort(kNeighbors[i])\r\n\r\n for i in range(k):\r\n plt.plot(kNeighbors[i])\r\n\r\n plt.title('10 Nearest Point')\r\n plt.show()","def problem5(self, s):\n points = 0\n\n points = self.neighbor( 10, 10, s.nearest_neighbor)*3\n points += self.neighbor(100, 10, s.nearest_neighbor)*3\n points += self.neighbor( 10, 100, s.nearest_neighbor)*3\n points += self.neighbor(100, 100, s.nearest_neighbor)*3\n points += self.neighbor(100, 100, s.nearest_neighbor)*3\n\n _testDriver.get_code(s.nearest_neighbor)\n print \"\\n(Check that scipy.spatial.KDTree is not used)\"\n points *= self.grade(1)\n \n return points","def test_nearest_neighbour_regular_2d():\n # test with regular grid and 2d coords\n grid_lon, grid_lat = np.meshgrid(np.arange(100), np.arange(50), indexing=\"ij\")\n data = np.zeros((100, 50))\n\n # the four nearest values for the first point\n data[10:12, 20:22] = 7\n\n # the four nearest values for the second point\n data[13:15, 17:19] = 8\n\n # the actual test\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, (10.2, 13.2), (20.2, 17.2), npoints=4)(data)\n np.testing.assert_array_almost_equal(res, [7, 8])\n\n # same test, but with 3d-data (e.g., level, lon, lat)\n data2 = np.zeros((10, 100, 50))\n for i in range(10):\n data2[i, :, :] = data + i\n\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, (10.2, 13.2), (20.2, 17.2), npoints=4)(data2)\n np.testing.assert_array_almost_equal(res, np.asarray([np.arange(7, 17, 1), np.arange(8, 18, 1)]).transpose())\n\n # same test with one neighbour point\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, 10.2, 20.2, npoints=1)(data2)\n np.testing.assert_array_almost_equal(res, np.arange(7, 17, 1).reshape(10, 1))\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, (10.2, 13.2), (20.2, 17.2), npoints=1)(data2)\n np.testing.assert_array_almost_equal(res, np.asarray([np.arange(7, 17, 1), np.arange(8, 18, 1)]).transpose())","def spatial_planner():\n from scipy.spatial import KDTree\n # KDTree","def plot_nhdp_hello_topology(options, tags=None, cursor=None):\n options['cur_src'] = 'topo'\n options['prefix'] = \"nhdp\"\n ################################################################################\n locs = options['locs']\n colors = options['color2'](pylab.linspace(0, 1, 101))\n ################################################################################\n circ_max = 5\n line_max = 10\n floor_factor = 2\n floor_skew = -0.25\n line_min = 1\n\n hosts = get_hosts(options)\n\n for q, (tag_key, tag_id, nhdp_hi, nhdp_ht, mpr_minpdr) in enumerate(tags):\n logging.info('tag_id=\\\"%s\\\" (%d/%d)', tag_id, q+1, len(tags))\n fig2d = MyFig(options, rect=[0.1, 0.1, 0.8, 0.7], xlabel='x Coordinate', ylabel='y Coordinate')\n fig3d = MyFig(options, rect=[0.1, 0.1, 0.8, 0.7], xlabel='x Coordinate', ylabel='y Coordinate', ThreeD=True)\n if not q:\n fig3d_onlynodes = MyFig(options, xlabel='x Coordinate [m]', ylabel='y Coordinate [$m$]', ThreeD=True)\n\n min_x = min_y = min_z = numpy.infty\n max_x = max_y = max_z = 0\n\n # draw the nodes\n for host in hosts:\n try:\n xpos, ypos, zpos = locs[host]\n except KeyError:\n logging.warning('no position found for node %s', host)\n continue\n\n max_x = max(xpos, max_x)\n max_y = max(ypos, max_y)\n min_x = min(xpos, min_x)\n min_y = min(ypos, min_y)\n max_z = max(zpos, max_z)\n min_z = max(zpos, min_z)\n\n fig2d.ax.plot(\n xpos+zpos*floor_skew*floor_factor,\n ypos+zpos*floor_factor,\n 'o', color='black', ms=circ_max)\n fig3d.ax.plot([xpos], [ypos], [zpos], 'o', color='black', ms=circ_max)\n if not q:\n color = 'black'\n if host.startswith('a6'):\n color = 'red'\n elif host.startswith('a3'):\n color = 'blue'\n elif host.startswith('a7'):\n color = 'orange'\n fig3d_onlynodes.ax.plot([xpos], [ypos], [zpos], 'o', color=color, ms=circ_max)\n fig2d.colorbar = fig2d.fig.add_axes([0.1, 0.875, 0.8, 0.025])\n fig3d.colorbar = fig3d.fig.add_axes([0.1, 0.875, 0.8, 0.025])\n drawBuildingContours(fig3d.ax, options)\n drawBuildingContours(fig3d_onlynodes.ax, options)\n\n alinspace = numpy.linspace(0, 1, 100)\n alinspace = numpy.vstack((alinspace, alinspace))\n for tax in [fig2d.colorbar, fig3d.colorbar]:\n tax.imshow(alinspace, aspect='auto', cmap=options['color2'])\n tax.set_xticks(pylab.linspace(0, 100, 5))\n tax.set_xticklabels(['$%.2f$' % l for l in pylab.linspace(0, 1, 5)], fontsize=0.8*options['fontsize'])\n tax.set_yticks([])\n tax.set_title('$PDR$', size=options['fontsize'])\n fig2d.ax.axis((min_x-10, max_x+10, min_y-10, max_y+10+max_z*floor_factor+10))\n fig2d.save('2d_%s' % (tag_id))\n fig3d.save('3d_%s' % (tag_id))\n if not q:\n fig3d_onlynodes.save('3d')","def render(static, tour_indices, save_path):\n\n plt.close('all')\n print('static_shape', static.shape)\n print('tour_indices_shape', tour_indices.shape)\n\n num_plots = 3 if int(np.sqrt(len(tour_indices))) >= 3 else 1\n\n _, axes = plt.subplots(nrows=num_plots, ncols=num_plots,\n sharex='col', sharey='row')\n\n if num_plots == 1:\n axes = [[axes]]\n axes = [a for ax in axes for a in ax]\n\n for i, ax in enumerate(axes):\n\n # Convert the indices back into a tour\n idx = tour_indices[i]\n print('idx0', idx)\n if len(idx.size()) == 1:\n idx = idx.unsqueeze(0)\n print('idx1', idx)\n\n idx = idx.expand(static.size(1), -1)\n print('idx2', idx)\n data = torch.gather(static[i].data, 1, idx).cpu().numpy()\n print('data', data)\n\n start = static[i, :, 0].cpu().data.numpy()\n x = np.hstack((start[0], data[0], start[0]))\n y = np.hstack((start[1], data[1], start[1]))\n print('x', x)\n print('y', y)\n\n # Assign each subtour a different colour & label in order traveled\n idx = np.hstack((0, tour_indices[i].cpu().numpy().flatten(), 0))\n print('idx3', idx)\n where = np.where(idx == 0)[0]\n print('where', where)\n\n for j in range(len(where) - 1):\n\n low = where[j]\n high = where[j + 1]\n\n if low + 1 == high:\n continue\n\n ax.plot(x[low: high + 1], y[low: high + 1], zorder=1, label=j)\n\n ax.legend(loc=\"upper right\", fontsize=3, framealpha=0.5)\n ax.scatter(x, y, s=4, c='r', zorder=2)\n ax.scatter(x[0], y[0], s=20, c='k', marker='*', zorder=3)\n\n ax.set_xlim(0, 1)\n ax.set_ylim(0, 1)\n\n plt.tight_layout()\n plt.savefig(save_path, bbox_inches='tight', dpi=400)","def make_pnts(start_point, end_point, path, cellsize):\n pnts = misc.generateSamples(tran = [start_point, end_point], path = path)\n \n #Only do sampling at DEM with >3m resolution \n if cellsize[0] >= 5:\n pnts = misc.selectSamplePts([start_point, end_point], pnts, cellsize[0])\n return pnts","def plot_timeres(timeres):\n tint = 24 / len(timeres.intervals)\n step = 255 / (tint + 1)\n\n cont = np.zeros(cluster.num_clusters())\n for i in range(self.dataset.shape[0]):\n posy = self.dataset[i][0]\n posx = self.dataset[i][1]\n ejem = np.array([[posy, posx]]).reshape(1,-1)\n ncl = cluster.predict(ejem)\n ncl = ncl[0]\n\n if distrib:\n cont[ncl] += 1\n else:\n cont[ncl] = 1\n\n # if distrib:\n # cont = cont / np.max(cont)\n # for i in range(cont.shape[0]):\n # if cont[i] > 0.01:\n # cx = cluster.cluster_centers_[i][0]\n # cy = cluster.cluster_centers_[i][1]\n # mymap.circle_marker(location=[cx, cy],\n # radius=cont[i] * circlesize,\n # line_color='#FF0000',\n # fill_color='#110000')\n # else:\n # for i in range(cont.shape[0]):\n # if cont[i] > 0.01:\n # cx = cluster.cluster_centers_[i][0]\n # cy = cluster.cluster_centers_[i][1]\n # mymap.circle_marker(location=[cx, cy],\n # radius=30,\n # line_color='#FF0000',\n # fill_color='#110000')\n for t in range(tint):\n color = '#' + (str(hex((t + 1) * step))[2:]) + \\\n (str(hex((t + 1) * step))[2:]) + 'FF' # (str(hex((t+1)*step))[2:])\n cont = np.zeros(cluster.num_clusters())\n for i in range(self.dataset.shape[0]):\n posy = self.dataset[i][0]\n posx = self.dataset[i][1]\n ejem = np.array([[posy, posx]]).reshape(1,-1)\n ncl = cluster.predict(ejem)\n ncl = ncl[0]\n\n _, evtime = timeres.discretize(self.dataset[i][2])\n\n if evtime == t:\n if distrib:\n cont[ncl] += 1\n else:\n cont[ncl] = 1\n if distrib:\n cont = cont / np.max(cont)\n for i in range(cont.shape[0]):\n if cont[i] > 0.01:\n cx = cluster.cluster_centers_[i][0]\n cy = cluster.cluster_centers_[i][1]\n mymap.circle_marker(location=[cx, cy],\n radius=cont[i] * circlesize,\n line_color=pltcolors[t],\n fill_color=pltcolors[t], #'#110000',\n popup=str(t) + '-' + str(cont[i]), fill_opacity=0.2)\n else:\n for i in range(cont.shape[0]):\n for j in range(cont.shape[1]):\n if cont[i] > 0.01:\n cx = cluster.cluster_centers_[i][0]\n cy = cluster.cluster_centers_[i][1]\n mymap.circle_marker(location=[cx, cy],\n radius=30,\n line_color=pltcolors[t],\n fill_color=pltcolors[t], #'#110000',\n popup=str(t) + '-' + str(cont[i]), fill_opacity=0.2)","def rho_true(subj, T, test_set, bbox_ls):\n res = (20,20)\n x = 0.5*(test_set[subj][0,T] + test_set[subj][2,T])\n y = 0.5*(test_set[subj][1,T] + test_set[subj][3,T])\n print \"Rho TRUE\"\n plt.scatter(x, y, s=60, color=\"grey\")\n x_min = x-test_scene.bbox_width/2\n x_max = x+test_scene.bbox_width/2\n y_min = y-test_scene.bbox_width/2\n y_max = y+test_scene.bbox_width/2\n bbox_npy = np.array(bbox_ls)\n x_width_arr = bbox_npy[:,0,0]\n x_pos_arr = bbox_npy[:,1,0]\n y_width_arr = bbox_npy[:,0,1]\n y_pos_arr = bbox_npy[:,1,1]\n pmax = lambda x,y: x*(x>y)+y*(y>x)\n pmin = lambda x,y: x*(x<y)+y*(y<x)\n x_left = pmax(x_min, x_pos_arr - x_width_arr/2.0)\n x_right = pmin(x_max, x_pos_arr + x_width_arr/2.0)\n y_bottom = pmax(y_min, y_pos_arr - y_width_arr/2.0)\n y_top = pmin(y_max, y_pos_arr + y_width_arr/2.0)\n out = (x_right-x_left)*(x_right>x_left)*(y_top-y_bottom)*(y_top>y_bottom)\n out /= test_scene.bbox_width**2\n return out","def print_TRT_cell_map(samples_df,cfg_set_tds):\r\n\r\n fig, axes, extent = ccs4_map(cfg_set_tds)\r\n axes.scatter(samples_df[\"LV03_x\"].loc[samples_df[\"category\"] == \"DEVELOPING\"],\r\n samples_df[\"LV03_y\"].loc[samples_df[\"category\"] == \"DEVELOPING\"],c='w',edgecolor=(.7,.7,.7),s=18)\r\n axes.scatter(samples_df[\"LV03_x\"].loc[samples_df[\"category\"] == \"MODERATE\"],\r\n samples_df[\"LV03_y\"].loc[samples_df[\"category\"] == \"MODERATE\"],c='g',edgecolor=(.7,.7,.7),s=22)\r\n axes.scatter(samples_df[\"LV03_x\"].loc[samples_df[\"category\"] == \"SEVERE\"],\r\n samples_df[\"LV03_y\"].loc[samples_df[\"category\"] == \"SEVERE\"],c='y',edgecolor=(.7,.7,.7),s=26)\r\n axes.scatter(samples_df[\"LV03_x\"].loc[samples_df[\"category\"] == \"VERY SEVERE\"],\r\n samples_df[\"LV03_y\"].loc[samples_df[\"category\"] == \"VERY SEVERE\"],c='r',edgecolor=(.7,.7,.7),s=30)\r\n \r\n fig.savefig(os.path.join(cfg_set_tds[\"fig_output_path\"],u\"TRT_Map.pdf\"))","def plot_tsne_with_colors_sorted(tsne_result, vector, cmap_use, save_tag=False, save_name='Test.pdf'):\n vector = np.asarray(vector)\n new_vector = [i[0] for i in vector]\n idx = np.argsort(new_vector)\n plt.scatter(tsne_result[idx, 0], tsne_result[idx, 1], c=cmap_use)\n plt.axis('off')\n if save_tag == True:\n plt.savefig(\n \"/Users/rohanramesh/Documents/SportsData/NBA/Figures/tsne_%s.png\" % save_name,\n bbox_inches='tight', dpi=100)\n plt.show()","def render(static, tour_indices, save_path, test = False):\n # if not test:\n # matplotlib.use('Agg')\n # if not os.path.exists(save_path):\n # os.makedirs(save_path)\n\n plt.close('all')\n if isinstance(static, torch.Tensor):\n static = static.cpu()\n if isinstance(tour_indices, torch.Tensor):\n tour_indices = tour_indices.cpu()\n\n num_plots = 3 if int(np.sqrt(len(tour_indices))) >= 3 else 1\n\n _, axes = plt.subplots(nrows=num_plots, ncols=num_plots,\n sharex='col', sharey='row')\n\n if num_plots == 1:\n axes = [[axes]]\n axes = [a for ax in axes for a in ax]\n\n for i, ax in enumerate(axes):\n\n # Convert the indices back into a tour\n idx = tour_indices[i, :]\n idx = idx[idx>-1]\n static_ = static[i].data\n\n for idx_ in idx:\n nearest_indices = cal_nearest_indices(static_, idx_)\n for nearest_idx in nearest_indices:\n pair_coor = torch.cat((static_[:,idx_].unsqueeze(0),static_[:,nearest_idx].unsqueeze(0))).transpose(1,0).numpy()\n ax.plot(pair_coor[0], pair_coor[1], linestyle='--', color='k',zorder=1, linewidth='0.5')\n\n\n # End tour at the starting index\n idx = torch.cat((idx, idx[0].unsqueeze(0)))\n idx = idx.repeat(2, 1) # (2,6)\n\n data = torch.gather(static[i].data, 1, idx).cpu().numpy()\n\n #plt.subplot(num_plots, num_plots, i + 1)\n ax.plot(data[0], data[1], zorder=1)\n ax.scatter(static_[0], static_[1], s=4, c='r', zorder=2)\n ax.scatter(data[0, 0], data[1, 0], s=20, c='k', marker='*', zorder=3)\n\n # ax.set_xlim(0, 1)\n # ax.set_ylim(0, 1)\n\n plt.tight_layout()\n plt.show()\n print(save_path)\n plt.savefig(save_path, bbox_inches='tight', dpi=400)","def watershed_segment_2(M,click_coords):\n \n # todo: choose these structures based on aspect ratio of M and input parameters\n sel = np.ones((4,10)) # for opening\n sel2 = np.ones((15,75)) # for local thresholding\n sel3 = np.ones((2,5)) # for erosion\n # get a few points in the center of each blob\n \n # threshold\n #bw = ((M>=ndi.percentile_filter(M,80,footprint=sel2)) & (M>=scoreatpercentile(M.flatten(),60)))\n \n score = stats.percentileofscore(M.flatten(),M[int(click_coords[0][1]),int(click_coords[0][0])])\n bw = (M>=stats.scoreatpercentile(M.flatten(),score))\n\n # open and erode\n #bools = sp.zeros((M.shape[0],M.shape[1]),int)\n #bools[int(click_coords[0]),int(click_coords[1])] = 1\n #blobs = sp.where(bools == 1,True,False)\n blobs = snm.binary_opening(bw,structure=sel)\n blobs = snm.binary_dilation(blobs,iterations=3)\n blobs = snm.binary_erosion(blobs,structure=sel3)\n \n \n # label\n labels,_ = ndi.label(blobs)\n labels[labels > 0] += 1\n #labels[0,0] = 1\n\n # rescale and cast to int16, then use watershed\n M2 = rescaled(M,0,65000).astype(np.uint16)\n newlabels = ndi.watershed_ift(M2,labels)\n \n # get rid of groups unless they have the right number of pixels\n counts = np.bincount(newlabels.flatten())\n old2new = np.arange(len(counts))\n old2new[(counts < 100) | (counts > 600)] = 0\n newlabels = old2new[newlabels]\n \n return newlabels","def _create_tecplot_solids(grid, model, nsolids, ntets, tets, nhexas, hexas, is_surface=True):\n if is_surface:\n if nhexas:\n free_faces = np.array(model.get_free_faces(), dtype='int32')# + 1\n nfaces = len(free_faces)\n nelements = nfaces\n unused_elements = free_faces\n grid.Allocate(nfaces, 1000)\n\n #elem.GetCellType() = 9 # vtkQuad\n for face in free_faces:\n elem = vtkQuad()\n epoints = elem.GetPointIds()\n epoints.SetId(0, face[0])\n epoints.SetId(1, face[1])\n epoints.SetId(2, face[2])\n epoints.SetId(3, face[3])\n grid.InsertNextCell(9, epoints)\n else:\n # is_volume\n grid.Allocate(nsolids, 1000)\n if ntets:\n for node_ids in tets:\n elem = vtkTetra()\n epoints = elem.GetPointIds()\n epoints.SetId(0, node_ids[0])\n epoints.SetId(1, node_ids[1])\n epoints.SetId(2, node_ids[2])\n epoints.SetId(3, node_ids[3])\n #elem.GetCellType() = 5 # vtkTriangle\n grid.InsertNextCell(elem.GetCellType(), epoints)\n\n\n if nhexas:\n for node_ids in hexas:\n elem = vtkHexahedron()\n epoints = elem.GetPointIds()\n epoints.SetId(0, node_ids[0])\n epoints.SetId(1, node_ids[1])\n epoints.SetId(2, node_ids[2])\n epoints.SetId(3, node_ids[3])\n epoints.SetId(4, node_ids[4])\n epoints.SetId(5, node_ids[5])\n epoints.SetId(6, node_ids[6])\n epoints.SetId(7, node_ids[7])\n #elem.GetCellType() = 5 # vtkTriangle\n grid.InsertNextCell(elem.GetCellType(), epoints)\n return nelements","def plot_distance(stc_est, stc_signal, D, surface='inflated'):\n import surfer # Import here so other parts of the code can be used without graphics\n peak = stc_est.get_peak(vert_as_index=True)[0]\n peak_hemi = 0 if peak < len(stc_est.vertices[0]) else 1\n true_hemi = config.signal_hemi\n\n est_vert = np.hstack(stc_est.vertices)[peak]\n true_vert = stc_signal.vertices[true_hemi][0]\n\n brain = surfer.Brain('sample', hemi='both', surf=surface)\n brain.add_data(D[peak, :len(stc_est.vertices[0])], vertices=stc_est.vertices[0],\n hemi='lh', transparent=True)\n brain.add_data(D[peak, len(stc_est.vertices[0]):], vertices=stc_est.vertices[1],\n hemi='rh', transparent=True)\n brain.add_foci([est_vert], coords_as_verts=True, hemi='lh' if peak_hemi == 0 else 'rh', color='red')\n brain.add_foci([true_vert], coords_as_verts=True, hemi='lh' if true_hemi == 0 else 'rh', color='green')\n return brain","def output_grid_information():\n # translate = [-74.26, 40.50]\n # scale = [0.02, 0.02]\n # step = 1\n\n translate = [0, 0]\n scale = [1, 1]\n step = 0.02\n\n lon_limits = [(-74.26 - translate[0]) / scale[0], (-73.76 - translate[0]) / scale[0]]\n lat_limits = [(40.48 - translate[1]) / scale[1], (40.94 - translate[1]) / scale[1]]\n\n lons = np.arange(lon_limits[0], lon_limits[1] - step, step)\n lats = np.arange(lat_limits[0], lat_limits[1] - step, step)\n\n all_json = {\n \"type\": \"FeatureCollection\"\n }\n\n gr_id = 0\n grid_df = pd.DataFrame(columns=['gr_id', 'c_lat', 'c_lon', 's_lon', 'w_lat', 'n_lon', 'e_lat'])\n features = []\n\n for lat in lats:\n for lon in lons:\n w_lon = lon\n e_lon = lon + step\n s_lat = lat\n n_lat = lat + step\n\n c_lon = lon + step / 2\n c_lat = lat + step / 2\n\n grid_df = grid_df.append(pd.DataFrame({\"gr_id\": [gr_id],\n \"c_lon\": [c_lon], \"c_lat\": [c_lat],\n \"w_lon\": [w_lon], \"s_lat\": [s_lat],\n \"e_lon\": [e_lon], \"n_lat\": [n_lat]}))\n\n coor = [[[s_lat, w_lon], [n_lat, w_lon], [n_lat, e_lon],\n [s_lat, e_lon], [s_lat, w_lon]]]\n\n feature = {\n \"type\": \"Feature\",\n \"geometry\": {\n \"type\": \"Polygon\",\n \"coordinates\": coor\n },\n \"properties\": {\n \"id\": str(gr_id)\n }\n }\n\n features.append(feature)\n\n gr_id += 1\n\n all_json['features'] = features\n\n with open(BaseDir + '/grid.geojson', 'w') as f:\n json.dump(all_json, f)\n\n grid_df.to_csv(BaseDir + '/grid_locs.csv', index=False)","def get_contour_features(mask,selectcell=\"centered\"):\r\n \r\n #binarize image (everything above 0 becomes 1)\r\n mask = np.clip(mask,a_min=0,a_max=1)\r\n\r\n #for contours, dont use RETR_TREE, but RETR_EXTERNAL as we are not interested in internal objects\r\n contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\r\n contours = list(contours)\r\n \r\n #in case there is no contour found, add a dummy contour\r\n if len(contours)==0:\r\n contours = [np.array([[[0, 0]],[[0, 1]],[[1, 1]],[[1, 0]]])] #generate a dummy contour\r\n\r\n #Sort contours, longest first\r\n contours.sort(key=len,reverse=True)\r\n contours = [c for c in contours if len(c)>4] #proper contour should have at least 5 points\r\n hulls = [cv2.convexHull(contour,returnPoints=True) for contour in contours]\r\n\r\n mu_origs = [cv2.moments(contour) for contour in contours]\r\n mu_hulls = [cv2.moments(hull) for hull in hulls]\r\n\r\n area_origs = [mu_orig[\"m00\"] for mu_orig in mu_origs]\r\n area_hulls = [mu_hull[\"m00\"] for mu_hull in mu_hulls]\r\n\r\n #drop events where area is zero\r\n hulls = [hulls[i] for i in range(len(hulls)) if area_origs[i]>0] \r\n contours = [contours[i] for i in range(len(contours)) if area_origs[i]>0]\r\n mu_origs = [mu_origs[i] for i in range(len(mu_origs)) if area_origs[i]>0]\r\n mu_hulls = [mu_hulls[i] for i in range(len(mu_hulls)) if area_origs[i]>0]\r\n area_hulls = [area_hulls[i] for i in range(len(area_hulls)) if area_origs[i]>0]\r\n area_origs = [area_origs[i] for i in range(len(area_origs)) if area_origs[i]>0]\r\n \r\n \r\n pos_x = [int(mu_orig['m10']/mu_orig['m00']) for mu_orig in mu_origs]\r\n pos_y = [int(mu_orig['m01']/mu_orig['m00']) for mu_orig in mu_origs]\r\n\r\n \r\n if selectcell == \"smooth\":\r\n #compute the area ratio (roughness of contour)\r\n area_ratio = np.array(area_hulls)/np.array(area_origs)\r\n #get the contour with minimum roughness (smooth contour)\r\n sorter = np.argsort(area_ratio) #smallest first\r\n\r\n if selectcell == \"centered\":\r\n #select contour that is closest to the center of the image. \r\n #In iPAC, cells are usually in the center.\r\n mid_x,mid_y = mask.shape[0]/2,mask.shape[1]/2 #middle of the image\r\n BB = [cv2.boundingRect(c) for c in contours] #get a bounding box around the object\r\n distances = [np.sqrt((mid_x-bb[0])**2 + (mid_y-bb[1])**2) for bb in BB]\r\n sorter = np.argsort(distances) #smallest first\r\n \r\n #sort values with respect to chosen metric (area_ratio or distance)\r\n contours = [contours[s] for s in sorter]\r\n hulls = [hulls[s] for s in sorter]\r\n pos_x = [pos_x[s] for s in sorter]\r\n pos_y = [pos_y[s] for s in sorter]\r\n mu_origs = [mu_origs[s] for s in sorter]\r\n area_origs = [area_origs[s] for s in sorter]\r\n area_hulls = [area_hulls[s] for s in sorter]\r\n \r\n # draw mask of the chosen contour\r\n mask = np.zeros_like(mask)\r\n cv2.drawContours(mask,contours,0,1,cv2.FILLED)# produce a contour that is filled inside\r\n\r\n hull = hulls[0]#[0:n_contours]\r\n pos_x = pos_x[0]\r\n pos_y = pos_y[0] \r\n mu_orig = mu_origs[0]#[0:n_contours]\r\n area_orig = area_origs[0]#[0:n_contours]\r\n area_hull = area_hulls[0]#[0:n_contours]\r\n \r\n if area_orig>0:\r\n area_ratio = area_hull/area_orig\r\n else:\r\n area_ratio = np.nan\r\n\r\n arc = cv2.arcLength(hull, True) \r\n circularity = 2.0 * np.sqrt(np.pi * mu_orig[\"m00\"]) / arc\r\n\r\n\r\n dic = {\"mask\":mask,\"pos_x\":pos_x,\"pos_y\":pos_y,\"area_orig\":area_orig,\"area_hull\":area_hull,\\\r\n \"area_ratio\":area_ratio,\"circularity\":circularity}\r\n return dic","def plot_screen(tiles, gazepoints, tolerance=0, filepath=None):\n\n #read gaze points\n gazeX = gazepoints['pixels'].map(lambda x: x.x)\n gazeY = gazepoints['pixels'].map(lambda x: x.y)\n gazeI = gazepoints.index\n\n\n #create figure\n fig = plt.figure(figsize=(16,9))\n ax = fig.add_subplot(111)\n\n ax.set_xlim(-200,2120)\n ax.set_ylim(-200,1280)\n ax.set_ylim(ax.get_ylim()[::-1])\n ax.add_patch(plt.Rectangle((0,0),1920,1080,alpha = 0.05,color = 'b'))\n gax = ax.scatter(gazeX, gazeY, s= 10, c = gazeI, cmap = plt.cm.Reds, label = 'gaze')\n fig.colorbar(gax, format = '%d')\n\n #draw the objects\n tolerances = []\n for tile in tiles:\n if tile.is_selected:\n ax.text(tile.x, tile.y, tile.shape, size = 'xx-large', weight = 'bold',\n color = tile.color, bbox=dict(facecolor='red', alpha=0.5))\n else:\n ax.text(tile.x, tile.y, tile.shape, size = 'xx-large', weight = 'bold', color = tile.color)\n #draw the tolerance circles\n circle = plt.Circle((tile.x, tile.y), tolerance, color='r', fill=False)\n ax.add_patch(circle)\n if filepath is not None:\n fig.savefig(filepath, format=filepath.split('.')[1])","def hot_plate(n,c=None):\n A,b=finite_difference(n)\n if c is None:\n u=linalg.spsolve(A.tocsr(),b)\n \n else:\n u=linalg.spsolve(A.tocsr(),c)\n \n \n x=np.linspace(1,n,n)\n y=np.linspace(1,n,n)\n X,Y=np.meshgrid(x,y)\n Z=u.reshape((n,n))\n \n \n \n \n # Plot the heat map of f over the 2-D domain.\n plt.pcolormesh(X, Y, Z, cmap=\"seismic\")\n plt.colorbar()\n plt.xlim(1,n)\n plt.ylim(1,n)\n plt.show()","def create_local_grid(points: np.ndarray, edge_sides: dict, triangles: np.ndarray,\n fault_is_plane: bool, resolution: float=5000.0, num_search_tris: int=10):\n\n # Edge coordinates.\n left_edge = edge_sides['left_edge']\n right_edge = edge_sides['right_edge']\n bottom_edge = edge_sides['bottom_edge']\n top_edge = edge_sides['top_edge']\n\n # Determine number of points in each direction.\n left_diffs = np.diff(left_edge, axis=0)\n left_length = np.sum(np.linalg.norm(left_diffs, axis=1))\n num_divs_left = left_length/resolution\n\n right_diffs = np.diff(right_edge, axis=0)\n right_length = np.sum(np.linalg.norm(right_diffs, axis=1))\n num_divs_right = right_length/resolution\n\n num_vert_points = int(round(0.5*(num_divs_left + num_divs_right))) + 1\n\n bottom_diffs = np.diff(bottom_edge, axis=0)\n bottom_length = np.sum(np.linalg.norm(bottom_diffs, axis=1))\n num_divs_bottom = bottom_length/resolution\n\n top_diffs = np.diff(top_edge, axis=0)\n top_length = np.sum(np.linalg.norm(top_diffs, axis=1))\n num_divs_top = top_length/resolution\n\n num_horiz_points = int(round(0.5*(num_divs_bottom + num_divs_top))) + 1\n num_points = num_vert_points*num_horiz_points\n\n # Get interpolated points on edges.\n ygrid_left = np.linspace(left_edge[0,1], left_edge[-1,1], num=num_vert_points, dtype=np.float64)\n xgrid_left = np.interp(ygrid_left, left_edge[:,1], left_edge[:,0])\n zgrid_left = np.interp(ygrid_left, left_edge[:,1], left_edge[:,2])\n ygrid_right = np.linspace(right_edge[0,1], right_edge[-1,1], num=num_vert_points, dtype=np.float64)\n xgrid_right = np.interp(ygrid_right, right_edge[:,1], right_edge[:,0])\n zgrid_right = np.interp(ygrid_right, right_edge[:,1], right_edge[:,2])\n xgrid_bottom = np.linspace(bottom_edge[0,0], bottom_edge[-1,0], num=num_horiz_points, dtype=np.float64)\n ygrid_bottom = np.interp(xgrid_bottom, bottom_edge[:,0], bottom_edge[:,1])\n zgrid_bottom = np.interp(xgrid_bottom, bottom_edge[:,0], bottom_edge[:,2])\n xgrid_top = np.linspace(top_edge[0,0], top_edge[-1,0], num=num_horiz_points, dtype=np.float64)\n ygrid_top = np.interp(xgrid_top, top_edge[:,0], top_edge[:,1])\n zgrid_top = np.interp(xgrid_top, top_edge[:,0], top_edge[:,2])\n\n # Create 2D mesh.\n mesh_points = np.zeros((num_vert_points, num_horiz_points, 3), dtype=np.float64)\n\n # We need to do this for points on the boundary, which might fall outside a mesh triangle.\n if not(fault_is_plane):\n z = np.zeros((num_vert_points, num_horiz_points), dtype=np.float64)\n is_mesh_edge = np.zeros((num_vert_points, num_horiz_points), dtype=np.bool)\n is_mesh_edge[0,:] = True\n is_mesh_edge[-1,:] = True\n is_mesh_edge[:,0] = True\n is_mesh_edge[:,-1] = True\n z[:,0] = zgrid_left\n z[:,-1] = zgrid_right\n z[0,:] = zgrid_bottom\n z[-1,:] = zgrid_top\n \n for row_num in range(num_vert_points):\n mesh_points[row_num,:,0] = np.linspace(xgrid_left[row_num], xgrid_right[row_num],\n num=num_horiz_points, dtype=np.float64)\n for col_num in range(num_horiz_points):\n mesh_points[:,col_num,1] = np.linspace(ygrid_bottom[col_num], ygrid_top[col_num],\n num=num_vert_points, dtype=np.float64)\n\n # If surface is not a plane, interpolate to get z-coordinates.\n mesh_points = mesh_points.reshape(num_points, 3)\n if not(fault_is_plane):\n is_mesh_edge = is_mesh_edge.reshape(num_points)\n z = z.reshape(num_points)\n mesh_points[:,2] = tri_interpolate_zcoords(points, triangles, mesh_points[:,0:2],\n is_mesh_edge, num_search_tris=num_search_tris)\n mesh_points[is_mesh_edge,2] = z[is_mesh_edge]\n\n return (mesh_points, num_horiz_points, num_vert_points)","def triangle_contour(x_center, y_center, values, smoothing, ckwargs={}):\n # make Triangulation object using the centers of each of the hexbins\n triag = Triangulation(x_center, y_center)\n refiner = UniformTriRefiner(triag) # refines the mesh of triangle\n # returns refines triangle field of triangles and interpolated\n # contour values by dividing each triangle into 4**subdiv triangles\n tri_refi, c_refi = refiner.refine_field(values, subdiv=smoothing)\n T = pl.tricontour(tri_refi, c_refi, **ckwargs)\n return T","def findminpath(tab, gxtab, gytab, pixtab):\n\n pathdist = 2 # the number of points each points on a ray can related to on the previous ray\n pathdist_penalty = 0.3 # penalty of the difference of the pathdist\n pathpix_penalty = 2 # penalty of the difference of pixel values between the point and the previous point\n nray = tab.shape[1]\n\n #tab = np.hstack((tab,tab[:, 0].reshape(tab.shape[0], 1)))\n #pixtab = np.hstack((pixtab,pixtab[:, 0].reshape(pixtab.shape[0], 1)))\n #gxtab = np.hstack((gxtab,gxtab[:, 0].reshape(gxtab.shape[0], 1)))\n #gytab = np.hstack((gytab,gytab[:, 0].reshape(gytab.shape[0], 1)))\n\n tab = np.hstack((tab,tab,tab)) # horizontally stack the tab matrix to prepare for the filtering on the result\n pixtab = np.hstack((pixtab,pixtab,pixtab))\n gxtab = np.hstack((gxtab,gxtab,gxtab))\n gytab = np.hstack((gytab,gytab,gytab))\n\n tab = (tab - tab.min()) / (tab.max() - tab.min()) # noralize the tab matrix\n pixtab = (pixtab - pixtab.min()) / (pixtab.max() - pixtab.min()) * -1 # for we want to find the white contour of the cell so we multipy -1 on the pixtab\n # tab = tab / np.median(tab)\n # pixtab = pixtab / np.median(pixtab)\n path = np.zeros(tab.shape)\n path[:, 0] = np.array(range(0, tab.shape[0]))\n score = np.zeros(tab.shape)\n score[:, 1] = tab[:, 1]\n\n for i in range(1, tab.shape[1]):\n for j in range(tab.shape[0]):\n mins = np.Inf # record the min value of the ray\n minat = 0\n for k in range(-pathdist, pathdist+1):\n if(0 <= (j+k) and (j+k) < tab.shape[0]):\n s = pixtab[j, i]\n pixdiff = abs(pixtab[j, i] - pixtab[j+k, i-1])\n s += pixdiff * pathpix_penalty # two kinds of penalty\n s += abs(k) * pathdist_penalty\n s += score[j+k, i-1]\n\n if(s < mins):\n mins = s\n minat = j + k\n path[j, i] = minat\n score[j, i]= mins\n\n start = int(np.argmin(score[:, -1]))\n path = path.astype(np.int32)\n minpath = [start]\n for i in range(tab.shape[1]-1, 0, -1):\n minpath.append(path[minpath[-1], i])\n minpath = minpath[::-1]\n # print(len(minpath))\n minpath = savgol_filter(minpath, 15, 3) # apply a Savitzky-Golay filter to the raw minpath signal\n minpath = minpath[nray:nray*2] # cut the middle part of minpath whose length is nray\n return np.array(minpath).astype(np.int32)","def do_jet_pt_plots(tree, output_dir, cut=''):\n for logz, normx in product([True, False], [True, False]):\n make_2d_plot(tree, 'httL1', HTT_L1_STR, NB_HTT, HTT_MIN, HTT_MAX, 'pt', PT_L1_STR, NB_PT, PT_MIN, PT_MAX,\n os.path.join(output_dir, 'pt_httL1.pdf'), logz=logz, normx=normx,\n cut=cut, title=TITLE, diagonal_line=True)\n make_2d_plot(tree, 'httL1', HTT_L1_STR, NB_HTT, HTT_MIN, HTT_MAX, 'ptRef', PT_REF_STR, NB_PT, PT_MIN, PT_MAX,\n os.path.join(output_dir, 'ptRef_httL1.pdf'), logz=logz, normx=normx,\n cut=cut, title=TITLE, diagonal_line=True)\n make_2d_plot(tree, 'httRef', HTT_REF_STR, NB_HTT, HTT_MIN, HTT_MAX, 'pt', PT_L1_STR, NB_PT, PT_MIN, PT_MAX,\n os.path.join(output_dir, 'pt_httRef.pdf'), logz=logz, normx=normx,\n cut=cut, title=TITLE, diagonal_line=True)\n make_2d_plot(tree, 'httRef', HTT_REF_STR, NB_HTT, HTT_MIN, HTT_MAX, 'ptRef', PT_REF_STR, NB_PT, PT_MIN, PT_MAX,\n os.path.join(output_dir, 'ptRef_httRef.pdf'), logz=logz, normx=normx,\n cut=cut, title=TITLE, diagonal_line=True)","def get_shortest_path_cell(\n self,\n xP0,\n yP0,\n xP1,\n yP1,\n npoint_ref=1,\n debug_info=False,\n ):\n # find indices of endpoints\n if self.on_sphere:\n idxP0 = get_index_lonlat(xP0, yP0, self.xcell, self.ycell)\n idxP1 = get_index_lonlat(xP1, yP1, self.xcell, self.ycell)\n else:\n idxP0 = get_index_xy(xP0, yP0, self.xcell, self.ycell)\n idxP1 = get_index_xy(xP1, yP1, self.xcell, self.ycell)\n print('Cell closest to P0: {:8.5f} {:8.5f}'.format(self.xcell[idxP0], self.ycell[idxP0]))\n print('Cell closest to P1: {:8.5f} {:8.5f}'.format(self.xcell[idxP1], self.ycell[idxP1]))\n # find reference points\n x_ref, y_ref = gc_interpolate(self.xcell[idxP0], self.ycell[idxP0],\n self.xcell[idxP1], self.ycell[idxP1], npoint_ref+2)\n if self.on_sphere:\n x_ref = np.mod(x_ref[1:-1], 360)\n y_ref = np.mod(y_ref[1:-1], 360)\n # initialize an empty path\n out = CellPath()\n # loop over reference points, find the path between these points\n idx_sp0 = idxP0\n for i in np.arange(npoint_ref):\n idx_cell = np.minimum(i,1)\n idx_sp1 = get_index_xy(x_ref[i], y_ref[i], self.xcell, self.ycell)\n print(' - Cell closest to RefP{:d}: {:8.5f} {:8.5f}'.format(i+1, self.xcell[idx_sp1], self.ycell[idx_sp1]))\n out_i = get_path_cell(idx_sp0, idx_sp1,\n self.cellid, self.xcell, self.ycell,\n self.cells_cell, self.nedges_cell,\n self.on_sphere, debug_info)\n out = out + out_i\n idx_sp0 = idx_sp1\n # last path, start from end points P1\n out_n = get_path_cell(idxP1, idx_sp1,\n self.cellid, self.xcell, self.ycell,\n self.cells_cell, self.nedges_cell,\n self.on_sphere, debug_info)\n out = out + out_n.reverse()\n return out","def process_tir_image(ds, data_res, t_thresh=-50, min_mcs_size=5000):\n ctt = (ds['tb']).squeeze()-273.15\n min_pix_nb = min_mcs_size / data_res**2\n\n max_pix_nb = 300000 / data_res**2 # this is to capture satellite artefacts that come in large contiguous stripes.\n labels, goodinds = mcs_define(ctt.values, t_thresh, minmax_area=[min_pix_nb, max_pix_nb]) # 7.7x7.7km = 64km2 per pix in gridsat? 83 pix is 5000km2\n dic = dictionary()\n #plt.figure()\n #plt.pcolormesh(labels)\n #plt.colorbar()\n #plt.show()\n for g in goodinds:\n\n if g==0:\n continue\n\n pos = np.where(labels==g)\n npos = np.where(labels!=g)\n datestr = str(int(ctt['time.year'].values))+'-'+str(int(ctt['time.month'].values)).zfill(2)+'-'+str(int(ctt['time.day'].values)).zfill(2)+'_'+\\\n str(int(ctt['time.hour'].values)).zfill(2)+':'+str(int(ctt['time.minute'].values)).zfill(2)\n \n dic['date'].append(datestr)\n dic['month'].append(int(ctt['time.month']))\n dic['hour'].append(int(ctt['time.hour']))\n dic['year'].append(int(ctt['time.year']))\n dic['day'].append(int(ctt['time.day']))\n dic['minute'].append(int(ctt['time.minute']))\n\n storm = ctt.copy()\n storm.values[npos] = np.nan\n tmin_pos = np.nanargmin(storm.values)\n tpos_2d = np.unravel_index(tmin_pos, storm.shape)\n \n latmin = np.nanmin(ctt.lat.values[pos[0]])\n latmax = np.nanmax(ctt.lat.values[pos[0]])\n lonmin = np.nanmin(ctt.lon.values[pos[1]])\n lonmax = np.nanmax(ctt.lon.values[pos[1]])\n dic['area'].append(np.sum(np.isfinite(storm.values))*data_res**2)\n dic['70area'].append(np.sum(storm.values<=-70)*data_res**2)\n dic['minlon'].append(lonmin)\n dic['minlat'].append(latmin)\n dic['maxlon'].append(lonmax)\n dic['maxlat'].append(latmax)\n dic['clon'].append(lonmin + (lonmax - lonmin)/2)\n dic['clat'].append(latmin + (latmax - latmin)/2)\n dic['tmin'].append(np.nanmin(storm))\n dic['tminlat'].append(float(ctt.lat[tpos_2d[0]].values))\n dic['tminlon'].append(float(ctt.lon[tpos_2d[1]].values))\n dic['tmean'].append(float(np.nanmean(storm)))\n dic['tp1'].append(float(np.nanpercentile(storm, 1)))\n dic['tp99'].append(float(np.nanpercentile(storm, 99)))\n dic['stormID'].append(datestr + '_' + str(g))\n dic['cloudMask'].append(labels==g)\n dic['tir'].append(storm.values)\n\n # for k in dic.keys():\n # print(k, len(dic[k]))\n return dic","def plot_harris_points(image, filtered_coords):\n\n plt.plot()\n plt.imshow(image)\n plt.plot([p[1] for p in filtered_coords],\n [p[0] for p in filtered_coords],\n 'b.')\n plt.axis('off')\n plt.show()","def surface_contacts(struc,SASA):\n\tplot_single = False\n\n\tcmap_cutoff = 5.0 # nm\n\tsasa_cutoff = 0.5\n\t# identify surface residues\n\tS = []\n\tN = np.array(range(struc.n_residues))\n\tfor r in N:\n\t\tind = struc.topology.select('resid '+str(r))\n\t\tSASA_per_res = np.sum(SASA[0][ind[0]:ind[-1]],axis=0)\n\t\tif SASA_per_res > sasa_cutoff:\n\t\t\tS.append(SASA_per_res)\n\t\telse:\n\t\t\tS.append(0.0)\n\t#import ipdb; ipdb.set_trace()\n\tsurf_res = N[np.where(np.array(S) > 0)]\n\tcmap = contact_maps(struc.atom_slice(struc.topology.select('name CA'))[0].xyz[0])\n\tfor n in N:\n\t\tfor m in N:\n\t\t\tif (n not in surf_res or m not in surf_res) or n < m:\n\t\t\t\tcmap[n][m] = 0\n\t\t\telif cmap[n][m] < cmap_cutoff:\n\t\t\t\tcmap[n][m] = 1\n\tif plot_single == True:\n\t\tfor it,rn in enumerate(resnames):\n\t\t\tif rn in hydrophobic:\n\t\t\t\tplt.axhline(y=it,c='grey',linewidth=2)\n\t\t\t\tplt.axvline(x=it,c='grey',linewidth=2)\n\t\t\telif rn in hydrophilic:\n\t\t\t\tplt.axhline(y=it,c='g',linewidth= 2)\n\t\t\t\tplt.axvline(x=it,c='g',linewidth= 2)\n\t\t\telif rn in poscharge:\n\t\t\t\tplt.axhline(y=it,c='b',linewidth= 2)\n\t\t\t\tplt.axvline(x=it,c='b',linewidth= 2)\n\t\t\telif rn in negcharge:\n\t\t\t\tplt.axhline(y=it,c='r',linewidth= 2)\n\t\t\t\tplt.axvline(x=it,c='r',linewidth= 2)\n\t\t\telse:\n\t\t\t\tprint \"unknown restype:\", rn\n\t\tscat = np.array(zip(np.where(np.array(cmap) > 0)[0], np.where(np.array(cmap) > 0)[1])).T\n\t\tplt.scatter(scat[0], scat[1],marker='s',c='k',s=90)\n\t\t#plt.imshow(cmap,cmap='Greys')\n\t\tplt.show()\n\treturn cmap","def get_table_corner_points(img):\n\n img_height, img_width, img_channels = img.shape\n lower_bounds,upper_bounds = get_table_color_bounds() # Get the bounds for the table felt color\n\n \"\"\"\n Table Image Masking\n \"\"\"\n res = cv2.cvtColor(img,cv2.COLOR_BGR2HSV) # Convert image to HSV color space\n mask = cv2.inRange(res,lower_bounds,upper_bounds) # Get image mask from bounds\n res = cv2.bitwise_and(img,img,mask = mask) # Mask the image\n\n \"\"\"\n Contour Detection\n \"\"\"\n imgray = cv2.cvtColor(res,cv2.COLOR_BGR2GRAY) # Get res in gray color space\n tmp,thresh = cv2.threshold(imgray,255,255,255) # Threshold on the gray image\n retr = cv2.RETR_EXTERNAL # Contour parameters\n mode = cv2.CHAIN_APPROX_SIMPLE\n tmp, contours, hierarchy = cv2.findContours(thresh,retr,mode) # Get contours\n res = np.zeros((img_height,img_width,3),np.uint8) # Blank image for contours\n color = (255,255,255) # Contour drawing parameters\n thickness = 3\n cv2.drawContours(res,contours,-1,color,thickness) # Draw contours on blank image\n\n \"\"\"\n Canny Detection\n \"\"\"\n blur = 9 # Blur parameter \n res = cv2.medianBlur(res,blur) # Blur\n res = cv2.Canny(res,100,150,apertureSize = 3) # Canny edge detection\n\n \"\"\"\n Hough Line Detection\n \"\"\"\n rho = 0.75 # Hough parameters\n theta = np.pi/180\n threshold = 150\n lines = cv2.HoughLines(res,rho,theta,threshold) # Get lines\n\n \"\"\"\n K-Mean 4 Line Clustering\n \"\"\"\n criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER,10,1.0) # K-Means parameters\n flags = cv2.KMEANS_PP_CENTERS\n n = 4\n max_iterations = 10 \n compactness,labels,centers = cv2.kmeans(np.float32(lines),n,None,criteria,max_iterations,flags) # K-Means\n \n \"\"\"\n Get And Return Points\n \"\"\"\n growth = 100 # Offset to expand corners\n pts = _get_table_corners_from_lines_hough_space(centers,growth,img_width,img_height) # Gets the corner points\n ''' \n mask = np.zeros((img_height,img_width,3),np.uint8)\n cv2.fillPoly(mask,np.array([pts],dtype = np.int32),(255,255,255))\n show_img(mask)\n cv2.resize(mask,(img.shape[0],img.shape[1]),fx = 2, fy = 2, interpolation = cv2.INTER_CUBIC)\n show_img(mask*2)\n res = cv2.bitwise_and(img,mask)\n '''\n return pts","def plt3dpaint(nppoints, color_map = 'jet', reduce_for_vis = True, voxel_size = 0.2, pointsize = 0.1, subplots = 5):\n assert (type(nppoints) == pclpy.pcl.PointCloud.PointXYZRGB) or (type(nppoints) == pclpy.pcl.PointCloud.PointXYZ) or (type(nppoints) == np.ndarray) or (type(nppoints) is list) or (type(nppoints) is tuple), 'Not valid point_cloud'\n cloudlist = []\n cloudcolors = []\n if (type(nppoints) is not list) & (type(nppoints) is not tuple):\n nppoints = [nppoints]\n \n if len(nppoints) > 1:\n for n,i in enumerate(nppoints):\n workpoints = i\n if (type(workpoints) == pclpy.pcl.PointCloud.PointXYZRGB) or (type(workpoints) == pclpy.pcl.PointCloud.PointXYZ):\n workpoints = workpoints.xyz\n\n if reduce_for_vis:\n workpoints = seg_tree.voxelize(workpoints,voxel_size)\n\n \n cloudmin = np.min(workpoints[:,2])\n cloudmax = np.max(workpoints[:,2])\n \n points = workpoints\n color_coef = n/len(nppoints)/2 + n%2*.5\n if type(color_map) == np.ndarray:\n color = color_map\n elif color_map == 'jet':\n color=cm.jet(color_coef)[:3]\n else:\n color=cm.Set1(color_coef)[:3]\n cloudcolors.append(np.ones_like(workpoints)*color + 0.4*(np.ones_like(workpoints) * ((workpoints[:,2] - cloudmin)/(cloudmax - cloudmin)).reshape(-1,1)-0.5) )\n cloudlist.append(points)\n else:\n workpoints = nppoints[0]\n if (type(workpoints) == pclpy.pcl.PointCloud.PointXYZRGB) or (type(workpoints) == pclpy.pcl.PointCloud.PointXYZ):\n workpoints = workpoints.xyz\n\n if reduce_for_vis:\n workpoints = seg_tree.voxelize(workpoints,voxel_size)\n cloudcolors.append(workpoints[:,2])\n cloudlist.append(workpoints)\n\n plt_pointcloud = np.concatenate(cloudlist)\n plt_colors = np.concatenate(cloudcolors)\n if len(nppoints) > 1:\n plt_colors = np.minimum(plt_colors,np.ones_like(plt_colors))\n plt_colors = np.maximum(plt_colors,np.zeros_like(plt_colors))\n fig = plt.figure(figsize=(30,16) )\n for i in range(subplots):\n ax = fig.add_subplot(1, subplots, i+1, projection='3d')\n ax.view_init(30, 360*i/subplots)\n ax.scatter3D(plt_pointcloud[:,0], plt_pointcloud[:,1], plt_pointcloud[:,2], c=plt_colors, s=pointsize)","def TetrahedralProjection(c1=(0,0,0), c2=(2,0,0), c3=(0,2,0), c4=(0,0,2), points=None, npoints=10, equally_spaced=True):\n\n if points is None or not isinstance(points,np.ndarray):\n if not isinstance(c1,tuple) or not isinstance(c2,tuple) or not isinstance(c3,tuple) \\\n or not isinstance(c4,tuple):\n raise ValueError(\"coordinates should be given in tuples of two elements (x,y)\")\n else:\n c1 = np.array(c1); c2 = np.array(c2); c3 = np.array(c3); c4 = np.array(c4)\n opoints = np.vstack((c1,c2,c3,c4))\n else:\n opoints = points\n\n from scipy.spatial import Delaunay\n from Florence.FunctionSpace import Tet\n from Florence.QuadratureRules.EquallySpacedPoints import EquallySpacedPointsTet\n from Florence.QuadratureRules.FeketePointsTet import FeketePointsTet\n\n if equally_spaced:\n points = EquallySpacedPointsTet(npoints)\n else:\n points = FeketePointsTet(npoints)\n\n BasesTet = np.zeros((4,points.shape[0]),dtype=np.float64)\n hpBases = Tet.hpNodal.hpBases\n for i in range(points.shape[0]):\n BasesTet[:,i] = hpBases(0,points[i,0],points[i,1],points[i,2],\n Transform=1,EvalOpt=1,equally_spaced=equally_spaced)[0]\n makezero(BasesTet,tol=1e-10)\n\n # func = Delaunay(points,qhull_options=\"QJ\") # this does not produce the expected connectivity\n func = Delaunay(points)\n tets = func.simplices\n\n mesh = Mesh()\n mesh.element_type=\"tet\"\n mesh.points = np.dot(BasesTet.T, opoints)\n mesh.elements = tets\n mesh.nelem = mesh.elements.shape[0]\n mesh.nnode = mesh.points.shape[0]\n mesh.GetBoundaryFaces()\n mesh.GetBoundaryEdges()\n\n return mesh","def get_segmented_point_clouds(seg_masks, depth): \n obj_labels = np.unique(seg_masks)\n num_objs = obj_labels.shape[0]+1\n rows, cols = seg_masks.shape\n cm = plt.get_cmap('gist_rainbow')\n colors = [cm(1. * i/num_objs) for i in range(num_objs)]\n \n object_dict = {}\n # key - object label; val - depth array of that object\n for i in obj_labels:\n object_dict[i] = np.zeros((rows,cols), dtype = np.float32)\n\n for i in range(rows):\n for j in range(cols):\n if seg_masks[i][j] != 0 and seg_masks[i][j] != -1:\n object_dict[seg_masks[i][j]][i][j] = depth[i][j]\n \n segmented_pcds = []\n for key, val in object_dict.items():\n if key == -1 or key == 0:\n continue\n img = o3d.geometry.Image(val)\n pcd_from_depth = o3d.geometry.PointCloud.create_from_depth_image(\n img,\n o3d.camera.PinholeCameraIntrinsic(\n o3d.camera.PinholeCameraIntrinsicParameters.PrimeSenseDefault))\n\n # Multiply with Transformation matrix to get correct view of the PCD\n pcd_from_depth.transform([[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0], [0, 0, 0, 1]])\n pcd_from_depth.paint_uniform_color(np.array(colors[key][:3], dtype = np.uint8) * 255)\n segmented_pcds.append(pcd_from_depth)\n return segmented_pcds","def footprint_corner_indices():","def downloadSurroundingStreetView(point, directory, picNum, ptrNum, intersectionPointInfo):\n result = []\n for heading in CONFIG[\"gmap\"][\"headings\"]:\n filename = \"%s/%010d_%s_%s_%s.jpg\" % (directory, picNum, str(point[1]), str(point[0]), heading[0])\n paramDict = GoogleStreetView.makeParameterDict(point[1], point[0], heading[1])\n metadata = GoogleStreetView.getMetadata(paramDict)\n\n result.append([picNum,\n ptrNum,\n str(point[1]) + \",\" + str(point[0]),\n heading[0],\n metadata[\"date\"],\n filename.split(\"/\")[-1],\n \",\".join(intersectionPointInfo[(point[0], point[1])])]\n )\n\n param = GoogleStreetView.makeParameter(point[1], point[0], heading[1])\n GoogleStreetView.downloadStreetView(param, filename)\n picNum += 1\n return result","def ccs4_map(cfg_set_tds,figsize_x=12,figsize_y=12,hillshade=True,radar_loc=True,radar_vis=True):\r\n \r\n ## Load DEM and Swiss borders\r\n shp_path_CH = os.path.join(cfg_set_tds[\"root_path\"],u\"data/shapefile/swissBOUNDARIES3D_1_3_TLM_LANDESGEBIET.shp\")\r\n shp_path_Kantone = os.path.join(cfg_set_tds[\"root_path\"],u\"data/shapefile/swissBOUNDARIES3D_1_3_TLM_KANTONSGEBIET.shp\")\r\n shp_path_count = os.path.join(cfg_set_tds[\"root_path\"],u\"data/shapefile/CCS4_merged_proj_clip_G05_countries.shp\")\r\n dem_path = os.path.join(cfg_set_tds[\"root_path\"],u\"data/DEM/ccs4.png\")\r\n visi_path = os.path.join(cfg_set_tds[\"root_path\"],u\"data/radar/radar_composite_visibility.npy\")\r\n\r\n dem = Image.open(dem_path)\r\n dem = np.array(dem.convert('P'))\r\n\r\n sf_CH = shapefile.Reader(shp_path_CH)\r\n sf_KT = shapefile.Reader(shp_path_Kantone)\r\n sf_ct = shapefile.Reader(shp_path_count)\r\n\r\n ## Setup figure\r\n fig_extent = (255000,965000,-160000,480000)\r\n fig, axes = plt.subplots(1, 1)\r\n fig.set_size_inches(figsize_x, figsize_y)\r\n \r\n ## Plot altitude / hillshading\r\n if hillshade:\r\n ls = colors.LightSource(azdeg=315, altdeg=45)\r\n axes.imshow(ls.hillshade(-dem, vert_exag=0.05),\r\n extent=fig_extent, cmap='gray', alpha=0.5)\r\n else:\r\n axes.imshow(dem*0.6, extent=fig_extent, cmap='gray', alpha=0.5)\r\n \r\n ## Get borders of Cantons\r\n try:\r\n shapes_KT = sf_KT.shapes()\r\n except UnicodeDecodeError:\r\n print(\" *** Warning: No country shape plotted (UnicodeDecodeErrror)\")\r\n else:\r\n for KT_i, shape in enumerate(shapes_KT):\r\n x = np.array([i[0] for i in shape.points[:]])\r\n y = np.array([i[1] for i in shape.points[:]])\r\n endpoint = np.where(x==x[0])[0][1]\r\n x = x[:endpoint]\r\n y = y[:endpoint]\r\n axes.plot(x,y,color='darkred',linewidth=0.5,zorder=5)\r\n\r\n ## Get borders of neighbouring countries\r\n try:\r\n shapes_ct = sf_ct.shapes()\r\n except UnicodeDecodeError:\r\n print(\" *** Warning: No country shape plotted (UnicodeDecodeErrror)\")\r\n else:\r\n for ct_i, shape in enumerate(shapes_ct):\r\n if ct_i in [0,1]:\r\n continue\r\n x = np.array([i[0] for i in shape.points[:]])\r\n y = np.array([i[1] for i in shape.points[:]])\r\n x[x<=255000] = 245000\r\n x[x>=965000] = 975000\r\n y[y<=-159000] = -170000\r\n y[y>=480000] = 490000\r\n if ct_i in [3]:\r\n axes.plot(x[20:170],y[20:170],color='black',linewidth=0.5)\r\n if ct_i in [2]:\r\n ## Delete common border of FR and CH:\r\n x_south = x[y<=86000]; y_south = y[y<=86000]\r\n x_north = x[np.logical_and(np.logical_and(y>=270577,y<=491000),x>510444)]\r\n #x_north = x[np.logical_and(y>=270577,y<=491000)]\r\n y_north = y[np.logical_and(np.logical_and(y>=270577,y<=491000),x>510444)]\r\n #y_north = y[np.logical_and(y>=270577,y<=491000)]\r\n axes.plot(x_south,y_south,color='black',linewidth=0.5,zorder=4)\r\n axes.plot(x_north,y_north,color='black',linewidth=0.5,zorder=4)\r\n if ct_i in [4]:\r\n ## Delete common border of AT and CH:\r\n x_south = x[np.logical_and(x>=831155,y<235000)]\r\n y_south = y[np.logical_and(x>=831155,y<235000)]\r\n #x_north1 = x[np.logical_and(x>=756622,y>=260466)]\r\n x_north1 = x[np.logical_and(np.logical_and(x>=758622,y>=262466),x<=794261)]\r\n #y_north1 = y[np.logical_and(x>=756622,y>=260466)]\r\n y_north1 = y[np.logical_and(np.logical_and(x>=758622,y>=262466),x<=794261)]\r\n y_north2 = y[np.logical_and(np.logical_and(x>=774261,y>=229333),x<=967000)]\r\n x_north2 = x[np.logical_and(np.logical_and(x>=774261,y>=229333),x<=967000)]\r\n y_north2 = np.concatenate([y_north2[np.argmin(x_north2):],y_north2[:np.argmin(x_north2)]])\r\n x_north2 = np.concatenate([x_north2[np.argmin(x_north2):],x_north2[:np.argmin(x_north2)]])\r\n x_LI = x[np.logical_and(np.logical_and(x<=773555,y>=214400),y<=238555)]\r\n y_LI = y[np.logical_and(np.logical_and(x<=773555,y>=214400),y<=238555)]\r\n axes.plot(x_south,y_south,color='black',linewidth=0.5,zorder=4)\r\n axes.plot(x_north1,y_north1,color='black',linewidth=0.5,zorder=4)\r\n axes.plot(x_north2,y_north2,color='black',linewidth=0.5,zorder=4)\r\n axes.plot(x_LI,y_LI,color='black',linewidth=0.5,zorder=4)\r\n else:\r\n continue\r\n #axes.plot(x,y,color='black',linewidth=1,zorder=4)\r\n\r\n ## Get Swiss borders\r\n try:\r\n #shp_records = sf_CH.shapeRecords()\r\n shapes_CH = sf_CH.shapes()\r\n except UnicodeDecodeError:\r\n print(\" *** Warning: No country shape plotted (UnicodeDecodeErrror)\")\r\n else:\r\n for ct_i, shape in enumerate(shapes_CH): #sf_CH.shapeRecords():\r\n if ct_i!=0: continue\r\n x = np.array([i[0]-2000000 for i in shape.points[:]])\r\n y = np.array([i[1]-1000000 for i in shape.points[:]])\r\n endpoint = np.where(x==x[0])[0][1]\r\n x = x[:endpoint]\r\n y = y[:endpoint]\r\n \r\n ## Convert to swiss coordinates\r\n #x,y = lonlat2xy(lon, lat)\r\n axes.plot(x,y,color='darkred',linewidth=1,zorder=3)\r\n\r\n ## Add weather radar locations:\r\n if radar_loc:\r\n weather_radar_y = [237000,142000,100000,135000,190000]\r\n weather_radar_x = [681000,497000,708000,604000,780000]\r\n axes.scatter(weather_radar_x,weather_radar_y,marker=\"D\",#s=2,\r\n color='orange',edgecolor='black',zorder=10)\r\n \r\n ## Add radar visibility:\r\n if radar_vis:\r\n arr_visi = np.load(visi_path)\r\n arr_visi[arr_visi<9000] = 0\r\n arr_visi2 = morph.binary_opening(morph.binary_erosion(arr_visi, structure=np.ones((4,4))), structure=np.ones((4,4)))\r\n arr_visi[arr_visi<9000] = np.nan\r\n axes.imshow(arr_visi, cmap=\"gray\", alpha=0.2, extent=fig_extent)\r\n arr_visi[np.isnan(arr_visi)] = 1\r\n #axes.contour(arr_visi[::-1,:], levels=[2], cmap=\"gray\", linewidths=2,\r\n # linestyle=\"solid\", alpha=0.5, extent=fig_extent)\r\n #arr_visi = arr_visi[::4, ::4]\r\n #ys, xs = np.mgrid[arr_visi.shape[0]:0:-1,\r\n # 0:arr_visi.shape[1]]\r\n #axes.scatter(xs.flatten(), ys.flatten(), s=4,\r\n # c=arr_visi.flatten().reshape(-1, 3), edgecolor='face')\r\n \r\n ## Add further elements:\r\n axes.set_xlim([255000,965000])\r\n axes.set_ylim([-160000,480000])\r\n axes.grid()\r\n axes.set_ylabel(\"CH1903 Northing\")\r\n axes.set_xlabel(\"CH1903 Easting\")\r\n axes.get_xaxis().set_major_formatter( \\\r\n ticker.FuncFormatter(lambda x, p: format(int(x), \",\").replace(',', \"'\")))\r\n axes.get_yaxis().set_major_formatter( \\\r\n ticker.FuncFormatter(lambda x, p: format(int(x), \",\").replace(',', \"'\")))\r\n plt.yticks(rotation=90, verticalalignment=\"center\")\r\n return fig, axes, fig_extent","def create_grid_and_edges(data, drone_altitude, safety_distance):\n # minimum and maximum north coordinates\n north_min = np.floor(np.min(data[:, 0] - data[:, 3]))\n north_max = np.ceil(np.max(data[:, 0] + data[:, 3]))\n\n # minimum and maximum east coordinates\n east_min = np.floor(np.min(data[:, 1] - data[:, 4]))\n east_max = np.ceil(np.max(data[:, 1] + data[:, 4]))\n\n # given the minimum and maximum coordinates we can\n # calculate the size of the grid.\n north_size = int(np.ceil(north_max - north_min))\n east_size = int(np.ceil(east_max - east_min))\n\n # Initialize an empty grid\n grid = np.zeros((north_size, east_size))\n # Initialize an empty list for Voronoi points\n points = []\n # Populate the grid with obstacles\n for i in range(data.shape[0]):\n north, east, alt, d_north, d_east, d_alt = data[i, :]\n if alt + d_alt + safety_distance > drone_altitude:\n obstacle = [\n int(np.clip(north - d_north - safety_distance - north_min, 0, north_size-1)),\n int(np.clip(north + d_north + safety_distance - north_min, 0, north_size-1)),\n int(np.clip(east - d_east - safety_distance - east_min, 0, east_size-1)),\n int(np.clip(east + d_east + safety_distance - east_min, 0, east_size-1)),\n ]\n grid[obstacle[0]:obstacle[1]+1, obstacle[2]:obstacle[3]+1] = 1\n # add center of obstacles to points list\n points.append([north - north_min, east - east_min])\n\n graph = Voronoi(points)\n\n edges = []\n for v in graph.ridge_vertices:\n p1 = graph.vertices[v[0]]\n p2 = graph.vertices[v[1]]\n cells = list(bresenham(int(p1[0]), int(p1[1]), int(p2[0]), int(p2[1])))\n hit = False\n\n for c in cells:\n if np.amin(c) < 0 or c[0] >= grid.shape[0] or c[1] >= grid.shape[1]:\n hit = True\n break\n if grid[c[0], c[1]] == 1:\n hit = True\n break\n\n if not hit:\n p1 = (p1[0], p1[1])\n p2 = (p2[0], p2[1])\n edges.append((p1, p2))\n\n return grid, edges, int(north_min), int(east_min)","def compute_mesh(nrow, ncol, nele):\n tri_index = np.zeros((nele, 3))\n for i in range(nrow-1):\n for j in range(NUM):\n if j == 0:\n tri_index[i*4*NUM+j*4, 0] = (i+1)+(2*j+1)*nrow\n tri_index[i*4*NUM+j*4, 1] = (i+1)\n tri_index[i*4*NUM+j*4, 2] = (i+2)\n\n tri_index[i*4*NUM+j*4+1, 0] = (i+1)+(2*j+1)*nrow\n tri_index[i*4*NUM+j*4+1, 1] = (i+2)\n tri_index[i*4*NUM+j*4+1, 2] = (i+2)+(2*j+1)*nrow\n else:\n tri_index[i*4*NUM+j*4, 0] = (i+1)+(2*j+1)*nrow\n tri_index[i*4*NUM+j*4, 1] = (i+1)+(2*j-1)*nrow\n tri_index[i*4*NUM+j*4, 2] = (i+2)+(2*j-1)*nrow\n\n tri_index[i*4*NUM+j*4+1, 0] = (i+1)+(2*j+1)*nrow\n tri_index[i*4*NUM+j*4+1, 1] = (i+2)+(2*j-1)*nrow\n tri_index[i*4*NUM+j*4+1, 2] = (i+2)+(2*j+1)*nrow\n \n tri_index[i*4*NUM+j*4+2, 0] = (i+1)+2*j*nrow\n tri_index[i*4*NUM+j*4+2, 1] = (i+1)+2*(j+1)*nrow\n tri_index[i*4*NUM+j*4+2, 2] = (i+2)+2*(j+1)*nrow\n\n tri_index[i*4*NUM+j*4+3, 0] = (i+1)+2*j*nrow\n tri_index[i*4*NUM+j*4+3, 1] = (i+2)+2*(j+1)*nrow\n tri_index[i*4*NUM+j*4+3, 2] = (i+2)+2*j*nrow\n return tri_index","def drawShadedContours(xlist, ylist, zmatrix, levels):\n dislin.conshd(xlist, len(xlist), ylist, len(ylist), zmatrix, levels, len(levels))","def plot_vor(self,x,ax,tri=False):\n\n L = self.L\n grid_x, grid_y = np.mgrid[-1:2, -1:2]\n grid_x[0, 0], grid_x[1, 1] = grid_x[1, 1], grid_x[0, 0]\n grid_y[0, 0], grid_y[1, 1] = grid_y[1, 1], grid_y[0, 0]\n y = np.vstack([x + np.array([i * L, j * L]) for i, j in np.array([grid_x.ravel(), grid_y.ravel()]).T])\n\n c_types_print = np.tile(self.c_types,9)\n bleed = 0.1\n c_types_print = c_types_print[(y<L*(1+bleed)).all(axis=1)+(y>-L*bleed).all(axis=1)]\n y = y[(y<L*(1+bleed)).all(axis=1)+(y>-L*bleed).all(axis=1)]\n regions, vertices = self.voronoi_finite_polygons_2d(Voronoi(y))\n\n\n ax.set(aspect=1,xlim=(0,self.L),ylim=(0,self.L))\n if type(self.c_types) is list:\n # ax.scatter(x[:, 0], x[:, 1],color=\"grey\",zorder=1000)\n for region in regions:\n polygon = vertices[region]\n plt.fill(*zip(*polygon), alpha=0.4, color=\"grey\")\n\n else:\n cols = self.cols\n if self.plot_scatter is True:\n for j,i in enumerate(np.unique(self.c_types)):\n ax.scatter(x[self.c_types==i, 0], x[self.c_types==i, 1],color=cols[i],zorder=1000)\n patches = []\n for i, region in enumerate(regions):\n patches.append(Polygon(vertices[region], True,facecolor=cols[c_types_print[i]],ec=(1,1,1,1)))\n\n p = PatchCollection(patches, match_original=True)\n # p.set_array(c_types_print)\n ax.add_collection(p)\n if tri is not False:\n for TRI in tri:\n for j in range(3):\n a, b = TRI[j], TRI[np.mod(j + 1, 3)]\n if (a >= 0) and (b >= 0):\n X = np.stack((x[a], x[b])).T\n ax.plot(X[0], X[1], color=\"black\")","def _plot_sr_surface(self, varname):\n\n fig = plt.figure()\n varname = self.layer_lookup[varname]\n data = self.node_data[varname]\n x_node_loc = np.arange(self.mins[0], self.maxs[0], self.min_grid_size) + self.min_grid_size/2\n y_node_loc = np.arange(self.mins[1], self.maxs[1], self.min_grid_size) + self.min_grid_size/2\n lon2d, lat2d = np.meshgrid(x_node_loc, y_node_loc)\n\n # mask NaN values\n data_m = np.ma.array(data, mask=np.isnan(data))\n plt.pcolormesh(lon2d, lat2d, data_m.T, vmin=data_m.min(), vmax=data_m.max())","def make_hexgrid_for_tract(tract_info, spacing_pixels=64, rng=None):\n if not isinstance(rng, np.random.RandomState):\n rng = np.random.RandomState(seed=rng)\n\n # compute the dimensions of the tract\n dimx = tract_info.getBBox().getDimensions().x\n dimy = tract_info.getBBox().getDimensions().y\n nx = int(dimx / spacing_pixels * np.sqrt(2) * 1.05)\n # the factor of 0.866 makes sure the grid is square-ish\n ny = int(dimy / spacing_pixels * np.sqrt(2) * 1.05 / 0.8660254)\n\n # make a base grid\n # here the spacing between grid centers is 1\n v, _ = create_hex_grid(nx=nx, ny=ny, rotate_deg=rng.uniform() * 365)\n\n # convert the spacing to right number of pixels\n # we also recenter the grid since it comes out centered at 0,0\n v *= spacing_pixels\n v[:, 0] += (dimx / 2)\n v[:, 1] += (dimy / 2)\n\n # now cut to things in the tract\n # this is done with\n # 1. an initial cut of the pixel location\n # 2. transforming to ra,dec and using the sky polygon\n # cut 1\n msk = (\n (v[:, 0] >= 0)\n & (v[:, 0] < dimx)\n & (v[:, 1] >= 0)\n & (v[:, 1] < dimy)\n )\n v = v[msk, :]\n\n # cut 2\n wcs = tract_info.getWcs()\n ra, dec = wcs.pixelToSkyArray(v[:, 0], v[:, 1], degrees=True)\n cvx = tract_info.getOuterSkyPolygon()\n msk = np.array([\n cvx.contains(geom.SpherePoint(ra[i], dec[i], geom.degrees).getVector())\n for i in range(len(ra))\n ])\n ra = ra[msk]\n dec = dec[msk]\n v = v[msk, :]\n\n grid_data = np.zeros(v.shape[0], dtype=[\n (\"ra\", \"f8\"),\n (\"dec\", \"f8\"),\n (\"x\", \"f8\"),\n (\"y\", \"f8\")\n ])\n grid_data[\"ra\"] = ra\n grid_data[\"dec\"] = dec\n grid_data[\"x\"] = v[:, 0]\n grid_data[\"y\"] = v[:, 1]\n\n return grid_data","def tsne_points(feature_matrix: np.array, perplexity: int) -> list:\n number_of_t_sne_components = 2\n number_of_t_sne_iterations = 1000\n t_sne_metric = \"manhattan\"\n\n tsne = TSNE(\n n_components=number_of_t_sne_components,\n perplexity=perplexity,\n n_iter=number_of_t_sne_iterations,\n metric=t_sne_metric,\n )\n results = tsne.fit_transform(feature_matrix)\n\n # This is where my hacky plotting script makes us do unseemly things.\n tsne_1 = results[:, 0]\n tsne_2 = results[:, 1]\n plottable_list_form = []\n for idx in range(len(tsne_1)):\n plottable_list_form.append((tsne_1[idx], tsne_2[idx]))\n\n return plottable_list_form","def get_element_for_location(self, points):\n verts = np.zeros((points.shape[0], 4, 3))\n bc = np.zeros((points.shape[0], 4))\n tetras = np.zeros(points.shape[0], dtype=\"int64\")\n inside = np.zeros(points.shape[0], dtype=bool)\n npts = 0\n npts_step = int(1e4)\n # break into blocks of 10k points\n while npts < points.shape[0]:\n\n cell_index = np.array(\n self.aabb_grid.position_to_cell_index(points[: npts + npts_step, :])\n )\n inside = self.aabb_grid.inside(points[: npts + npts_step, :])\n global_index = (\n cell_index[:, 0]\n + self.aabb_grid.nsteps_cells[None, 0] * cell_index[:, 1]\n + self.aabb_grid.nsteps_cells[None, 0]\n * self.aabb_grid.nsteps_cells[None, 1]\n * cell_index[:, 2]\n )\n\n tetra_indices = self.aabb_table[global_index[inside], :].tocoo()\n # tetra_indices[:] = -1\n row = tetra_indices.row\n col = tetra_indices.col\n # using returned indexes calculate barycentric coords to determine which tetra the points are in\n vertices = self.nodes[self.elements[col, :4]]\n pos = points[row, :]\n vap = pos[:, :] - vertices[:, 0, :]\n vbp = pos[:, :] - vertices[:, 1, :]\n # # vcp = p - points[:, 2, :]\n # # vdp = p - points[:, 3, :]\n vab = vertices[:, 1, :] - vertices[:, 0, :]\n vac = vertices[:, 2, :] - vertices[:, 0, :]\n vad = vertices[:, 3, :] - vertices[:, 0, :]\n vbc = vertices[:, 2, :] - vertices[:, 1, :]\n vbd = vertices[:, 3, :] - vertices[:, 1, :]\n\n va = np.einsum(\"ij, ij->i\", vbp, np.cross(vbd, vbc, axisa=1, axisb=1)) / 6.0\n vb = np.einsum(\"ij, ij->i\", vap, np.cross(vac, vad, axisa=1, axisb=1)) / 6.0\n vc = np.einsum(\"ij, ij->i\", vap, np.cross(vad, vab, axisa=1, axisb=1)) / 6.0\n vd = np.einsum(\"ij, ij->i\", vap, np.cross(vab, vac, axisa=1, axisb=1)) / 6.0\n v = np.einsum(\"ij, ij->i\", vab, np.cross(vac, vad, axisa=1, axisb=1)) / 6.0\n c = np.zeros((va.shape[0], 4))\n c[:, 0] = va / v\n c[:, 1] = vb / v\n c[:, 2] = vc / v\n c[:, 3] = vd / v\n # inside = np.ones(c.shape[0],dtype=bool)\n mask = np.all(c >= 0, axis=1)\n\n verts[: npts + npts_step, :, :][row[mask], :, :] = vertices[mask, :, :]\n bc[: npts + npts_step, :][row[mask], :] = c[mask, :]\n tetras[: npts + npts_step][row[mask]] = col[mask]\n inside[: npts + npts_step][row[mask]] = True\n npts += npts_step\n return verts, bc, tetras, inside","def plot(sigma, strikes, dips):\n values, vectors = principal(sigma)\n sigma1, sigma2, sigma3 = vectors\n\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='stereonet')\n plt.hold(True)\n ax.density_contourf(strikes, dips)\n #ax.pole(strikes, dips, 'b.')\n ax.line(sigma1[0],sigma1[1], 'r^', label='sigma1', markersize=18)\n ax.line(sigma2[0],sigma2[1], 'g^', label='sigma2', markersize=18)\n ax.line(sigma3[0],sigma3[1], 'b^', label='sigma3', markersize=18)","def plot_harris_points(image, filtered_coords):\n plt.figure()\n plt.imshow(image)\n plt.plot([p[1] for p in filtered_coords], [p[0] for p in filtered_coords], 'r*')\n plt.axis('off')\n plt.title('harris points')\n plt.show()","def plotTsneE_3D(datadf,level,descname,v,path_output,Efilter,own_cmap,clustermethod=\"kmeans\",onlyShow=False,selected=False):\n\n if not selected:\n datadf = datadf[datadf[\"{}Energy\".format(level)]<=Efilter].sort_values(by=\"{}_{}_klabel\".format(level,descname))\n\n klabels = datadf[\"{}_{}_klabel\".format(level,descname)].astype(str)\n fig = px.scatter_3d(data_frame=datadf,\n z=\"{}Energy\".format(level),\n x=\"{}_{}_tsne1\".format(level,descname),\n y=\"{}_{}_tsne2\".format(level,descname),\n color=klabels,\n color_discrete_sequence=own_cmap,\n size=\"GyRadius\",\n opacity=0.9,\n #symbol=\"symbol\", # Use if needed in Jupyter\n hover_name=datadf.index,\n title=\"{}'s' t-SNE + {}Energy\".format(descname,level),\n #range_z=[-36,-20],\n width= 1200,\n height= 900)\n\n\n if onlyShow:\n fig.show()\n elif selected:\n fig.write_html(\"{}/{}_{}_EtSNE_selected.html\".format(path_output,level,descname))\n else:\n fig.write_html(\"{}/{}_{}_EtSNE.html\".format(path_output,level,descname))","def detect(image):\n markers = []\n # Stage 1: Detect edges in image\n gray = cvtColor(image, COLOR_BGR2GRAY)\n clahe = createCLAHE(clipLimit=1, tileGridSize=(6, 6))\n cl1 = clahe.apply(gray)\n _, thresh = threshold(cl1, 60, 255, THRESH_OTSU)\n blurred = GaussianBlur(thresh, (5, 5), 0)\n edges = Canny(blurred, 75, 100)\n\n # Stage 2: Find contours\n contours = findContours(edges, RETR_TREE, CHAIN_APPROX_SIMPLE)\n contours = sorted(contours, key=contourArea, reverse=True)[:]\n\n for contour in contours:\n # Stage 3: Shape check\n perimeter = arcLength(contour, True)\n approx = approxPolyDP(contour, 0.01*perimeter, True)\n\n if len(approx) == QUADRILATERAL_POINTS:\n area = contourArea(approx)\n # (x, y, w, h) = boundingRect(approx)\n # ar = float(h) / float(w)\n # if area > 100 and ar >= 0.8 and ar <= 1.2:\n if area > 700:\n # putText(image, str(area), (10, 30), FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)\n drawContours(image, [contour], -1, (0, 255, 0), 1)\n\n # Stage 4: Perspective warping\n topdown_quad = get_topdown_quad(thresh, approx.reshape(4, 2))\n\n # Stage 5: Border check\n if topdown_quad[int((topdown_quad.shape[0]/100.0)*5), int((topdown_quad.shape[1]/100.0)*5)] > BLACK_THRESHOLD:\n continue\n\n # Stage 6: Get marker pattern\n marker_pattern = None\n\n try:\n marker_pattern = get_marker_pattern(topdown_quad, THRESHOLD_PERCENT)\n except:\n continue\n\n if not marker_pattern:\n continue\n\n # Stage 7: Match marker pattern\n marker_found, marker_rotation, marker_name = match_marker_pattern(marker_pattern)\n\n if marker_found:\n markers.append([marker_name, marker_rotation])\n\n return markers, image","def segmentRender(all_data_endo, all_data_epi, apex_pt, basal_pt, septal_pts, origin, transform, landmarks=True, ax=None, scar=None):\n\tif not ax:\n\t\tfig = mplt.figure()\n\t\tax = fig.add_subplot(111, projection='3d')\n\tdata_endo, data_epi, _, _, _ = meshhelper.prepData(all_data_endo, all_data_epi, apex_pt, basal_pt, septal_pts)\n\t# Subtract origin and transform data\n\tapex_transform = np.dot((apex_pt - origin), np.transpose(transform))\n\tbasal_transform = np.dot((basal_pt - origin), np.transpose(transform))\n\tseptal_transform1 = np.dot((septal_pts[0, :] - origin), np.transpose(transform))\n\tseptal_transform2 = np.dot((septal_pts[1, :] - origin), np.transpose(transform))\n\tseptal_transform3 = np.dot((septal_pts[2, :] - origin), np.transpose(transform))\n\t# Set up bins as the unique data in all_data_endo third column (the slices)\n\tbins = np.unique(all_data_endo[:, 2])\n\tfor jz in range(bins.size):\n\t\t# Get the indices that match the current bin and append then append the first value\n\t\ttracing = np.where(all_data_endo[:, 2] == bins[jz])[0]\n\t\ttracing = np.append(tracing, tracing[0])\n\t\t# Pull x, y, z from endo and epi and plot\n\t\tx = data_endo[tracing, 2]\n\t\ty = data_endo[tracing, 1]\n\t\tz = data_endo[tracing, 0]\n\t\tax.plot(x, y, -z, 'y-')\n\t\t# Epi plotting\n\t\tx = data_epi[tracing, 2]\n\t\ty = data_epi[tracing, 1]\n\t\tz = data_epi[tracing, 0]\n\t\tax.plot(x, y, -z, 'c-')\n\tif landmarks:\n\t\t# Plot the apex, basal, and septal points\n\t\tab = np.array([apex_transform, basal_transform])\n\t\tsi = np.array([septal_transform2, septal_transform3])\n\t\t\n\t\tax.plot(ab[:, 2], ab[:, 1], -ab[:, 0], 'k-.')\n\t\tax.scatter(si[:, 2], si[:, 1], -si[:, 0], 'bo', s=50)\n\t\tax.scatter(septal_transform1[2], septal_transform1[1], -septal_transform1[0], 'ro', s=50)\n\t\n\treturn(ax)","def ShowOneContour(index,all_images,all_pointing,thex0,they0,all_titles,object_name,all_expo,dir_top_img,all_filt,figname):\n plt.figure(figsize=(15,6))\n spec_index_min=100 # cut the left border\n spec_index_max=1900 # cut the right border\n star_halfwidth=70\n \n YMIN=-15\n YMAX=15\n \n figfilename=os.path.join(dir_top_img,figname) \n \n #center is approximately the one on the original raw image (may be changed)\n #x0=int(all_pointing[index][0])\n x0=int(thex0[index])\n \n \n # Extract the image \n full_image=np.copy(all_images[index])\n \n # refine center in X,Y\n star_region_X=full_image[:,x0-star_halfwidth:x0+star_halfwidth]\n \n profile_X=np.sum(star_region_X,axis=0)\n profile_Y=np.sum(star_region_X,axis=1)\n\n NX=profile_X.shape[0]\n NY=profile_Y.shape[0]\n \n X_=np.arange(NX)\n Y_=np.arange(NY)\n \n avX,sigX=weighted_avg_and_std(X_,profile_X**4) # take squared on purpose (weigh must be >0)\n avY,sigY=weighted_avg_and_std(Y_,profile_Y**4)\n \n x0=int(avX+x0-star_halfwidth)\n \n \n # find the center in Y on the spectrum\n yprofile=np.sum(full_image[:,spec_index_min:spec_index_max],axis=1)\n y0=np.where(yprofile==yprofile.max())[0][0]\n\n # cut the image in vertical and normalise by exposition time\n reduc_image=full_image[y0-20:y0+20,x0:spec_index_max]/all_expo[index] \n reduc_image[:,0:100]=0 # erase central star\n \n X_Size_Pixels=np.arange(0,reduc_image.shape[1])\n Y_Size_Pixels=np.arange(0,reduc_image.shape[0])\n Transverse_Pixel_Size=Y_Size_Pixels-int(float(Y_Size_Pixels.shape[0])/2.)\n \n # calibration in wavelength\n #grating_name=all_filt[index].replace('dia ','')\n grating_name=get_disperser_filtname(all_filt[index])\n \n lambdas=Pixel_To_Lambdas(grating_name,X_Size_Pixels,all_pointing[index],True)\n \n #if grating_name=='Ron200':\n # holo = Hologram('Ron400',verbose=True)\n #else: \n # holo = Hologram(grating_name,verbose=True)\n #lambdas=holo.grating_pixel_to_lambda(X_Size_Pixels,all_pointing[index])\n #if grating_name=='Ron200':\n # lambdas=lambdas*2.\n \n\n X,Y=np.meshgrid(lambdas,Transverse_Pixel_Size) \n T=np.transpose(reduc_image)\n \n \n plt.contourf(X, Y, reduc_image, 100, alpha=1., cmap='jet',origin='lower')\n C = plt.contour(X, Y, reduc_image , 20, colors='black', linewidth=.5,origin='lower')\n \n \n for line in LINES:\n if line == O2 or line == HALPHA or line == HBETA or line == HGAMMA:\n plt.plot([line['lambda'],line['lambda']],[YMIN,YMAX],'-',color='lime',lw=0.5)\n plt.text(line['lambda'],YMAX-3,line['label'],verticalalignment='bottom', horizontalalignment='center',color='lime', fontweight='bold',fontsize=16)\n \n \n \n plt.axis([X.min(), X.max(), Y.min(), Y.max()]); plt.grid(True)\n plt.title(all_titles[index])\n plt.grid(color='white', ls='solid')\n plt.text(200,-5.,all_filt[index],verticalalignment='bottom', horizontalalignment='center',color='yellow', fontweight='bold',fontsize=16)\n plt.xlabel('$\\lambda$ (nm)')\n plt.ylabel('pixels')\n plt.ylim(YMIN,YMAX)\n plt.xlim(0.,1200.)\n plt.savefig(figfilename)","def point1(source, ants, elmin=15.0, showGUI=True, zoom=1, mode=0, \n nextSource=None, writeFITS=True, brightness=50,isInner=False,\n subtractBackground=False, ncoadd=1, dazbkg=2.0, centroidLoopMax=16,\n minsamples=None):\n global previous_source_\n antlist = helpers.makeList(ants)\n el = elevation(source)\n \n # Check for source too low, and bail out if it is\n if el < elmin:\n print 'Skipping %s because elevation(%.1f) is less than limit(%.1f)' \\\n %(source,el,elmin)\n return\n \n # Check for maximum elevation as well\n maxelLimit = 87.0\n if el > maxelLimit:\n print 'Skipping %s because elevation(%.1f) is greater than limit(%.1f)' \\\n %(source,el,maxelLimit)\n return\n\n # Print message\n msg = \"Pointing on %s at el=%5.1f (elmin = %5.1f); ants = %s\" % (source, el, elmin, str(ants))\n print msg\n SAC.scriptlog(msg)\n \n d = distance(source,previous_source_)\n print \" Distance from %s to %s is %.1f deg\" %(previous_source_,source,d)\n if mode > 0:\n if nextSource != None:\n print \" Next source will be %s\" % nextSource\n else:\n print \" Last source.\"\n # Send all antennas tracking to new source, even though some are\n # already there.\n if isInner :\n SAC.track(source)\n else : SAC.track(source, antlist, phaseCenter=False, waiton=SAC.NONE)\n antsTodo = antlist\n while len(antsTodo) > 0 :\n r = SAC.wait(SAC.TRACK, antsTodo, waiton=SAC.ANY)\n antsReady = r.ready\n antsTodo = r.notready\n for i in antsReady :\n show(source)\n #print \"Loading camera on antenna %d\" %i\n opticalSystem(i, auto=True, object=source, repeat=4, zoom=zoom,\n showGUI=showGUI, dontClose=True, \n brightness=brightness, ncoadd=ncoadd, dazbkg=dazbkg,\n subtractBackground=subtractBackground, \n centroidLoopMax=centroidLoopMax, minsamples=minsamples)\n # now that this ant is done, send it to next source\n if mode > 0:\n if nextSource != None: \n if isInner : SAC.track(nextSource)\n else : SAC.track(nextSource, i, waiton=SAC.NONE)\n previous_source_ = source","def ray_label_simplex(grid, simplex, thresh):\n coords = [grid[:,x] for x in simplex]\n dist = squareform(pdist(coords,'euclidean'))\n adjacency = dist<thresh\n adjacency = adjacency.astype(int) \n graph = csr_matrix(adjacency)\n n_components, labels = connected_components(csgraph=graph, directed=False, return_labels=True)\n\n return n_components","def create_grid_and_edges(data, drone_altitude, safety_distance):\n\n # minimum and maximum north coordinates\n north_min = np.floor(np.min(data[:, 0] - data[:, 3]))\n north_max = np.ceil(np.max(data[:, 0] + data[:, 3]))\n\n # minimum and maximum east coordinates\n east_min = np.floor(np.min(data[:, 1] - data[:, 4]))\n east_max = np.ceil(np.max(data[:, 1] + data[:, 4]))\n\n # given the minimum and maximum coordinates we can\n # calculate the size of the grid.\n north_size = int(np.ceil((north_max - north_min)))\n east_size = int(np.ceil((east_max - east_min)))\n\n # Initialize an empty grid\n grid = np.zeros((north_size, east_size))\n\n # Define a list to hold Voronoi points\n points = []\n # Populate the grid with obstacles\n for i in range(data.shape[0]):\n north, east, alt, d_north, d_east, d_alt = data[i, :]\n\n if alt + d_alt + safety_distance > drone_altitude:\n obstacle = [\n int(north - d_north - safety_distance - north_min),\n int(north + d_north + safety_distance - north_min),\n int(east - d_east - safety_distance - east_min),\n int(east + d_east + safety_distance - east_min),\n ]\n grid[obstacle[0]:obstacle[1] + 1, obstacle[2]:obstacle[3] + 1] = 1\n\n # add center of obstacles to points list\n points.append([north - north_min, east - east_min])\n\n # create a voronoi graph based on\n # location of obstacle centres\n graph = Voronoi(points)\n # check each edge from graph.ridge_vertices for collision\n edges = []\n for v in graph.ridge_vertices:\n p1 = graph.vertices[v[0]].astype(int)\n p2 = graph.vertices[v[1]].astype(int)\n # test each pair p1 and p2 for collision using Bresenham\n # If the edge does not hit an obstacle add it to the list\n in_collision = False\n ridgeline = bresenham(p1[0], p1[1], p2[0], p2[1])\n for b in ridgeline:\n # eliminate out of range points in the line\n if b[0] < 0 or b[0] >= grid.shape[0]:\n in_collision = True\n break\n if b[1] < 0 or b[1] >= grid.shape[1]:\n in_collision = True\n break\n # check if grid cell is an obstacle\n if grid[b[0], b[1]] == 1:\n in_collision = True\n break\n # keep ridge points not in collision\n if not in_collision:\n p1 = (p1[0], p1[1])\n p2 = (p2[0], p2[1])\n edges.append((p1, p2))\n\n return grid, edges","def phosphorene_4band():\n a = 0.222\n ax = 0.438\n ay = 0.332\n theta = 96.79 * (pi / 180)\n phi = 103.69 * (pi / 180)\n\n lat = pb.Lattice(a1=[ax, 0], a2=[0, ay])\n\n h = a * sin(phi - pi / 2)\n s = 0.5 * ax - a * cos(theta / 2)\n lat.add_sublattices(\n ('A', [-s/2, -ay/2, h], 0),\n ('B', [ s/2, -ay/2, 0], 0),\n ('C', [-s/2 + ax/2, 0, 0], 0),\n ('D', [ s/2 + ax/2, 0, h], 0)\n )\n\n lat.register_hopping_energies({\n 't1': -1.22,\n 't2': 3.665,\n 't3': -0.205,\n 't4': -0.105,\n 't5': -0.055\n })\n\n lat.add_hoppings(\n # t1\n ([-1, 0], 'A', 'D', 't1'),\n ([-1, -1], 'A', 'D', 't1'),\n ([ 0, 0], 'B', 'C', 't1'),\n ([ 0, -1], 'B', 'C', 't1'),\n # t2\n ([ 0, 0], 'A', 'B', 't2'),\n ([ 0, 0], 'C', 'D', 't2'),\n # t3\n ([ 0, 0], 'A', 'D', 't3'),\n ([ 0, -1], 'A', 'D', 't3'),\n ([ 1, 1], 'C', 'B', 't3'),\n ([ 1, 0], 'C', 'B', 't3'),\n # t4\n ([ 0, 0], 'A', 'C', 't4'),\n ([ 0, -1], 'A', 'C', 't4'),\n ([-1, 0], 'A', 'C', 't4'),\n ([-1, -1], 'A', 'C', 't4'),\n ([ 0, 0], 'B', 'D', 't4'),\n ([ 0, -1], 'B', 'D', 't4'),\n ([-1, 0], 'B', 'D', 't4'),\n ([-1, -1], 'B', 'D', 't4'),\n # t5\n ([-1, 0], 'A', 'B', 't5'),\n ([-1, 0], 'C', 'D', 't5')\n )\n\n return lat","def test_plot_mesh(self):\n plt.close('all')\n\n #\n # Initialize\n #\n fig, ax = plt.subplots(3,3)\n plot = Plot()\n #\n # Define mesh\n # \n mesh = Mesh.newmesh(grid_size=(2,2))\n mesh.refine() \n mesh.root_node().children[1,1].mark(1)\n mesh.refine(1)\n \n # Plot simple mesh\n ax[0,0] = plot.mesh(ax[0,0], mesh)\n \n #\n # Flag a few cells\n # \n mesh.unmark(nodes=True)\n mesh.root_node().children[0,0].mark(2)\n mesh.root_node().children[1,0].mark(1)\n mesh.root_node().children[1,1].children['SW'].mark(3)\n mesh.root_node().children[1,1].children['NE'].mark(3)\n \n # Color flagged cells\n ax[0,1] = plot.mesh(ax[0,1], mesh, color_marked=[1,2,3], nested=True)\n \n # Plot vertex numbers\n ax[0,2] = plot.mesh(ax[0,2], mesh, vertex_numbers=True)\n \n # Plot edge numbers\n ax[1,0] = plot.mesh(ax[1,0], mesh, edge_numbers=True)\n \n # Plot cell numbers nested off\n mesh.refine(2)\n ax[1,1] = plot.mesh(ax[1,1], mesh, cell_numbers=True)\n \n # Plot cell numbers nested on\n ax[1,2] = plot.mesh(ax[1,2], mesh, cell_numbers=True, nested=True)\n\n # Plot dofs\n element = QuadFE(2,'Q1')\n ax[2,0] = plot.mesh(ax[2,0], mesh, element=element, dofs=True)\n \n # Assign dofs in a nested way\n ax[2,1] = plot.mesh(ax[2,1], mesh, element=element, dofs=True, \\\n nested=True)\n \n # Display only dofs of flagged nodes \n ax[2,2] = plot.mesh(ax[2,2], mesh, element=element, dofs=True, \\\n node_flag=3, nested=True, show_axis=True)","def plot_3d(trj: TrajaDataFrame, **kwargs) -> matplotlib.collections.PathCollection:\n\n fig = plt.figure()\n ax = fig.add_subplot(111, projection=\"3d\")\n ax.set_xlabel(\"x\", fontsize=15)\n ax.set_zlabel(\"time\", fontsize=15)\n ax.set_ylabel(\"y\", fontsize=15)\n title = kwargs.pop(\"title\", \"Trajectory\")\n ax.set_title(f\"{title}\", fontsize=20)\n ax.plot(trj.x, trj.y, trj.index)\n cmap = kwargs.pop(\"cmap\", \"winter\")\n cm = plt.get_cmap(cmap)\n NPOINTS = len(trj)\n ax.set_prop_cycle(color=[cm(1.0 * i / (NPOINTS - 1)) for i in range(NPOINTS - 1)])\n for i in range(NPOINTS - 1):\n ax.plot(trj.x[i : i + 2], trj.y[i : i + 2], trj.index[i : i + 2])\n\n dist = kwargs.pop(\"dist\", None)\n if dist:\n ax.dist = dist\n labelpad = kwargs.pop(\"labelpad\", None)\n if labelpad:\n from matplotlib import rcParams\n\n rcParams[\"axes.labelpad\"] = labelpad\n\n return ax","def tSNE_plot3(features, labels):\n model = TSNE(n_components=3, random_state=0)\n transformed = model.fit_transform(features)\n\n print(\"Data transformed, now plotting...\")\n\n # Plotting\n x = transformed[:, 0]\n y = transformed[:, 1]\n z = transformed[:, 2]\n colors = labels\n\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n ax.scatter(x, y, z, s=20, c=colors, depthshade=True)\n plt.show()","def point_spatial_transformer(x, single=False, sdt_vol_resize=1):\n\n # surface_points is a N x D or a N x (D+1) Tensor\n # trf is a *volshape x D Tensor\n surface_points, trf = x\n trf = trf * sdt_vol_resize\n surface_pts_D = surface_points.get_shape().as_list()[-1]\n trf_D = trf.get_shape().as_list()[-1]\n assert surface_pts_D in [trf_D, trf_D + 1]\n\n if surface_pts_D == trf_D + 1:\n li_surface_pts = K.expand_dims(surface_points[..., -1], -1)\n surface_points = surface_points[..., :-1]\n\n # just need to interpolate.\n # at each location determined by surface point, figure out the trf...\n # note: if surface_points are on the grid, gather_nd should work as well\n fn = lambda x: ne.utils.interpn(x[0], x[1])\n diff = tf.map_fn(fn, [trf, surface_points], dtype=tf.float32)\n ret = surface_points + diff\n\n if surface_pts_D == trf_D + 1:\n ret = tf.concat((ret, li_surface_pts), -1)\n\n return ret","def plot_contours(clf, points,labels):\n def make_meshgrid(x, y,h=0.02):\n \"\"\"Create a mesh of points to plot in\n Parameters\n ----------\n x: data to base x-axis meshgrid on\n y: data to base y-axis meshgrid on\n h: stepsize for meshgrid, optional\n Returns\n -------\n xx, yy : ndarray\n \"\"\"\n x_min, x_max = x.min() - 1, x.max() + 1\n y_min, y_max = y.min() - 1, y.max() + 1\n xx, yy = np.meshgrid(np.arange(x_min, x_max, h),\n np.arange(y_min, y_max, h))\n return xx, yy\n X0, X1 = points[:, 0], points[:, 1]\n xx, yy = make_meshgrid(X0, X1,0.5)\n Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])\n Z = Z.reshape(xx.shape)\n #VISUALIZATION OF DECISION\n fig2 = plt.figure(figsize=(5,5))\n ax = fig2.add_subplot(1,1,1)\n out = plt.contourf(xx, yy, Z, cmap=plt.cm.coolwarm, alpha=0.8)\n ax.scatter(X0, X1, c=labels, cmap=plt.cm.coolwarm, s=80, edgecolors='k')\n ax.scatter(X0[clf.support_],X1[clf.support_],c=labels[clf.support_], cmap=plt.cm.coolwarm, s=80, edgecolors='w')\n ax.set_xlim(xx.min(), xx.max())\n ax.set_ylim(yy.min(), yy.max())\n plt.show()\n return out","def trip_grid(\n trj: TrajaDataFrame,\n bins: Union[tuple, int] = 10,\n log: bool = False,\n spatial_units: str = None,\n normalize: bool = False,\n hist_only: bool = False,\n **kwargs,\n) -> Tuple[np.ndarray, PathCollection]:\n after_plot_args, kwargs = _get_after_plot_args(**kwargs)\n\n bins = traja.trajectory._bins_to_tuple(trj, bins)\n # TODO: Add kde-based method for line-to-cell gridding\n df = trj[[\"x\", \"y\"]].dropna()\n\n # Set aspect if `xlim` and `ylim` set.\n if \"xlim\" in kwargs and \"ylim\" in kwargs:\n xlim, ylim = kwargs.pop(\"xlim\"), kwargs.pop(\"ylim\")\n else:\n xlim, ylim = traja.trajectory._get_xylim(df)\n xmin, xmax = xlim\n ymin, ymax = ylim\n\n x, y = zip(*df.values)\n\n hist, x_edges, y_edges = np.histogram2d(\n x, y, bins, range=((xmin, xmax), (ymin, ymax)), normed=normalize\n )\n\n # rotate to keep y as first dimension\n hist = np.rot90(hist)\n\n if log:\n hist = np.log(hist + np.e)\n if hist_only: # TODO: Evaluate potential use cases or remove\n return (hist, None)\n fig, ax = plt.subplots()\n\n image = ax.imshow(\n hist, interpolation=\"bilinear\", aspect=\"equal\", extent=[xmin, xmax, ymin, ymax]\n )\n # TODO: Adjust colorbar ytick_labels to correspond with time\n label = \"Frames\" if not log else \"$ln(frames)$\"\n plt.colorbar(image, ax=ax, label=label)\n\n _label_axes(trj, ax)\n\n plt.title(\"Time spent{}\".format(\" (Logarithmic)\" if log else \"\"))\n\n _process_after_plot_args(**after_plot_args)\n # TODO: Add method for most common locations in grid\n # peak_index = unravel_index(hist.argmax(), hist.shape)\n return hist, image","def teselado(self,points):\n #muestrea todo el espacio de la envolvente para conseguir las fronteras de decision a intervalos regulares \n #get_hull\n area = boundingbox(points)\n #(min_x,min_y),(max_x,min_y),(max_x,max_y),(min_x,max_y)\n #sample inside hull\n lat_sample = np.arange(min_y, max_y, 0.001).tolist()\n lon_sample = np.arange(min_x,max_x, 0.001)\n sampling_space = [[x,y] for x in lat_sample for y in lon_sample]\n sampling_space = np.asarray(sampling_space, dtype=np.float32)\n prediction = kmeans_instance.predict(sampling_space)\n pol = [[list(sampling_space[index]) for index in [i for i, j in enumerate(prediction) if j == k]] for k in range(centers)]\n hull = [shapely.geometry.MultiPoint(pol[i]).convex_hull.exterior._get_coords() for i in range(len(pol))]","def plot_contour( m, lat, lon, data, contour, clr = 'k' ):\n \n x, y = m( lon,lat )\n \n CS = m.contour( x, y, data, contour , linewidths = 0.8, colors = clr )","def calculate_watershed_of_node(landscape, outlet_coords_r_c, d4):\n landscape.heights = util.fill_single_cell_depressions(landscape.heights, landscape.ny, landscape.nx)\n watersheds, steepest, flow_dir = util.calculate_watersheds(landscape.heights, landscape.nx, landscape.ny, landscape.step_size, d4)\n # spill_heights = util.get_spill_heights(watersheds, landscape.heights, steepest)\n # traps, size_of_traps = util.get_all_traps(watersheds, landscape.heights, spill_heights)\n\n # Increase heights of traps and recalculate flow. Remove flow from some indices in traps.\n util.make_landscape_depressionless(watersheds, steepest, landscape)\n print 'Made landscape depressionless'\n # Test if traps are merged\n watersheds, steepest, flow_dir = util.calculate_watersheds(landscape.heights, landscape.nx, landscape.ny, landscape.step_size, d4)\n spill_heights = util.get_spill_heights(watersheds, landscape.heights, steepest)\n traps, size_of_traps = util.get_all_traps(watersheds, landscape.heights, spill_heights)\n\n flow = util.get_flow_direction_indices(landscape.heights, landscape.step_size, landscape.ny, landscape.nx, d4)\n flow_dir = util.get_flow_directions(landscape.heights, landscape.step_size, landscape.ny, landscape.nx, d4)\n\n for i in range(len(traps)):\n trap_in_2d = util.map_1d_to_2d(traps[i], landscape.nx)\n flow[trap_in_2d] = -1\n flow_dir[trap_in_2d] = -1\n\n # Create connections and expand matrix to accommodate trap nodes\n node_conn_mat = util.make_sparse_node_conn_matrix(flow, landscape.ny, landscape.nx)\n node_conn_mat = expand_conn_mat(node_conn_mat, len(traps))\n expanded_conn_mat = reroute_trap_connections(node_conn_mat, landscape.ny, landscape.nx, traps, steepest, d4)\n\n # Get the watershed of the node\n ws_of_node, trap_nodes_in_ws = get_watershed_of_node(outlet_coords_r_c, expanded_conn_mat, traps, landscape.ny, landscape.nx)\n\n return ws_of_node, traps, spill_heights, trap_nodes_in_ws, steepest, flow_dir, landscape.heights","def draw_heaters(ax, windtunnel):\n draw_heater(ax, windtunnel.heater_l)\n draw_heater(ax, windtunnel.heater_r)","def plot_features(im, locs, circle=False):\n def draw_circle(c, r):\n t = arrange(0, 1.01, .01) * 2 * pi\n x = r * cos(t) + c[0]\n y = r * sin(t) + c[1]\n plot(x, y, \"b\", linewidth=2)\n\n imshow(im)\n if circle:\n for p in locs:\n draw_circle(p[:2], p[2])\n else:\n plot(locs[:, 0], locs[:, 1], \"ob\")\n axis(\"off\")","def mpl_triangulation(self):\n tris=[] # [ (n1,n2,n3), ...]\n\n for c in self.valid_cell_iter():\n nodes=np.array(self.cell_to_nodes(c))\n\n # this only works for convex cells\n for i in range(1,len(nodes)-1):\n tris.append( nodes[ [0,i,i+1] ] )\n\n tris=np.array(tris)\n tri=Triangulation(self.nodes['x'][:,0],self.nodes['x'][:,1],\n triangles=tris )\n return tri","def plot_trips(data, n_trips, name):\n savedir = \"./\"\n bins = 1000\n lat_min, lat_max = 41.04961, 41.24961\n lon_min, lon_max = -8.71099, -8.51099\n z = np.zeros((bins, bins))\n latlon = np.array([(lat, lon)\n for path in data.POLYLINE\n for lon, lat in path if len(path) > 0])\n figure()\n z += np.histogram2d(*latlon.T, bins=bins,\n range=[[lat_min, lat_max],\n [lon_min, lon_max]])[0]\n log_density = np.log(1 + z)\n title(str(n_trips) + ' Taxi trips')\n imshow(log_density[::-1, :], # flip vertically\n extent=[lat_min, lat_max, lon_min, lon_max])\n savefig(savedir + name)\n print \"img file saved in \" + savedir + name","def plot_mesh(corners):\r\n triangle = tri.Triangulation(corners[:, 0], corners[:, 1])\r\n\r\n refiner = tri.UniformTriRefiner(triangle)\r\n trimesh = refiner.refine_triangulation(subdiv=4)\r\n \r\n plt.figure(figsize=(6, 4))\r\n for i, mesh in enumerate((triangle, trimesh)):\r\n plt.subplot(1, 2, i+1)\r\n plt.triplot(mesh)\r\n plt.axis('off')\r\n plt.axis('equal')","def plot_dist_4p(\n hst,\n xi,\n yi,\n ax=None,\n filled=False,\n fcolors=None,\n **kwargs,\n ):\n vl = [0.3, 0.6, 0.9, 0.99]\n fig = plot_dist_xp(hst, xi, yi, ax=ax, levels=vl, filled=filled, fcolors=fcolors, **kwargs)\n return fig","def plot_vor_boundary(self,x,ax,tri=False):\n\n x = x[~np.isnan(x[:,0])]\n c_types_print = np.ones(x.shape[0],dtype=np.int32)*-1\n c_types_print[:self.n_C] = self.c_types\n regions, vertices = self.voronoi_finite_polygons_2d(Voronoi(x))\n\n\n ax.set(aspect=1,xlim=(0,self.L),ylim=(0,self.L))\n if type(self.c_types) is list:\n # ax.scatter(x[:, 0], x[:, 1],color=\"grey\",zorder=1000)\n for region in regions:\n polygon = vertices[region]\n plt.fill(*zip(*polygon), alpha=0.4, color=\"grey\")\n\n else:\n cols = self.cols\n patches = []\n if self.plot_scatter is True:\n ax.scatter(x[:self.n_C, 0], x[:self.n_C, 1], color=\"black\", zorder=1000)\n ax.scatter(x[self.n_C:, 0], x[self.n_C:, 1], color=\"grey\", zorder=1000)\n\n for i, region in enumerate(regions):\n patches.append(Polygon(vertices[region], True,facecolor=cols[c_types_print[i]],edgecolor=\"white\",alpha=0.5))\n\n p = PatchCollection(patches, match_original=True)\n # p.set_array(c_types_print)\n ax.add_collection(p)\n if tri is not False:\n for TRI in tri:\n for j in range(3):\n a, b = TRI[j], TRI[np.mod(j + 1, 3)]\n if (a >= 0) and (b >= 0):\n X = np.stack((x[a], x[b])).T\n ax.plot(X[0], X[1], color=\"black\")","def find_interpolation_coefficients(grid,pt,tessellation,ndx):\n\n if (pt is None): return None, None\n if (tessellation is None): return None, None\n pt1 = np.asarray(pt[0:-1],dtype=gtype)\n val = tessellation.find_simplex(pt1.reshape((1,grid.ndim)))[0]\n\n # see if point is outside tessellation\n if (val == -1): return None, None\n mat = tessellation.transform[val]\n\n # make sure the transformation matrix is defined:\n if (math.isnan(np.sum(mat))): return None, None\n\n b = mat[:grid.ndim].dot(pt1-mat[grid.ndim])\n coefs = np.r_[b, 1.0-b.sum()]\n ind = tessellation.simplices[val]\n\n # check to make sure you're not outside the grid:\n for coef in coefs:\n if (coef < -tol): return None, None\n\n # produce results, filtering out zero elements:\n coefs_out = []\n tracks = []\n for coef,i in zip(coefs,ind):\n # remove negative coefficients to avoid problems.\n if (coef > 0.0):\n coefs_out.append(coef)\n tracks.append(grid.tracks[ndx[i]])\n\n return coefs_out, tracks","def closest_pair_strip(cluster_list, horiz_center, half_width):\n indices = [] \n\n # Let S be a list of the set {i: |xi - mid| < half_width}\n indices = [index for index in range(len(cluster_list)) if abs(cluster_list[index].horiz_center()-horiz_center)<=half_width]\n \n\t# Sort the indices in S in nondecreasing order of the vertial (y) coordinates of their associated points;\n indices.sort(key = lambda index: cluster_list[index].vert_center())\n\n cl_sorted = cluster_list[:]\n cl_sorted.sort(key = lambda cluster: cluster.vert_center())\n\n # k <-- length(S);\n len_indices = len(indices)\n\n # (d,i,j) <-- (infinity, -1, -1);\n output_list = [float('inf'), -1, -1]\t\n\n # for u <-- 0 to k - 2 do\n for value1 in range(len_indices-1):\n \t# \tfor v <-- u + 1 to min{u+3,k-1} do\n for value2 in range(value1+1, min(value1+6,len_indices)):\n # (d,i,j) <-- min{(d,i,j),(dsub(psubS[u],PsubS[v]), S[u],S[v])}\n min_dist = min(output_list[0], pair_distance(cluster_list,indices[value1],indices[value2])[0])\n if output_list[0] > min_dist:\n indices_sorted = sorted([indices[value1], indices[value2]])\n \toutput_list = [pair_distance(cluster_list,indices[value1],indices[value2])[0], indices_sorted[0], indices_sorted[1]]\n\n # return(d,i,j)\n return tuple(output_list)","def pf_plot(pf, t):\n xx = pf.XS[t, :, 0]\n yy = pf.XS[t, :, 1]\n ww = pf.WS[t, :]\n plt.scatter(xx, yy, s=ww * 5000)","def solveTetris(self,**kwargs):\n #self.showCamera()\n self.locator.recognise_grid()","def makemesh(pts,vec,growsize=0.2,curvilinear_neighbors=10,\n\tcurvilinear=True,debug=False,growsize_nm=None,excise=True,areas_only=False):\n\tif debug: \n\t\timport time\n\t\tst = time.time()\n\t\tdef checkpoint(note):\n\t\t\tprint(note)\n\t\t\tst = time.time()\n\n\tnmol = len(pts)\n\tpts = pts\n\tvec = vec\n\tif debug: \n\t\timport time\n\t\tst = time.time()\n\t\tprint(\"[STATUS] start makemesh %0.2f\"%(time.time()-st))\n\tptsb,ptsb_inds = beyonder(pts,vec,growsize=growsize,growsize_nm=growsize_nm,return_ids=True)\n\tif debug: print(\"[STATUS] project curvilinear=\"+str(curvilinear)+\" %0.2f\"%(time.time()-st))\n\t#---if curvilinear then use the isomap otherwise project onto the xy plane\n\tif curvilinear: \n\t\timport sklearn\n\t\tfrom sklearn import manifold\n\t\tproj = manifold.Isomap(curvilinear_neighbors,2).fit_transform(ptsb)\n\telse: proj = ptsb[...,:2]\n\tif debug: checkpoint(\"[STATUS] delaunay %0.2f\"%(time.time()-st))\n\tif debug: checkpoint(\"[STATUS] shape=\"+str(np.shape(ptsb)))\n\tdl = scipy.spatial.Delaunay(proj)\n\tif debug: checkpoint(\"[STATUS] reclock %0.2f\"%(time.time()-st))\n\tsimplices = np.array([a[reclock(ptsb[a])] for a in dl.simplices])\n\t#---rework simplices and ptsb to exclude superfluous points\n\tif debug: checkpoint(\"[STATUS] trim %0.2f\"%(time.time()-st))\n\t#---relevants is a unique list of simplices with exactly one member that is equal to a core vertex point\n\trelevants = np.unique(np.concatenate([simplices[\n\t\tnp.where(np.sum(simplices==i,axis=1)==1)[0]] for i in range(nmol)]))\n\tpoints = ptsb[relevants]\n\tghost_indices = ptsb_inds[relevants]\n\tptsb = points\n\n\tif debug: checkpoint(\"[STATUS] simplices %0.2f\"%(time.time()-st))\n\tsimplices = np.array([[np.where(relevants==r)[0][0] for r in s] \n\t\tfor s in simplices if np.all([r in relevants for r in s])])\n\t#---end rework\n\tif debug: checkpoint(\"[STATUS] areas %0.2f\"%(time.time()-st))\n\tareas = np.array([triarea(ptsb[a]) for a in simplices])\n\tif areas_only: return {'simplices':simplices,'areas':areas,'nmol':nmol,'vec':vec,'points':points}\n\tif debug: checkpoint(\"[STATUS] facenorms %0.2f\"%(time.time()-st))\n\tfacenorms = np.array([vecnorm(facenorm(ptsb[a])) for a in simplices])\t\n\tif debug: checkpoint(\"[STATUS] vertex-to-simplex %0.2f\"%(time.time()-st))\n\tv2s = [np.where(np.any(simplices==i,axis=1))[0] for i in range(nmol)]\n\tif debug: checkpoint(\"[STATUS] vertex normals %0.2f\"%(time.time()-st))\n\tvertnorms = np.array([vecnorm(np.sum(facenorms[ind]*\\\n\t\tnp.transpose([areas[ind]/np.sum(areas[ind])]),axis=0)) for ind in v2s])\n\tprincipals = np.zeros((nmol,2))\n\tnl = []\n\tif debug: checkpoint(\"[STATUS] curvatures %0.2f\"%(time.time()-st))\n\tfor v in range(nmol):\n\t\tneighbors = np.unique(simplices[np.where(np.any(simplices==v,axis=1))[0]])\n\t\tneighbors = neighbors[neighbors!=v]\n\t\tnl.append(neighbors)\n\t\tedges = ptsb[neighbors]-ptsb[v]\n\t\tweights = [areas[sl]/2./np.sum(areas[v2s[v]]) for sl in v2s[v]]\n\t\ttijs = [vecnorm(np.dot(np.identity(3)-np.outer(vertnorms[v],\n\t\t\tvertnorms[v].T),ab)) for ab in edges]\n\t\tkijs = [np.dot(vertnorms[v].T,ab)/linalg.norm(ab)**2 for ab in edges]\n\t\tct = np.sum([weights[ind]*kijs[ind]*np.outer(tijs[ind],tijs[ind]) \n\t\t\tfor ind,i in enumerate(v2s[v])],axis=0)\n\t\twsign = 1-2*(linalg.norm(np.array([1,0,0])+\\\n\t\t\tvertnorms[v])<linalg.norm(np.array([1,0,0])-vertnorms[v]))\n\t\twvi = vecnorm(np.array([1,0,0])+wsign*vertnorms[v])\n\t\thm = np.identity(3)-2*np.outer(wvi,wvi.T)\n\t\thhm = np.dot(np.dot(hm.T,ct),hm)\n\t\tprincipals[v] = -1*hhm[1,1],-1*hhm[2,2]\n\tif debug: checkpoint(\"[STATUS] PBC neighborlist %0.2f\"%(time.time()-st))\n\t#---neighborlist under PBCs\n\tchecksubssort,nlsubs = np.where(torusnorm(points[nmol:],points[:nmol],vec)==0)\n\t#if not all(checksubssort==np.arange(len(points)-nmol)): raise Exception('torusnorm lookup fail')\n\ttry: nlpbc = [[(i if i<nmol else nlsubs[i-nmol]) for i in n] for n in nl]\n\texcept: nlpbc = []\n\tgauss = (3*principals[:,0]-principals[:,1])*(3*principals[:,1]-\\\n\t\tprincipals[:,0])\n\tmean = 1./2*((3*principals[:,0]-principals[:,1])+\\\n\t\t(3*principals[:,1]-principals[:,0]))\n\tif debug: checkpoint(\"[STATUS] complete %0.2f\"%(time.time()-st))\n\n\tif debug:\n\t\timport matplotlib as mpl;import matplotlib.pylab as plt\n\t\tplt.scatter(points[:,0],points[:,1])\n\t\tplt.show()\n\t\timport pdb;pdb.set_trace()\n\n\treturn {'nmol':nmol,'vec':vec,'simplices':simplices,'points':points,\n\t\t'areas':areas,'facenorms':facenorms,'vertnorms':vertnorms,'principals':principals,\n\t\t'ghost_ids':ghost_indices,'gauss':gauss,'mean':mean}"],"string":"[\n \"def highlight_cells_on_tsne(tsne, cells, fig=None, ax=None):\\n fig, ax = get_fig(fig=fig, ax=ax)\\n ax.scatter(tsne['x'], tsne['y'], s=3, color='lightgrey')\\n ax.scatter(tsne.loc[cells, 'x'], tsne.loc[cells, 'y'], s=3, color='b')\\n ax.set_axis_off()\\n return fig, ax\",\n \"def _uniform_refine_tetrahedra(mesh):\\n\\n # get current cells and edges\\n cells = mesh.cells\\n edges = mesh.edges\\n\\n assert np.size(cells, axis=1) == 4\\n\\n # get number of current nodes\\n n_nodes = np.size(mesh.nodes, axis=0)\\n \\n # first we create additional nodes as midpoints of the current edges\\n midpoints = 0.5 * mesh.nodes.take(edges - 1, axis=0).sum(axis=1)\\n\\n # add them to the existing mesh nodes\\n new_nodes = np.vstack([mesh.nodes, midpoints])\\n \\n # then we generate the indices of the newly created nodes\\n #\\n # their indices start at the current number of nodes (`n_nodes`) + 1\\n # and end after additional `n_edges` nodes\\n n_edges = np.size(edges, axis=0)\\n new_node_indices = np.arange(n_nodes + 1, n_nodes + n_edges + 1, dtype=int)\\n\\n # refine elements\\n #\\n # for every element we need the indices of the edges at which the\\n # corresponding new nodes are created\\n indices_3_1 = mesh.topology.get_connectivity(3, 1, return_indices=True) - 1\\n \\n # next we augment the indices that define each element as if\\n # they were defined by 10 nodes (including those of the edge midpoints)\\n cells_ = np.hstack([cells, new_node_indices.take(indices_3_1, axis=0)])\\n \\n # now we can generate the eight new elements for each existing one\\n new_cells_1 = np.vstack([cells_[:,0], cells_[:,4], cells_[:,5], cells_[:,6]]).T\\n new_cells_2 = np.vstack([cells_[:,1], cells_[:,4], cells_[:,7], cells_[:,8]]).T\\n new_cells_3 = np.vstack([cells_[:,2], cells_[:,5], cells_[:,7], cells_[:,9]]).T\\n new_cells_4 = np.vstack([cells_[:,3], cells_[:,6], cells_[:,8], cells_[:,9]]).T\\n new_cells_5 = np.vstack([cells_[:,4], cells_[:,5], cells_[:,6], cells_[:,9]]).T\\n new_cells_6 = np.vstack([cells_[:,4], cells_[:,5], cells_[:,7], cells_[:,9]]).T\\n new_cells_7 = np.vstack([cells_[:,4], cells_[:,6], cells_[:,8], cells_[:,9]]).T\\n new_cells_8 = np.vstack([cells_[:,4], cells_[:,7], cells_[:,8], cells_[:,9]]).T\\n \\n new_cells = np.vstack([new_cells_1, new_cells_2, new_cells_3, new_cells_4,\\n new_cells_5, new_cells_6, new_cells_7, new_cells_8])\\n\\n return new_nodes, new_cells\",\n \"def visualize_routes(self):\\n visualize_tsp.plotTSP([self.best_solution], self.coords)\",\n \"def plotMesh(verts,tris):\\n x = verts[:,0]\\n y = verts[:,1]\\n\\n plt.figure()\\n plt.gca().set_aspect('equal')\\n plt.triplot(x, y, tris, 'k-')\\n plt.title('Unstructured Mesh')\\n plt.xlabel('distance (m)')\\n plt.ylabel('distance (m)')\",\n \"def watershed_segment(M,xM=None,yM=None):\\n\\n if xM != None and yM != None:\\n sel = np.ones((int(ceil(23.9*xM)),int(ceil(23.9*yM)))) # for opening\\n sel2 = np.ones((int(ceil(127.2*xM)),int(ceil(127.2*yM)))) # for local thresholding\\n sel3 = np.ones((int(ceil(11.9*xM)),int(ceil(11.9*yM)))) # for erosion\\n ma,mi =(44245.21*xM*yM),(316.037*xM*yM) \\n else:\\n selD = np.array([int(M.shape[0]*.012),int(M.shape[1]*.012)])\\n selD = np.where(selD!=0,selD,1)\\n \\n sel2D = np.array([int(M.shape[0]*.12),int(M.shape[1]*.12)])\\n sel2D = np.where(sel2D!=0,sel2D,1)\\n\\n sel3D = np.array([int(M.shape[0]*.01),int(M.shape[1]*.01)])\\n sel3D = np.where(sel3D!=0,sel3D,1)\\n\\n\\n sel = np.ones(selD) # for opening\\n sel2 = np.ones(sel2D) # for local thresholding\\n sel3 = np.ones(sel3D) # for erosion\\n ma,mi = (M.shape[0]*M.shape[1]*.0075),(M.shape[0]*M.shape[1]*.0003)\\n\\n # get a few points in the center of each blob\\n \\n # threshold\\n bw = ((M>=ndi.percentile_filter(M,80,footprint=sel2)))\\n #& (M>=stats.scoreatpercentile(M.flatten(),80)))\\n\\n # open and erode\\n blobs = snm.binary_opening(bw,structure=sel)\\n blobs = snm.binary_erosion(blobs,structure=sel3,iterations=2)\\n \\n # label\\n labels,_ = ndi.label(blobs)\\n labels[labels > 0] += 1\\n labels[0,0] = 1\\n\\n # rescale and cast to int16, then use watershed\\n #M2 = rescaled(M,0,65000).astype(np.uint16)\\n #newlabels = ndi.watershed_ift(M2,labels)\\n newlabels = labels\\n \\n # get rid of groups unless they have the right number of pixels\\n\\n counts = np.bincount(newlabels.flatten())\\n old2new = np.arange(len(counts)) \\n old2new[(counts < int(mi)) | (counts > int(ma))] = 0\\n newlabels = old2new[newlabels]\\n\\n return newlabels\",\n \"def plot_simplex(self, num_contours: int = 100, num_sub_div: int = 8,\\n color_map: str = 'viridis', border: bool = True, ax: Axes = None) -> Axes:\\n\\n corners = array([[0, 0], [1, 0], [0.5, 0.75 ** 0.5]])\\n triangle = Triangulation(corners[:, 0], corners[:, 1])\\n mid_points = [\\n (corners[(i + 1) % 3] + corners[(i + 2) % 3]) / 2\\n for i in range(3)\\n ]\\n\\n def to_barycentric(cartesian):\\n \\\"\\\"\\\"\\n Converts 2D Cartesian to barycentric coordinates.\\n\\n :param cartesian: A length-2 sequence containing the x and y value.\\n \\\"\\\"\\\"\\n s = [(corners[i] - mid_points[i]).dot(cartesian - mid_points[i]) / 0.75\\n for i in range(3)]\\n s_clipped = clip(a=s, a_min=0, a_max=1)\\n return s_clipped / norm(s_clipped, ord=1)\\n\\n refiner = UniformTriRefiner(triangle)\\n tri_mesh = refiner.refine_triangulation(subdiv=num_sub_div)\\n f = [self._method(to_barycentric(xy))\\n for xy in zip(tri_mesh.x, tri_mesh.y)]\\n ax = ax or new_axes()\\n ax.tricontourf(tri_mesh, f, num_contours, cmap=color_map)\\n ax.set_aspect('equal')\\n ax.set_xlim(0, 1)\\n ax.set_ylim(0, 0.75 ** 0.5)\\n ax.set_axis_off()\\n if border:\\n ax.triplot(triangle, linewidth=1)\\n\\n return ax\",\n \"def test_plot_cspad(geometry, fname_data, amp_range=(0,0.5)):\\n #rad1 = 93\\n #rad2 = 146\\n rad1 = 655\\n rad2 = 670\\n\\n # get pixel coordinate index arrays:\\n xyc = xc, yc = 500, 500# None\\n\\n #rows, cols = geometry.get_pixel_coord_indexes(xy0_off_pix=None)\\n rows, cols = geometry.get_pixel_coord_indexes(xy0_off_pix=xyc, do_tilt=True)\\n\\n ixo, iyo = geometry.point_coord_indexes(xy0_off_pix=xyc, do_tilt=True)\\n logger.info('Detector origin indexes ixo:%d iyo:%d' % (ixo, iyo))\\n\\n root, ext = os.path.splitext(fname_data)\\n arr = np.load(fname_data) if ext == '.npy' else np.loadtxt(fname_data, dtype=np.float)\\n arr.shape= (4,8,185,388)\\n\\n logger.info('shapes rows: %s cols: %s weight: %s' % (str(rows.shape), str(cols.shape), str(arr.shape)))\\n\\n arr.shape = rows.shape\\n img = img_from_pixel_arrays(rows, cols, W=arr)\\n\\n rcc_ring = (iyo, ixo)\\n axim = gg.plotImageLarge(img,amp_range=amp_range)\\n gg.drawCircle(axim, rcc_ring, rad1, linewidth=1, color='w', fill=False)\\n gg.drawCircle(axim, rcc_ring, rad2, linewidth=1, color='w', fill=False)\\n gg.drawCenter(axim, rcc_ring, rad1, linewidth=1, color='w')\\n gg.move(500,10)\\n gg.show()\",\n \"def hexapodZernikeLinearModel_hexapodcoordinate():\\n Tfile='/home/jghao/research/decamFocus/psf_withseeing/finerGrid_coeff_matrix/zernike_coeff_finerGrid_training.cp'\\n b=p.load(open(Tfile))\\n nobs = len(b)\\n x = b[:,0]\\n y = b[:,1]\\n z = b[:,2]\\n theta = b[:,3]\\n phi = b[:,4]\\n fwhm = b[:,5]\\n e1 = b[:,6]\\n e2 = b[:,7]\\n thetax = theta*np.cos(np.deg2rad(phi))\\n thetay = theta*np.sin(np.deg2rad(phi))\\n xh = x*1000 # convert to hexapod coordinate\\n yh = -y*1000\\n zh = -z*1000\\n xtilth = - thetay\\n ytilth = - thetax\\n\\n M22realTrefoil2 = b[:,37] # for x decenter\\n M22imagTrefoil1 = b[:,54] \\n M22TrefoilXshift = 0.5*(M22realTrefoil2+M22imagTrefoil1)\\n\\n M22realTrefoil1 = b[:,34] # for y decenter\\n M22imagTrefoil2 = b[:,57] \\n M22TrefoilYshift = 0.5*(M22realTrefoil1 - M22imagTrefoil2)\\n\\n M20defocus = b[:,12] # for defocus\\n\\n M22realComa2 = b[:,36] # for x-tilt\\n M22imagComa1 = b[:,55]\\n M22ComaXtilt = 0.5*(M22realComa2+M22imagComa1)\\n\\n M22realComa1 = b[:,35] # for y-tilt\\n M22imagComa2 = b[:,56]\\n M22ComaYtilt = 0.5*(M22realComa1 - M22imagComa2)\\n \\n pl.figure(figsize=(21,12))\\n pl.subplot(2,3,1)\\n t=bp.bin_scatter(M22TrefoilXshift,xh,nbins=20,fmt='bo',scatter=True)\\n res = linefit(M22TrefoilXshift,xh)\\n pl.plot(M22TrefoilXshift,M22TrefoilXshift*res[1]+res[0],'r,')\\n pl.ylabel('x-decenter [micron]')\\n pl.xlabel('(M22realTrefoil2+M22imagTrefoil1)/2')\\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\\n pl.grid()\\n pl.subplot(2,3,2)\\n t=bp.bin_scatter(M22TrefoilYshift,yh,nbins=20,fmt='bo',scatter=True)\\n res = linefit(M22TrefoilYshift,yh)\\n pl.plot(M22TrefoilYshift,M22TrefoilYshift*res[1]+res[0],'r,')\\n pl.ylabel('y-decenter [micron]')\\n pl.xlabel('(M22realTrefoil1 - M22imagTrefoil2)/2')\\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\\n pl.grid()\\n pl.subplot(2,3,3)\\n t=bp.bin_scatter(M20defocus,zh,nbins=20,fmt='bo',scatter=True)\\n res = linefit(M20defocus,zh)\\n pl.plot(M20defocus,M20defocus*res[1]+res[0],'r,')\\n pl.ylabel('z-defocus [micron]')\\n pl.xlabel('M20defocus')\\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\\n pl.grid()\\n pl.subplot(2,3,4)\\n t=bp.bin_scatter(M22ComaXtilt,ytilth,nbins=20,fmt='bo',scatter=True)\\n res = linefit(M22ComaXtilt,ytilth)\\n pl.plot(M22ComaXtilt,M22ComaXtilt*res[1]+res[0],'r,')\\n pl.ylabel('y-tilt [arcsec]') # in hexapod coordiate, xtilt and y tilt is switched from the CRAY coordiante\\n pl.xlabel('(M22realComa2+M22imagComa1)/2')\\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\\n pl.grid()\\n pl.subplot(2,3,5)\\n t=bp.bin_scatter(M22ComaYtilt,xtilth,nbins=20,fmt='bo',scatter=True)\\n res = linefit(M22ComaYtilt,xtilth)\\n pl.plot(M22ComaYtilt,M22ComaYtilt*res[1]+res[0],'r,')\\n pl.ylabel('x-tilt [arcsec]')\\n pl.xlabel('(M22realComa1 - M22imagComa2)/2')\\n pl.title('slope: '+str(round(res[1],4))+' Intercept: '+str(round(res[0],4)))\\n pl.grid()\\n pl.savefig('linearModel_hexapod_coordinate.png')\\n pl.close()\",\n \"def quadrants (ax, T, neq, color='k', zorder=1):\\n \\n da = np.pi/180. # \\n R = 6370. # Mean Earth Radius in km\\n\\n for n in range(len(T['lon'])):\\n x = T['lon'][n]\\n y = T['lat'][n]\\n\\n if T[neq][n] is not None:\\n\\n #Convert Quadrant values to km\\n ne = T[neq][n][0]*1.852\\n se = T[neq][n][1]*1.852\\n sw = T[neq][n][2]*1.852\\n nw = T[neq][n][3]*1.852\\n\\n label = neq\\n if neq == 'rmax':\\n label = str (int(T['vmax'][n])) \\n \\n xiso = []\\n yiso = []\\n for a in np.arange(0., 0.5*np.pi, da):\\n \\n dx = 180./(np.pi*R)*ne/np.cos( np.radians(y))\\n dy = 180./(np.pi*R)*ne\\n xiso.append( x + dx*np.cos(a) )\\n yiso.append( y + dy*np.sin(a) )\\n \\n ax.text(x + dx + 0.05*dx, y, label, color=color, fontsize=7)\\n \\n for a in np.arange(0.5*np.pi, np.pi, da):\\n dx = 180./(np.pi*R)*nw/np.cos( np.radians(y))\\n dy = 180./(np.pi*R)*nw\\n xiso.append( x + dx*np.cos(a) )\\n yiso.append( y + dy*np.sin(a) ) \\n\\n for a in np.arange(np.pi, 1.5*np.pi, da):\\n dx = 180./(np.pi*R)*sw/np.cos( np.radians(y))\\n dy = 180./(np.pi*R)*sw\\n xiso.append( x + dx*np.cos(a) )\\n yiso.append( y + dy*np.sin(a) ) \\n\\n for a in np.arange(1.5*np.pi, 2.*np.pi, da):\\n dx = 180./(np.pi*R)*se/np.cos( np.radians(y))\\n dy = 180./(np.pi*R)*se\\n xiso.append( x + dx*np.cos(a) )\\n yiso.append( y + dy*np.sin(a) ) \\n \\n ax.plot(xiso, yiso, color=color, zorder=zorder)\\n ax.plot((xiso[0],xiso[-1]), (yiso[0],yiso[-1]), color=color, zorder=zorder)\\n\\n return ax\",\n \"def plot_neighbors(data, indices, ax):\\n\\n indices = [item.tolist() for item in indices]\\n counter_removed = 0\\n\\n for j in range(data.shape[0]):\\n def remove_repetitions(indices, j, counter_removed):\\n for item in indices[j]:\\n try:\\n indices[item].remove(j)\\n counter_removed = counter_removed + 1\\n except ValueError:\\n pass\\n # print(\\\"removed\\\", counter_removed)\\n return counter_removed, indices\\n\\n counter_removed, indices = remove_repetitions(indices, j, counter_removed)\\n origin = data[j, :]\\n targets = [data[i, :] for i in indices[j]]\\n\\n for target in targets:\\n x = [origin[0], target[0]]\\n y = [origin[1], target[1]]\\n z = [origin[2], target[2]]\\n ax.plot(x, y, z, 'ro-', linewidth='1', markersize=1)\",\n \"def plot_contour(xynodes, stress, mytitle='contour plot'):\\n\\n stress = np.array(stress)\\n fig2 = plt.figure()\\n\\n fig2 = plt.figure()\\n sigma1 = stress[:, 0]\\n sigma2 = stress[:, 1]\\n sigma12 = stress[:, 2]\\n vonmises = np.sqrt(sigma1 ** 2 - sigma1 * sigma2 + sigma2 ** 2 + 3 * sigma12 ** 2)\\n prins1 = (sigma1 + sigma2) / 2 + np.sqrt(((sigma1 - sigma2) / 2) ** 2 + sigma12 ** 2)\\n prins2 = (sigma1 + sigma2) / 2 - np.sqrt(((sigma1 - sigma2) / 2) ** 2 + sigma12 ** 2)\\n\\n sigma1norm = sigma1 / np.max(np.abs(sigma1))\\n sigma2norm = sigma2 / np.max(np.abs(sigma2))\\n sigma12norm = sigma12 / np.max(np.abs(sigma12))\\n vonmisesnorm = vonmises / np.max(np.abs(vonmises))\\n prins1norm = prins1 / np.max(np.abs(prins1))\\n prins2norm = prins2 / np.max(np.abs(prins2))\\n\\n pltsigma = sigma1norm\\n for i, xy in enumerate(xynodes):\\n x = [k[0] for k in xy]\\n y = [k[1] for k in xy]\\n # red for tension, blue for compression\\n pltcolor = 'r' if pltsigma[i] >= 0 else 'b'\\n sigmavalnorm = pltsigma[i] if pltsigma[i] > 0 else pltsigma[i] * -1\\n plt.fill(x, y, pltcolor, alpha=sigmavalnorm)\\n plt.plot(x, y, 'k')\\n\\n title(mytitle)\\n tmpx = [x[0] for k in xynodes for x in k]\\n tmpy = [x[1] for k in xynodes for x in k]\\n plt.xlim([np.min(tmpx) - 3, np.max(tmpx) + 3])\\n plt.ylim([np.min(tmpy) - 3, np.max(tmpy) + 3])\\n plt.show()\",\n \"def voronoi_sub_mask_1d_index_to_pixeliztion_1d_index_from_grids_and_geometry(\\n grid,\\n mask_1d_index_to_nearest_pixelization_1d_index,\\n sub_mask_1d_index_to_mask_1d_index,\\n pixel_centres,\\n pixel_neighbors,\\n pixel_neighbors_size,\\n):\\n\\n sub_mask_1d_index_to_pixeliztion_1d_index = np.zeros((grid.shape[0]))\\n\\n for sub_mask_1d_index in range(grid.shape[0]):\\n\\n nearest_pixelization_1d_index = mask_1d_index_to_nearest_pixelization_1d_index[\\n sub_mask_1d_index_to_mask_1d_index[sub_mask_1d_index]\\n ]\\n\\n while True:\\n\\n nearest_pixelization_pixel_center = pixel_centres[\\n nearest_pixelization_1d_index\\n ]\\n\\n sub_pixel_to_nearest_pixelization_distance = (\\n (grid[sub_mask_1d_index, 0] - nearest_pixelization_pixel_center[0]) ** 2\\n + (grid[sub_mask_1d_index, 1] - nearest_pixelization_pixel_center[1])\\n ** 2\\n )\\n\\n closest_separation_from_pixelization_to_neighbor = 1.0e8\\n\\n for neighbor_pixelization_1d_index in range(\\n pixel_neighbors_size[nearest_pixelization_1d_index]\\n ):\\n\\n neighbor = pixel_neighbors[\\n nearest_pixelization_1d_index, neighbor_pixelization_1d_index\\n ]\\n\\n separation_from_neighbor = (\\n grid[sub_mask_1d_index, 0] - pixel_centres[neighbor, 0]\\n ) ** 2 + (grid[sub_mask_1d_index, 1] - pixel_centres[neighbor, 1]) ** 2\\n\\n if (\\n separation_from_neighbor\\n < closest_separation_from_pixelization_to_neighbor\\n ):\\n closest_separation_from_pixelization_to_neighbor = (\\n separation_from_neighbor\\n )\\n closest_neighbor_pixelization_1d_index = (\\n neighbor_pixelization_1d_index\\n )\\n\\n neighboring_pixelization_1d_index = pixel_neighbors[\\n nearest_pixelization_1d_index, closest_neighbor_pixelization_1d_index\\n ]\\n sub_pixel_to_neighboring_pixelization_distance = (\\n closest_separation_from_pixelization_to_neighbor\\n )\\n\\n if (\\n sub_pixel_to_nearest_pixelization_distance\\n <= sub_pixel_to_neighboring_pixelization_distance\\n ):\\n sub_mask_1d_index_to_pixeliztion_1d_index[\\n sub_mask_1d_index\\n ] = nearest_pixelization_1d_index\\n break\\n else:\\n nearest_pixelization_1d_index = neighboring_pixelization_1d_index\\n\\n return sub_mask_1d_index_to_pixeliztion_1d_index\",\n \"def trapezoid_decomposition_pl(polygons, bounds):\\n polygons = Polygons(polygons)\\n # print(bounds)\\n point_locator = PointLocator(bounds)\\n for edge in polygons.random_edge_sampler():\\n point_locator.add_line(edge)\\n return point_locator\",\n \"def touching_hexagons(point: Point):\\n # get all 6 touching points\\n if point.y % 2 == 0:\\n return [Point(point.x + 1, point.y), Point(point.x, point.y - 1), Point(point.x - 1, point.y - 1),\\n Point(point.x - 1, point.y), Point(point.x - 1, point.y + 1), Point(point.x, point.y + 1)]\\n else:\\n return [Point(point.x + 1, point.y), Point(point.x + 1, point.y - 1), Point(point.x, point.y - 1),\\n Point(point.x - 1, point.y), Point(point.x, point.y + 1), Point(point.x + 1, point.y + 1)]\",\n \"def plotpy (tvec=tvec, ind=ind, synclines=True):\\n plt.scatter(tvec,ind) \\n if synclines:\\n for spkt in np.array(tvec): plt.plot((spkt, spkt), (0, ncells), 'r-', linewidth=0.1)\",\n \"def hexapodZernikeTrend(mnts='M20'):\\n Tfile='/home/jghao/research/decamFocus/psf_withseeing/finerGrid_coeff_matrix/zernike_coeff_finerGrid_training.cp'\\n b=p.load(open(Tfile))\\n nobs = len(b)\\n x = b[:,0]\\n y = b[:,1]\\n z = b[:,2]\\n theta = b[:,3]\\n phi = b[:,4]\\n fwhm = b[:,5]\\n e1 = b[:,6]\\n e2 = b[:,7]\\n thetax = theta*np.cos(np.deg2rad(phi))\\n thetay = theta*np.sin(np.deg2rad(phi))\\n if mnts == 'M20':\\n idxBase = 9\\n if mnts == 'M22real':\\n idxBase = 29\\n if mnts == 'M22imag':\\n idxBase = 49\\n idx = np.arange(14)\\n zernikeName=('Piston','Tip','Tilt','Astignism','Defocus','Astignism','Trefoil','Coma','Coma','Trefoil','Ashtray','Astigm.5th','Spherical','Astigm.5th','Ashtray','16','17','18','19','20')\\n for i in range(14):\\n pl.figure(figsize=(21,10))\\n pl.subplot(2,3,1)\\n bp.bin_scatter(b[:,idxBase+idx[i]],x,nbins=20,fmt='bo',scatter=True)\\n pl.ylabel('x-decenter')\\n pl.xlabel(zernikeName[i+1])\\n pl.ylim(-0.1,0.1)\\n pl.title(mnts)\\n pl.subplot(2,3,2)\\n bp.bin_scatter(b[:,idxBase+idx[i]],y,nbins=20,fmt='bo',scatter=True)\\n pl.ylabel('y-decenter')\\n pl.xlabel(zernikeName[i+1])\\n pl.title(mnts)\\n pl.ylim(-0.1,0.1)\\n pl.subplot(2,3,3)\\n bp.bin_scatter(b[:,idxBase+idx[i]],z,nbins=20,fmt='bo',scatter=True)\\n pl.ylabel('z-defocus')\\n pl.xlabel(zernikeName[i+1])\\n pl.title(mnts)\\n pl.ylim(-0.1,0.1)\\n pl.subplot(2,3,4)\\n bp.bin_scatter(b[:,idxBase+idx[i]],thetax,nbins=20,fmt='bo',scatter=True)\\n pl.ylabel('x-tilt')\\n pl.xlabel(zernikeName[i+1])\\n pl.title(mnts)\\n pl.ylim(-40,40)\\n pl.subplot(2,3,5)\\n bp.bin_scatter(b[:,idxBase+idx[i]],thetay,nbins=20,fmt='bo',scatter=True)\\n pl.ylabel('y-tilt')\\n pl.xlabel(zernikeName[i+1])\\n pl.title(mnts)\\n pl.ylim(-40,40)\\n pl.savefig(zernikeName[i+1]+mnts+'_'+str(i+1)+'.png')\\n pl.close()\",\n \"def zernikeHexapodTrend(mnts='M20'):\\n Tfile='/home/jghao/research/decamFocus/psf_withseeing/finerGrid_coeff_matrix/zernike_coeff_finerGrid_training.cp'\\n b=p.load(open(Tfile))\\n nobs = len(b)\\n x = b[:,0]\\n y = b[:,1]\\n z = b[:,2]\\n theta = b[:,3]\\n phi = b[:,4]\\n fwhm = b[:,5]\\n e1 = b[:,6]\\n e2 = b[:,7]\\n thetax = theta*np.cos(np.deg2rad(phi))\\n thetay = theta*np.sin(np.deg2rad(phi))\\n if mnts == 'M20':\\n idxBase = 9\\n if mnts == 'M22real':\\n idxBase = 29\\n if mnts == 'M22imag':\\n idxBase = 49\\n idx = np.arange(14)\\n zernikeName=('Piston','Tip','Tilt','Astignism','Defocus','Astignism','Trefoil','Coma','Coma','Trefoil','Ashtray','Astigm.5th','Spherical','Astigm.5th','Ashtray','16','17','18','19','20')\\n for i in range(14):\\n pl.figure(figsize=(21,10))\\n pl.subplot(2,3,1)\\n bp.bin_scatter(x,b[:,idxBase+idx[i]],binsize=0.01,fmt='bo',scatter=True)\\n pl.xlabel('x decenter')\\n pl.ylabel(zernikeName[i+1])\\n pl.title(mnts)\\n pl.subplot(2,3,2)\\n bp.bin_scatter(y,b[:,idxBase+idx[i]],binsize=0.01,fmt='bo',scatter=True)\\n pl.xlabel('y decenter')\\n pl.ylabel(zernikeName[i+1])\\n pl.title(mnts)\\n pl.subplot(2,3,3)\\n bp.bin_scatter(z,b[:,idxBase+idx[i]],binsize=0.01,fmt='bo',scatter=True)\\n pl.xlabel('z-defocus')\\n pl.ylabel(zernikeName[i+1])\\n pl.title(mnts)\\n pl.subplot(2,3,4)\\n bp.bin_scatter(thetax,b[:,idxBase+idx[i]],binsize=5,fmt='bo',scatter=True)\\n pl.xlabel('x-tilt')\\n pl.ylabel(zernikeName[i+1])\\n pl.title(mnts)\\n pl.subplot(2,3,5)\\n bp.bin_scatter(thetay,b[:,idxBase+idx[i]],binsize=5,fmt='bo',scatter=True)\\n pl.xlabel('y-tilt')\\n pl.ylabel(zernikeName[i+1])\\n pl.title(mnts)\\n pl.savefig(mnts+'_'+str(i+1)+'_'+zernikeName[i+1]+'.png')\\n pl.close()\",\n \"def integrate(coords,data,fault_pts,dshape_hex8,gll_weights,elmt):\\n norm=0.0\\n normx=0.0\\n normy=0.0\\n normz=0.0\\n div=0.0 #normalizing factor to divide by\\n divx=0.\\n divy=0.\\n divz=0.\\n\\n eps=1.0*g.mesh_spacing/(g.ngllx-1.)\\n print 'eps=', eps\\n f=open('eliminated_coords.vtk','w')\\n\\n #create integer versions of arrays to use in pulling out gll pts for each element\\n data_round=np.rint(data)\\n dati=data_round.astype(int)\\n coord_round=np.rint(coords)\\n coordi=coord_round.astype(int)\\n\\n #remove duplicates from data array\\n dat_struc=np.ascontiguousarray(dati).view(np.dtype((np.void,dati.dtype.itemsize *dati.shape[1])))\\n _,idx=np.unique(dat_struc,return_index=True)\\n datu=dati[idx]\\n data_unique=data[idx]\\n\\n for i_elmt in range(g.nelmt):\\n #pull out geometric coordinates for this element\\n elmt_coord_id=[j-1 for j in elmt[i_elmt]]\\n elmt_coord=coordi[elmt_coord_id]\\n\\n #find corresponding gll pts for this element\\n xmin=min(elmt_coord[:,0]);xmax=max(elmt_coord[:,0])\\n ymin=min(elmt_coord[:,1]);ymax=max(elmt_coord[:,1])\\n zmin=min(elmt_coord[:,2]);zmax=max(elmt_coord[:,2])\\n gll_coord_id=np.nonzero((datu[:,0]>=xmin) & (datu[:,0]<=xmax) & (datu[:,1]>=ymin) & (datu[:,1]<=ymax) & (datu[:,2]>=zmin) & (datu[:,2]<=zmax))\\n elmt_data=data_unique[gll_coord_id]\\n if len(gll_coord_id[0]) != g.ngll:\\n print \\\"elmt=\\\", elmt_coord_id\\n print xmin,xmax,ymin,ymax,zmin,zmax\\n print 'elmt_data=', elmt_data\\n print \\\"gll pts found=\\\", len(gll_coord_id[0])\\n raise ValueError(\\\"incorrect number of gll points found in element!\\\")\\n exit\\n\\n #sort the gll coords so they correspond the order of the arrays giving the weights and shape function\\n dat_sorted=elmt_data[npi.argsort((elmt_data[:,0], elmt_data[:,1],elmt_data[:,2]))]\\n func=dat_sorted[:,3:]\\n\\n #if any gll pt is too close to fault, remove the element from the integration\\n dist=distance.cdist(fault_pts,dat_sorted[:,0:3],'euclidean')\\n if (dist<eps).any():\\n print \\\"eliminated element #\\\", i_elmt\\n np.savetxt(f,dat_sorted[:,0:3],fmt='%3.3f')\\n continue\\n\\n for i_gll in range(g.ngll):\\n\\n #compute jacobian, its derivative and inverse\\n jac=np.matmul(dshape_hex8[:,:,i_gll],elmt_coord)\\n det_jac=np.linalg.det(jac)\\n\\n #perform the integration\\n norm=norm+det_jac*gll_weights[i_gll]*np.dot((func[i_gll,3:6]-func[i_gll,0:3]),(func[i_gll,3:6]-func[i_gll,0:3]))\\n div=div+det_jac*gll_weights[i_gll]*np.dot(func[i_gll,3:6],func[i_gll,3:6])\\n normx=normx+det_jac*gll_weights[i_gll]*(func[i_gll,3]-func[i_gll,0])**2\\n divx=divx+det_jac*gll_weights[i_gll]*(func[i_gll,3])**2\\n normy=normy+det_jac*gll_weights[i_gll]*(func[i_gll,4]-func[i_gll,1])**2\\n divy=divy+det_jac*gll_weights[i_gll]*(func[i_gll,4])**2\\n normz=normz+det_jac*gll_weights[i_gll]*(func[i_gll,5]-func[i_gll,2])**2\\n divz=divz+det_jac*gll_weights[i_gll]*(func[i_gll,5])**2\\n\\n norm_finalx=sqrt(normx/divx)\\n norm_finaly=sqrt(normy/divy)\\n norm_finalz=sqrt(normz/divz)\\n norm_final=sqrt(norm/div)\\n\\n f.close()\\n\\n return norm_finalx, norm_finaly, norm_finalz,norm_final\",\n \"def test_nearest_neighbour_regular_1d():\\n # test with regular grid and 1d coords\\n grid_lon = np.arange(100)\\n grid_lat = np.arange(50)\\n data = np.zeros((50, 100))\\n\\n # the four nearest values for the first point\\n data[20:22, 10:12] = 7\\n\\n # the four nearest values for the second point\\n data[17:19, 13:15] = 8\\n\\n # the actual test\\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, (10.2, 13.2), (20.2, 17.2), npoints=4)(data)\\n np.testing.assert_array_almost_equal(res, [7, 8])\\n\\n # same test, but with 3d-data (e.g., level, lat, lon)\\n data2 = np.zeros((10, 50, 100))\\n for i in range(10):\\n data2[i, :, :] = data + i\\n\\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, (10.2, 13.2), (20.2, 17.2), npoints=4)(data2)\\n np.testing.assert_array_almost_equal(res, np.asarray([np.arange(7, 17, 1), np.arange(8, 18, 1)]).transpose())\\n\\n # same test with only one neighbour or only one target point\\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, (10.2, 13.2), (20.2, 17.2), npoints=1)(data)\\n np.testing.assert_array_almost_equal(res, [7, 8])\\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, 10.2, 20.2, npoints=1)(data)\\n np.testing.assert_array_almost_equal(res, 7)\\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, 13.2, 17.2, npoints=1)(data2)\\n np.testing.assert_array_almost_equal(res, np.arange(8, 18, 1).reshape(10, 1))\",\n \"def plotSolitonIntersection():\\n \\n cells = np.loadtxt('cells.txt') #file with several cell [x0 y0 x1 y1 x2 y2 x3 y3], each cell in seperate row (at least 2 needed)\\n cells = np.hstack([cells,cells[:,:2]])\\n for cell in cells:\\n plt.plot(cell[::2],cell[1::2])\\n\\n np.savetxt('X.txt',sorted(cells.flatten()[::2]))\\n subprocess.call('solitonEta 0.3 15 0 X.txt',shell=True)\\n soliton = np.loadtxt('eta.txt')\\n plt.plot(soliton[:,0],soliton[:,1])\\n\\n #ipdb.set_trace()\\n plt.savefig('boxes.png')\\n plt.show()\",\n \"def check_interp(self):\\n\\n points = np.loadtxt(\\\"skeleton_temp/\\\" + cell + \\\"_points.txt\\\", delimiter=',')\\n\\n self.initial_scatter = ax.scatter(points[:, 0],\\n points[:, 1],\\n points[:, 2], s=5, c='r')\\n self.cell_points = self.get_cell_xyz()\\n ax.scatter(self.cell_points[::5, 0],\\n self.cell_points[::5, 1],\\n self.cell_points[::5, 2], s=3, c='b', alpha=.03)\\n ax.set_xlabel('X (um)')\\n ax.set_ylabel('Y (um)')\\n ax.set_zlabel('Z (um)')\",\n \"def print_components_sizes(distance, points):\\n SortedX = sorted([point for point in points], key = abscisse)\\n\\n result = prochesX(SortedX, distance)\\n dernier_pointX_1 = result[len(result)-1]\\n dernier_indice = SortedX.index(dernier_pointX_1)\\n\\n origine = Point([0.0, 0.0])\\n segment_1 = Segment([Point([dernier_pointX_1.x, 0]), Point([dernier_pointX_1.x, 1])])\\n\\n SortedY = sorted([point for point in result], key = ordonnee)\\n result_bis = prochesY(SortedY, distance)\\n dernier_pointXbis_1 = result_bis[len(result_bis)-1]\\n dernier_indice_bis = SortedX.index(dernier_pointXbis_1)\\n\\n segment_2 = Segment([Point([0, dernier_pointXbis_1.y]), Point([1, dernier_pointXbis_1.y])])\\n tycat(origine, points, (segment_1, segment_2))\\n \\\"\\\"\\\"\\n affichage des tailles triees de chaque composante\\n \\\"\\\"\\\"\\n segments = []\\n research_base = [point for point in points]\\n origine = Point([0.0, 0.0])\\n total = research_base.copy()\\n s = 0\\n enveloppe = []\\n while len(research_base) > 0:\\n current = research_base[0]\\n research_base.pop(0)\\n for point in research_base:\\n if current.distance_to(point) < distance:\\n s += 1\\n segments.append(Segment([current, point]))\\n enveloppe.append(s)\\n tycat(origine, total, segments)\",\n \"def plotVoronoiCell(self, cells):\\n for i in cells:\\n #i indexes volumes\\n i = self.nonBI[i] #now i indexes vor.point_region\\n\\n vI = self.vor.regions[self.vor.point_region[i]]\\n v = self.vor.vertices[vI, :]\\n r = v\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection='3d')\\n fig.set_size_inches(18.5, 9.5)\\n ax.set_title('Voronoi Cell of Particle ' + str(i))\\n ax.set_xlabel('x [m]')\\n ax.set_ylabel('y [m]')\\n ax.set_zlabel('z [m]')\\n ax.scatter(r[:, 0], r[:, 1], r[:, 2], s=5, alpha=0.5, label='Cell Boundaries')\\n ax.scatter(self.data[i, 0], self.data[i, 1], self.data[i, 2], s=25, label='Cell Center')\\n ax.set_xlim3d(np.min(self.data[:, 0]), np.max(self.data[:, 0]))\\n ax.set_ylim3d(np.min(self.data[:, 1]), np.max(self.data[:, 1]))\\n ax.set_zlim3d(np.min(self.data[:, 2]), np.max(self.data[:, 2]))\\n # limits = np.vstack((np.array([np.max(self.data[:, 0]), np.max(self.data[:, 1]), np.max(self.data[:, 2])]), np.array([np.min(self.data[:, 0]), np.min(self.data[:, 1]), np.min(self.data[:, 2])])))\\n # ax.scatter(limits[:, 0], limits[:, 1], limits[:, 2], s=1)\\n ax.legend()\",\n \"def plot_timeres(timeres):\\n tint = 24 / timeres\\n step = 255 / (tint + 1)\\n\\n cont = np.zeros((scale, scale))\\n for i in range(self.dataset.shape[0]):\\n posy = int(((self.dataset[i][0] - minLat) * normLat))\\n posx = int(((self.dataset[i][1] - minLon) * normLon))\\n if distrib:\\n cont[scale - posy - 1, posx - 1] += 1\\n else:\\n cont[scale - posy - 1, posx - 1] = 1\\n mxcont = np.max(cont)\\n\\n if distrib:\\n cont = cont / mxcont\\n for i in range(cont.shape[0]):\\n for j in range(cont.shape[1]):\\n if cont[i, j] > 0.01:\\n mymap.circle_marker(\\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\\n radius=cont[i, j] * (circlesize / scale),\\n line_color='#000000',\\n fill_color='#110000', fill_opacity=0.3)\\n # mymap.addradpoint(minLat+(((scale - i)-0.5)/normLat), minLon+((j+1.5)/normLon),\\n # cont[i,j]*(circlesize/scale), \\\"#FF0000\\\")\\n else:\\n for i in range(cont.shape[0]):\\n for j in range(cont.shape[1]):\\n if cont[i, j] > 0.01:\\n mymap.circle_marker(\\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\\n radius=30,\\n line_color='#000000',\\n fill_color='#110000', fill_opacity=0.3)\\n # mymap.addradpoint(minLat+(((scale - i )-0.5)/normLat),\\n # minLon+((j+1.5)/normLon), 30, \\\"#FF0000\\\")\\n for t in range(tint):\\n color = '#' + (str(hex((t + 1) * step))[2:]) + (\\n str(hex((t + 1) * step))[2:]) + 'FF' # (str(hex((t+1)*step))[2:])\\n cont = np.zeros((scale, scale))\\n for i in range(self.dataset.shape[0]):\\n posy = int(((self.dataset[i][0] - minLat) * normLat))\\n posx = int(((self.dataset[i][1] - minLon) * normLon))\\n stime = time.localtime(np.int32(self.dataset[i][2]))\\n evtime = stime[3]\\n if (evtime / timeres) == t:\\n if distrib:\\n cont[scale - posy - 1, posx - 1] += 1\\n else:\\n cont[scale - posy - 1, posx - 1] = 1\\n if distrib:\\n cont = cont / mxcont\\n for i in range(cont.shape[0]):\\n for j in range(cont.shape[1]):\\n if cont[i, j] > 0.01:\\n mymap.circle_marker(\\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\\n radius=cont[i, j] * (circlesize / scale),\\n line_color=color,\\n fill_color='#110000', fill_opacity=0.2)\\n else:\\n for i in range(cont.shape[0]):\\n for j in range(cont.shape[1]):\\n if cont[i, j] > 0.01:\\n mymap.circle_marker(\\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\\n radius=30,\\n line_color=color,\\n fill_color='#110000', fill_opacity=0.2)\",\n \"def svm_add_2d_hyperplane(model, ax, plotted_points):\\n X_MIN = np.min(plotted_points[:, 0])\\n X_MAX = np.max(plotted_points[:, 0])\\n Y_MIN = np.min(plotted_points[:, 1])\\n Y_MAX = np.max(plotted_points[:, 1])\\n # plot the line, the points, and the nearest vectors to the plane\\n xx, yy = np.mgrid[X_MIN:X_MAX:200j, Y_MIN:Y_MAX:200j]\\n Z = model.decision_function(np.c_[xx.ravel(), yy.ravel()])\\n Z = Z.reshape(xx.shape)\\n plot.contourf(xx, yy, Z, levels=np.linspace(\\n Z.min(), 0, 7), cmap=plot.cm.PuBu)\\n a = plot.contour(xx, yy, Z, levels=[0], linewidths=2, colors='darkred')\\n plot.contourf(xx, yy, Z, levels=[0, Z.max()], colors='palevioletred')\\n return a.collections[0]\",\n \"def plotSurface(surfaceFile, comp=2, points=False, tris=False,\\n profile=False, ax=None, annotate=True, norm=None,xscale=1, yscale=1):\\n verts,data,tris = load_h5(surfaceFile)\\n\\n if comp==3: #radial displacements\\n z = np.hypot(data[:,:,0], data[:,:,1]).flatten()\\n else:\\n z = data[:,:,comp].flatten()\\n #z = data[:,:,comp].flatten()\\n x = verts[:,0] / xscale\\n y = verts[:,1] / yscale\\n\\n #NOTE: need to change grid for linear spacing to work properly\\n xi = np.linspace(x.min(), x.max(), x.size)\\n yi = np.linspace(y.min(), y.max(), y.size)\\n zi = griddata(x,y,z, xi,yi, interp='nn') #'nn'\\n\\n #NOTE: getting error message here...\\n # linear interpolation requires exactly the same limits\\n #xi=np.arange(-15000.0,15000.0+1e-14,30000.0/x.size)\\n #yi=np.arange(-15000.0,15000.0+1e-14,30000.0/x.size)\\n #zi = griddata(x,y,z, xi,yi, interp='linear') #'nn'\\n #ValueError: output grid must have constant spacing when using interp='linear'\\n\\n if ax==None:\\n plt.figure()\\n else:\\n ax = plt.axes(ax)\\n\\n #plt.pcolor(xi, yi, zi, cmap=plt.cm.jet) #Very slow...\\n x1, x2, y1, y2 = [x.min(), x.max(), y.min(), y.max()]\\n im = plt.imshow(zi, cmap=plt.cm.jet, norm=norm, extent=[x1, x2, y1, y2])\\n\\n if annotate:\\n compdict = {0:'Ux',1:'Uy',2:'Uz',3:'Ur'}\\n plt.title('{} Displacement'.format(compdict[comp]))\\n plt.xlabel('Distance [m]')\\n plt.ylabel('Distance [m]')\\n cb = plt.colorbar()\\n cb.set_label('[m]')\\n\\n if points:\\n plt.plot(x,y,'k.')\\n\\n if type(tris) is np.ndarray:\\n plt.triplot(x, y, tris, 'k-')\\n\\n # EW profile line through the x-axis\\n if profile:\\n plt.axhline(linewidth=2, color='r')\\n Zi = zi[x.size/2,:]\\n plt.figure()\\n plt.plot(xi, Zi, 'b.-')\\n plt.title('Profile')\\n plt.xlabel('Distance [m]')\\n plt.ylabel('{} Displacement [m]'.format(compdict[comp]))\\n\\n return im\",\n \"def test_nearest_neighbour_unstructured():\\n # create coordinates\\n grid_lon = np.arange(100)\\n grid_lat = np.ones(100)\\n data = np.zeros(100)\\n\\n # the nearest 3 points\\n data[10:13] = 7\\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, (11.2, 2.2), (11.2, 13.2), npoints=3, src_grid=\\\"unstructured\\\")(data)\\n np.testing.assert_array_almost_equal(res, [7, 0])\\n\\n # same test, but with 2d-data (e.g., level, ncell)\\n data2 = np.zeros((10, 100))\\n for i in range(10):\\n data2[i, :] = data + i\\n\\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, (11.2, 2.2), (11.2, 13.2), npoints=3, src_grid=\\\"unstructured\\\")(data2)\\n np.testing.assert_array_almost_equal(res, np.asarray([np.arange(7, 17, 1), np.arange(0, 10, 1)]).transpose())\\n\\n # only one point\\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, 11.2, 13.2, npoints=3, src_grid=\\\"unstructured\\\")(data)\\n np.testing.assert_almost_equal(res, 7)\\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, 11.2, 13.2, npoints=3, src_grid=\\\"unstructured\\\")(data2)\\n np.testing.assert_array_almost_equal(res, np.arange(7, 17, 1).reshape(10, 1))\\n\\n # same test with one one neighbour point\\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, 11.2, 13.2, npoints=1, src_grid=\\\"unstructured\\\")(data)\\n np.testing.assert_almost_equal(res, 7)\\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, 11.2, 13.2, npoints=1, src_grid=\\\"unstructured\\\")(data2)\\n np.testing.assert_almost_equal(res, np.arange(7, 17, 1).reshape(10, 1))\",\n \"def getEps(data):\\r\\n X = pdist(data)\\r\\n\\r\\n Sq = squareform(X)\\r\\n\\r\\n FourthDist = []\\r\\n firstDist = []\\r\\n k = 10\\r\\n kNeighbors = []\\r\\n for idx in range(len(Sq)):\\r\\n Sq[idx] = np.sort(Sq[idx])\\r\\n\\r\\n for i in range(k):\\r\\n kNeighbors.append(Sq[:, i + 1])\\r\\n for i in range(k):\\r\\n kNeighbors[i] = np.sort(kNeighbors[i])\\r\\n\\r\\n for i in range(k):\\r\\n plt.plot(kNeighbors[i])\\r\\n\\r\\n plt.title('10 Nearest Point')\\r\\n plt.show()\",\n \"def problem5(self, s):\\n points = 0\\n\\n points = self.neighbor( 10, 10, s.nearest_neighbor)*3\\n points += self.neighbor(100, 10, s.nearest_neighbor)*3\\n points += self.neighbor( 10, 100, s.nearest_neighbor)*3\\n points += self.neighbor(100, 100, s.nearest_neighbor)*3\\n points += self.neighbor(100, 100, s.nearest_neighbor)*3\\n\\n _testDriver.get_code(s.nearest_neighbor)\\n print \\\"\\\\n(Check that scipy.spatial.KDTree is not used)\\\"\\n points *= self.grade(1)\\n \\n return points\",\n \"def test_nearest_neighbour_regular_2d():\\n # test with regular grid and 2d coords\\n grid_lon, grid_lat = np.meshgrid(np.arange(100), np.arange(50), indexing=\\\"ij\\\")\\n data = np.zeros((100, 50))\\n\\n # the four nearest values for the first point\\n data[10:12, 20:22] = 7\\n\\n # the four nearest values for the second point\\n data[13:15, 17:19] = 8\\n\\n # the actual test\\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, (10.2, 13.2), (20.2, 17.2), npoints=4)(data)\\n np.testing.assert_array_almost_equal(res, [7, 8])\\n\\n # same test, but with 3d-data (e.g., level, lon, lat)\\n data2 = np.zeros((10, 100, 50))\\n for i in range(10):\\n data2[i, :, :] = data + i\\n\\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, (10.2, 13.2), (20.2, 17.2), npoints=4)(data2)\\n np.testing.assert_array_almost_equal(res, np.asarray([np.arange(7, 17, 1), np.arange(8, 18, 1)]).transpose())\\n\\n # same test with one neighbour point\\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, 10.2, 20.2, npoints=1)(data2)\\n np.testing.assert_array_almost_equal(res, np.arange(7, 17, 1).reshape(10, 1))\\n res = enstools.interpolation.nearest_neighbour(grid_lon, grid_lat, (10.2, 13.2), (20.2, 17.2), npoints=1)(data2)\\n np.testing.assert_array_almost_equal(res, np.asarray([np.arange(7, 17, 1), np.arange(8, 18, 1)]).transpose())\",\n \"def spatial_planner():\\n from scipy.spatial import KDTree\\n # KDTree\",\n \"def plot_nhdp_hello_topology(options, tags=None, cursor=None):\\n options['cur_src'] = 'topo'\\n options['prefix'] = \\\"nhdp\\\"\\n ################################################################################\\n locs = options['locs']\\n colors = options['color2'](pylab.linspace(0, 1, 101))\\n ################################################################################\\n circ_max = 5\\n line_max = 10\\n floor_factor = 2\\n floor_skew = -0.25\\n line_min = 1\\n\\n hosts = get_hosts(options)\\n\\n for q, (tag_key, tag_id, nhdp_hi, nhdp_ht, mpr_minpdr) in enumerate(tags):\\n logging.info('tag_id=\\\\\\\"%s\\\\\\\" (%d/%d)', tag_id, q+1, len(tags))\\n fig2d = MyFig(options, rect=[0.1, 0.1, 0.8, 0.7], xlabel='x Coordinate', ylabel='y Coordinate')\\n fig3d = MyFig(options, rect=[0.1, 0.1, 0.8, 0.7], xlabel='x Coordinate', ylabel='y Coordinate', ThreeD=True)\\n if not q:\\n fig3d_onlynodes = MyFig(options, xlabel='x Coordinate [m]', ylabel='y Coordinate [$m$]', ThreeD=True)\\n\\n min_x = min_y = min_z = numpy.infty\\n max_x = max_y = max_z = 0\\n\\n # draw the nodes\\n for host in hosts:\\n try:\\n xpos, ypos, zpos = locs[host]\\n except KeyError:\\n logging.warning('no position found for node %s', host)\\n continue\\n\\n max_x = max(xpos, max_x)\\n max_y = max(ypos, max_y)\\n min_x = min(xpos, min_x)\\n min_y = min(ypos, min_y)\\n max_z = max(zpos, max_z)\\n min_z = max(zpos, min_z)\\n\\n fig2d.ax.plot(\\n xpos+zpos*floor_skew*floor_factor,\\n ypos+zpos*floor_factor,\\n 'o', color='black', ms=circ_max)\\n fig3d.ax.plot([xpos], [ypos], [zpos], 'o', color='black', ms=circ_max)\\n if not q:\\n color = 'black'\\n if host.startswith('a6'):\\n color = 'red'\\n elif host.startswith('a3'):\\n color = 'blue'\\n elif host.startswith('a7'):\\n color = 'orange'\\n fig3d_onlynodes.ax.plot([xpos], [ypos], [zpos], 'o', color=color, ms=circ_max)\\n fig2d.colorbar = fig2d.fig.add_axes([0.1, 0.875, 0.8, 0.025])\\n fig3d.colorbar = fig3d.fig.add_axes([0.1, 0.875, 0.8, 0.025])\\n drawBuildingContours(fig3d.ax, options)\\n drawBuildingContours(fig3d_onlynodes.ax, options)\\n\\n alinspace = numpy.linspace(0, 1, 100)\\n alinspace = numpy.vstack((alinspace, alinspace))\\n for tax in [fig2d.colorbar, fig3d.colorbar]:\\n tax.imshow(alinspace, aspect='auto', cmap=options['color2'])\\n tax.set_xticks(pylab.linspace(0, 100, 5))\\n tax.set_xticklabels(['$%.2f$' % l for l in pylab.linspace(0, 1, 5)], fontsize=0.8*options['fontsize'])\\n tax.set_yticks([])\\n tax.set_title('$PDR$', size=options['fontsize'])\\n fig2d.ax.axis((min_x-10, max_x+10, min_y-10, max_y+10+max_z*floor_factor+10))\\n fig2d.save('2d_%s' % (tag_id))\\n fig3d.save('3d_%s' % (tag_id))\\n if not q:\\n fig3d_onlynodes.save('3d')\",\n \"def render(static, tour_indices, save_path):\\n\\n plt.close('all')\\n print('static_shape', static.shape)\\n print('tour_indices_shape', tour_indices.shape)\\n\\n num_plots = 3 if int(np.sqrt(len(tour_indices))) >= 3 else 1\\n\\n _, axes = plt.subplots(nrows=num_plots, ncols=num_plots,\\n sharex='col', sharey='row')\\n\\n if num_plots == 1:\\n axes = [[axes]]\\n axes = [a for ax in axes for a in ax]\\n\\n for i, ax in enumerate(axes):\\n\\n # Convert the indices back into a tour\\n idx = tour_indices[i]\\n print('idx0', idx)\\n if len(idx.size()) == 1:\\n idx = idx.unsqueeze(0)\\n print('idx1', idx)\\n\\n idx = idx.expand(static.size(1), -1)\\n print('idx2', idx)\\n data = torch.gather(static[i].data, 1, idx).cpu().numpy()\\n print('data', data)\\n\\n start = static[i, :, 0].cpu().data.numpy()\\n x = np.hstack((start[0], data[0], start[0]))\\n y = np.hstack((start[1], data[1], start[1]))\\n print('x', x)\\n print('y', y)\\n\\n # Assign each subtour a different colour & label in order traveled\\n idx = np.hstack((0, tour_indices[i].cpu().numpy().flatten(), 0))\\n print('idx3', idx)\\n where = np.where(idx == 0)[0]\\n print('where', where)\\n\\n for j in range(len(where) - 1):\\n\\n low = where[j]\\n high = where[j + 1]\\n\\n if low + 1 == high:\\n continue\\n\\n ax.plot(x[low: high + 1], y[low: high + 1], zorder=1, label=j)\\n\\n ax.legend(loc=\\\"upper right\\\", fontsize=3, framealpha=0.5)\\n ax.scatter(x, y, s=4, c='r', zorder=2)\\n ax.scatter(x[0], y[0], s=20, c='k', marker='*', zorder=3)\\n\\n ax.set_xlim(0, 1)\\n ax.set_ylim(0, 1)\\n\\n plt.tight_layout()\\n plt.savefig(save_path, bbox_inches='tight', dpi=400)\",\n \"def make_pnts(start_point, end_point, path, cellsize):\\n pnts = misc.generateSamples(tran = [start_point, end_point], path = path)\\n \\n #Only do sampling at DEM with >3m resolution \\n if cellsize[0] >= 5:\\n pnts = misc.selectSamplePts([start_point, end_point], pnts, cellsize[0])\\n return pnts\",\n \"def plot_timeres(timeres):\\n tint = 24 / len(timeres.intervals)\\n step = 255 / (tint + 1)\\n\\n cont = np.zeros(cluster.num_clusters())\\n for i in range(self.dataset.shape[0]):\\n posy = self.dataset[i][0]\\n posx = self.dataset[i][1]\\n ejem = np.array([[posy, posx]]).reshape(1,-1)\\n ncl = cluster.predict(ejem)\\n ncl = ncl[0]\\n\\n if distrib:\\n cont[ncl] += 1\\n else:\\n cont[ncl] = 1\\n\\n # if distrib:\\n # cont = cont / np.max(cont)\\n # for i in range(cont.shape[0]):\\n # if cont[i] > 0.01:\\n # cx = cluster.cluster_centers_[i][0]\\n # cy = cluster.cluster_centers_[i][1]\\n # mymap.circle_marker(location=[cx, cy],\\n # radius=cont[i] * circlesize,\\n # line_color='#FF0000',\\n # fill_color='#110000')\\n # else:\\n # for i in range(cont.shape[0]):\\n # if cont[i] > 0.01:\\n # cx = cluster.cluster_centers_[i][0]\\n # cy = cluster.cluster_centers_[i][1]\\n # mymap.circle_marker(location=[cx, cy],\\n # radius=30,\\n # line_color='#FF0000',\\n # fill_color='#110000')\\n for t in range(tint):\\n color = '#' + (str(hex((t + 1) * step))[2:]) + \\\\\\n (str(hex((t + 1) * step))[2:]) + 'FF' # (str(hex((t+1)*step))[2:])\\n cont = np.zeros(cluster.num_clusters())\\n for i in range(self.dataset.shape[0]):\\n posy = self.dataset[i][0]\\n posx = self.dataset[i][1]\\n ejem = np.array([[posy, posx]]).reshape(1,-1)\\n ncl = cluster.predict(ejem)\\n ncl = ncl[0]\\n\\n _, evtime = timeres.discretize(self.dataset[i][2])\\n\\n if evtime == t:\\n if distrib:\\n cont[ncl] += 1\\n else:\\n cont[ncl] = 1\\n if distrib:\\n cont = cont / np.max(cont)\\n for i in range(cont.shape[0]):\\n if cont[i] > 0.01:\\n cx = cluster.cluster_centers_[i][0]\\n cy = cluster.cluster_centers_[i][1]\\n mymap.circle_marker(location=[cx, cy],\\n radius=cont[i] * circlesize,\\n line_color=pltcolors[t],\\n fill_color=pltcolors[t], #'#110000',\\n popup=str(t) + '-' + str(cont[i]), fill_opacity=0.2)\\n else:\\n for i in range(cont.shape[0]):\\n for j in range(cont.shape[1]):\\n if cont[i] > 0.01:\\n cx = cluster.cluster_centers_[i][0]\\n cy = cluster.cluster_centers_[i][1]\\n mymap.circle_marker(location=[cx, cy],\\n radius=30,\\n line_color=pltcolors[t],\\n fill_color=pltcolors[t], #'#110000',\\n popup=str(t) + '-' + str(cont[i]), fill_opacity=0.2)\",\n \"def rho_true(subj, T, test_set, bbox_ls):\\n res = (20,20)\\n x = 0.5*(test_set[subj][0,T] + test_set[subj][2,T])\\n y = 0.5*(test_set[subj][1,T] + test_set[subj][3,T])\\n print \\\"Rho TRUE\\\"\\n plt.scatter(x, y, s=60, color=\\\"grey\\\")\\n x_min = x-test_scene.bbox_width/2\\n x_max = x+test_scene.bbox_width/2\\n y_min = y-test_scene.bbox_width/2\\n y_max = y+test_scene.bbox_width/2\\n bbox_npy = np.array(bbox_ls)\\n x_width_arr = bbox_npy[:,0,0]\\n x_pos_arr = bbox_npy[:,1,0]\\n y_width_arr = bbox_npy[:,0,1]\\n y_pos_arr = bbox_npy[:,1,1]\\n pmax = lambda x,y: x*(x>y)+y*(y>x)\\n pmin = lambda x,y: x*(x<y)+y*(y<x)\\n x_left = pmax(x_min, x_pos_arr - x_width_arr/2.0)\\n x_right = pmin(x_max, x_pos_arr + x_width_arr/2.0)\\n y_bottom = pmax(y_min, y_pos_arr - y_width_arr/2.0)\\n y_top = pmin(y_max, y_pos_arr + y_width_arr/2.0)\\n out = (x_right-x_left)*(x_right>x_left)*(y_top-y_bottom)*(y_top>y_bottom)\\n out /= test_scene.bbox_width**2\\n return out\",\n \"def print_TRT_cell_map(samples_df,cfg_set_tds):\\r\\n\\r\\n fig, axes, extent = ccs4_map(cfg_set_tds)\\r\\n axes.scatter(samples_df[\\\"LV03_x\\\"].loc[samples_df[\\\"category\\\"] == \\\"DEVELOPING\\\"],\\r\\n samples_df[\\\"LV03_y\\\"].loc[samples_df[\\\"category\\\"] == \\\"DEVELOPING\\\"],c='w',edgecolor=(.7,.7,.7),s=18)\\r\\n axes.scatter(samples_df[\\\"LV03_x\\\"].loc[samples_df[\\\"category\\\"] == \\\"MODERATE\\\"],\\r\\n samples_df[\\\"LV03_y\\\"].loc[samples_df[\\\"category\\\"] == \\\"MODERATE\\\"],c='g',edgecolor=(.7,.7,.7),s=22)\\r\\n axes.scatter(samples_df[\\\"LV03_x\\\"].loc[samples_df[\\\"category\\\"] == \\\"SEVERE\\\"],\\r\\n samples_df[\\\"LV03_y\\\"].loc[samples_df[\\\"category\\\"] == \\\"SEVERE\\\"],c='y',edgecolor=(.7,.7,.7),s=26)\\r\\n axes.scatter(samples_df[\\\"LV03_x\\\"].loc[samples_df[\\\"category\\\"] == \\\"VERY SEVERE\\\"],\\r\\n samples_df[\\\"LV03_y\\\"].loc[samples_df[\\\"category\\\"] == \\\"VERY SEVERE\\\"],c='r',edgecolor=(.7,.7,.7),s=30)\\r\\n \\r\\n fig.savefig(os.path.join(cfg_set_tds[\\\"fig_output_path\\\"],u\\\"TRT_Map.pdf\\\"))\",\n \"def plot_tsne_with_colors_sorted(tsne_result, vector, cmap_use, save_tag=False, save_name='Test.pdf'):\\n vector = np.asarray(vector)\\n new_vector = [i[0] for i in vector]\\n idx = np.argsort(new_vector)\\n plt.scatter(tsne_result[idx, 0], tsne_result[idx, 1], c=cmap_use)\\n plt.axis('off')\\n if save_tag == True:\\n plt.savefig(\\n \\\"/Users/rohanramesh/Documents/SportsData/NBA/Figures/tsne_%s.png\\\" % save_name,\\n bbox_inches='tight', dpi=100)\\n plt.show()\",\n \"def render(static, tour_indices, save_path, test = False):\\n # if not test:\\n # matplotlib.use('Agg')\\n # if not os.path.exists(save_path):\\n # os.makedirs(save_path)\\n\\n plt.close('all')\\n if isinstance(static, torch.Tensor):\\n static = static.cpu()\\n if isinstance(tour_indices, torch.Tensor):\\n tour_indices = tour_indices.cpu()\\n\\n num_plots = 3 if int(np.sqrt(len(tour_indices))) >= 3 else 1\\n\\n _, axes = plt.subplots(nrows=num_plots, ncols=num_plots,\\n sharex='col', sharey='row')\\n\\n if num_plots == 1:\\n axes = [[axes]]\\n axes = [a for ax in axes for a in ax]\\n\\n for i, ax in enumerate(axes):\\n\\n # Convert the indices back into a tour\\n idx = tour_indices[i, :]\\n idx = idx[idx>-1]\\n static_ = static[i].data\\n\\n for idx_ in idx:\\n nearest_indices = cal_nearest_indices(static_, idx_)\\n for nearest_idx in nearest_indices:\\n pair_coor = torch.cat((static_[:,idx_].unsqueeze(0),static_[:,nearest_idx].unsqueeze(0))).transpose(1,0).numpy()\\n ax.plot(pair_coor[0], pair_coor[1], linestyle='--', color='k',zorder=1, linewidth='0.5')\\n\\n\\n # End tour at the starting index\\n idx = torch.cat((idx, idx[0].unsqueeze(0)))\\n idx = idx.repeat(2, 1) # (2,6)\\n\\n data = torch.gather(static[i].data, 1, idx).cpu().numpy()\\n\\n #plt.subplot(num_plots, num_plots, i + 1)\\n ax.plot(data[0], data[1], zorder=1)\\n ax.scatter(static_[0], static_[1], s=4, c='r', zorder=2)\\n ax.scatter(data[0, 0], data[1, 0], s=20, c='k', marker='*', zorder=3)\\n\\n # ax.set_xlim(0, 1)\\n # ax.set_ylim(0, 1)\\n\\n plt.tight_layout()\\n plt.show()\\n print(save_path)\\n plt.savefig(save_path, bbox_inches='tight', dpi=400)\",\n \"def watershed_segment_2(M,click_coords):\\n \\n # todo: choose these structures based on aspect ratio of M and input parameters\\n sel = np.ones((4,10)) # for opening\\n sel2 = np.ones((15,75)) # for local thresholding\\n sel3 = np.ones((2,5)) # for erosion\\n # get a few points in the center of each blob\\n \\n # threshold\\n #bw = ((M>=ndi.percentile_filter(M,80,footprint=sel2)) & (M>=scoreatpercentile(M.flatten(),60)))\\n \\n score = stats.percentileofscore(M.flatten(),M[int(click_coords[0][1]),int(click_coords[0][0])])\\n bw = (M>=stats.scoreatpercentile(M.flatten(),score))\\n\\n # open and erode\\n #bools = sp.zeros((M.shape[0],M.shape[1]),int)\\n #bools[int(click_coords[0]),int(click_coords[1])] = 1\\n #blobs = sp.where(bools == 1,True,False)\\n blobs = snm.binary_opening(bw,structure=sel)\\n blobs = snm.binary_dilation(blobs,iterations=3)\\n blobs = snm.binary_erosion(blobs,structure=sel3)\\n \\n \\n # label\\n labels,_ = ndi.label(blobs)\\n labels[labels > 0] += 1\\n #labels[0,0] = 1\\n\\n # rescale and cast to int16, then use watershed\\n M2 = rescaled(M,0,65000).astype(np.uint16)\\n newlabels = ndi.watershed_ift(M2,labels)\\n \\n # get rid of groups unless they have the right number of pixels\\n counts = np.bincount(newlabels.flatten())\\n old2new = np.arange(len(counts))\\n old2new[(counts < 100) | (counts > 600)] = 0\\n newlabels = old2new[newlabels]\\n \\n return newlabels\",\n \"def _create_tecplot_solids(grid, model, nsolids, ntets, tets, nhexas, hexas, is_surface=True):\\n if is_surface:\\n if nhexas:\\n free_faces = np.array(model.get_free_faces(), dtype='int32')# + 1\\n nfaces = len(free_faces)\\n nelements = nfaces\\n unused_elements = free_faces\\n grid.Allocate(nfaces, 1000)\\n\\n #elem.GetCellType() = 9 # vtkQuad\\n for face in free_faces:\\n elem = vtkQuad()\\n epoints = elem.GetPointIds()\\n epoints.SetId(0, face[0])\\n epoints.SetId(1, face[1])\\n epoints.SetId(2, face[2])\\n epoints.SetId(3, face[3])\\n grid.InsertNextCell(9, epoints)\\n else:\\n # is_volume\\n grid.Allocate(nsolids, 1000)\\n if ntets:\\n for node_ids in tets:\\n elem = vtkTetra()\\n epoints = elem.GetPointIds()\\n epoints.SetId(0, node_ids[0])\\n epoints.SetId(1, node_ids[1])\\n epoints.SetId(2, node_ids[2])\\n epoints.SetId(3, node_ids[3])\\n #elem.GetCellType() = 5 # vtkTriangle\\n grid.InsertNextCell(elem.GetCellType(), epoints)\\n\\n\\n if nhexas:\\n for node_ids in hexas:\\n elem = vtkHexahedron()\\n epoints = elem.GetPointIds()\\n epoints.SetId(0, node_ids[0])\\n epoints.SetId(1, node_ids[1])\\n epoints.SetId(2, node_ids[2])\\n epoints.SetId(3, node_ids[3])\\n epoints.SetId(4, node_ids[4])\\n epoints.SetId(5, node_ids[5])\\n epoints.SetId(6, node_ids[6])\\n epoints.SetId(7, node_ids[7])\\n #elem.GetCellType() = 5 # vtkTriangle\\n grid.InsertNextCell(elem.GetCellType(), epoints)\\n return nelements\",\n \"def plot_distance(stc_est, stc_signal, D, surface='inflated'):\\n import surfer # Import here so other parts of the code can be used without graphics\\n peak = stc_est.get_peak(vert_as_index=True)[0]\\n peak_hemi = 0 if peak < len(stc_est.vertices[0]) else 1\\n true_hemi = config.signal_hemi\\n\\n est_vert = np.hstack(stc_est.vertices)[peak]\\n true_vert = stc_signal.vertices[true_hemi][0]\\n\\n brain = surfer.Brain('sample', hemi='both', surf=surface)\\n brain.add_data(D[peak, :len(stc_est.vertices[0])], vertices=stc_est.vertices[0],\\n hemi='lh', transparent=True)\\n brain.add_data(D[peak, len(stc_est.vertices[0]):], vertices=stc_est.vertices[1],\\n hemi='rh', transparent=True)\\n brain.add_foci([est_vert], coords_as_verts=True, hemi='lh' if peak_hemi == 0 else 'rh', color='red')\\n brain.add_foci([true_vert], coords_as_verts=True, hemi='lh' if true_hemi == 0 else 'rh', color='green')\\n return brain\",\n \"def output_grid_information():\\n # translate = [-74.26, 40.50]\\n # scale = [0.02, 0.02]\\n # step = 1\\n\\n translate = [0, 0]\\n scale = [1, 1]\\n step = 0.02\\n\\n lon_limits = [(-74.26 - translate[0]) / scale[0], (-73.76 - translate[0]) / scale[0]]\\n lat_limits = [(40.48 - translate[1]) / scale[1], (40.94 - translate[1]) / scale[1]]\\n\\n lons = np.arange(lon_limits[0], lon_limits[1] - step, step)\\n lats = np.arange(lat_limits[0], lat_limits[1] - step, step)\\n\\n all_json = {\\n \\\"type\\\": \\\"FeatureCollection\\\"\\n }\\n\\n gr_id = 0\\n grid_df = pd.DataFrame(columns=['gr_id', 'c_lat', 'c_lon', 's_lon', 'w_lat', 'n_lon', 'e_lat'])\\n features = []\\n\\n for lat in lats:\\n for lon in lons:\\n w_lon = lon\\n e_lon = lon + step\\n s_lat = lat\\n n_lat = lat + step\\n\\n c_lon = lon + step / 2\\n c_lat = lat + step / 2\\n\\n grid_df = grid_df.append(pd.DataFrame({\\\"gr_id\\\": [gr_id],\\n \\\"c_lon\\\": [c_lon], \\\"c_lat\\\": [c_lat],\\n \\\"w_lon\\\": [w_lon], \\\"s_lat\\\": [s_lat],\\n \\\"e_lon\\\": [e_lon], \\\"n_lat\\\": [n_lat]}))\\n\\n coor = [[[s_lat, w_lon], [n_lat, w_lon], [n_lat, e_lon],\\n [s_lat, e_lon], [s_lat, w_lon]]]\\n\\n feature = {\\n \\\"type\\\": \\\"Feature\\\",\\n \\\"geometry\\\": {\\n \\\"type\\\": \\\"Polygon\\\",\\n \\\"coordinates\\\": coor\\n },\\n \\\"properties\\\": {\\n \\\"id\\\": str(gr_id)\\n }\\n }\\n\\n features.append(feature)\\n\\n gr_id += 1\\n\\n all_json['features'] = features\\n\\n with open(BaseDir + '/grid.geojson', 'w') as f:\\n json.dump(all_json, f)\\n\\n grid_df.to_csv(BaseDir + '/grid_locs.csv', index=False)\",\n \"def get_contour_features(mask,selectcell=\\\"centered\\\"):\\r\\n \\r\\n #binarize image (everything above 0 becomes 1)\\r\\n mask = np.clip(mask,a_min=0,a_max=1)\\r\\n\\r\\n #for contours, dont use RETR_TREE, but RETR_EXTERNAL as we are not interested in internal objects\\r\\n contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\\r\\n contours = list(contours)\\r\\n \\r\\n #in case there is no contour found, add a dummy contour\\r\\n if len(contours)==0:\\r\\n contours = [np.array([[[0, 0]],[[0, 1]],[[1, 1]],[[1, 0]]])] #generate a dummy contour\\r\\n\\r\\n #Sort contours, longest first\\r\\n contours.sort(key=len,reverse=True)\\r\\n contours = [c for c in contours if len(c)>4] #proper contour should have at least 5 points\\r\\n hulls = [cv2.convexHull(contour,returnPoints=True) for contour in contours]\\r\\n\\r\\n mu_origs = [cv2.moments(contour) for contour in contours]\\r\\n mu_hulls = [cv2.moments(hull) for hull in hulls]\\r\\n\\r\\n area_origs = [mu_orig[\\\"m00\\\"] for mu_orig in mu_origs]\\r\\n area_hulls = [mu_hull[\\\"m00\\\"] for mu_hull in mu_hulls]\\r\\n\\r\\n #drop events where area is zero\\r\\n hulls = [hulls[i] for i in range(len(hulls)) if area_origs[i]>0] \\r\\n contours = [contours[i] for i in range(len(contours)) if area_origs[i]>0]\\r\\n mu_origs = [mu_origs[i] for i in range(len(mu_origs)) if area_origs[i]>0]\\r\\n mu_hulls = [mu_hulls[i] for i in range(len(mu_hulls)) if area_origs[i]>0]\\r\\n area_hulls = [area_hulls[i] for i in range(len(area_hulls)) if area_origs[i]>0]\\r\\n area_origs = [area_origs[i] for i in range(len(area_origs)) if area_origs[i]>0]\\r\\n \\r\\n \\r\\n pos_x = [int(mu_orig['m10']/mu_orig['m00']) for mu_orig in mu_origs]\\r\\n pos_y = [int(mu_orig['m01']/mu_orig['m00']) for mu_orig in mu_origs]\\r\\n\\r\\n \\r\\n if selectcell == \\\"smooth\\\":\\r\\n #compute the area ratio (roughness of contour)\\r\\n area_ratio = np.array(area_hulls)/np.array(area_origs)\\r\\n #get the contour with minimum roughness (smooth contour)\\r\\n sorter = np.argsort(area_ratio) #smallest first\\r\\n\\r\\n if selectcell == \\\"centered\\\":\\r\\n #select contour that is closest to the center of the image. \\r\\n #In iPAC, cells are usually in the center.\\r\\n mid_x,mid_y = mask.shape[0]/2,mask.shape[1]/2 #middle of the image\\r\\n BB = [cv2.boundingRect(c) for c in contours] #get a bounding box around the object\\r\\n distances = [np.sqrt((mid_x-bb[0])**2 + (mid_y-bb[1])**2) for bb in BB]\\r\\n sorter = np.argsort(distances) #smallest first\\r\\n \\r\\n #sort values with respect to chosen metric (area_ratio or distance)\\r\\n contours = [contours[s] for s in sorter]\\r\\n hulls = [hulls[s] for s in sorter]\\r\\n pos_x = [pos_x[s] for s in sorter]\\r\\n pos_y = [pos_y[s] for s in sorter]\\r\\n mu_origs = [mu_origs[s] for s in sorter]\\r\\n area_origs = [area_origs[s] for s in sorter]\\r\\n area_hulls = [area_hulls[s] for s in sorter]\\r\\n \\r\\n # draw mask of the chosen contour\\r\\n mask = np.zeros_like(mask)\\r\\n cv2.drawContours(mask,contours,0,1,cv2.FILLED)# produce a contour that is filled inside\\r\\n\\r\\n hull = hulls[0]#[0:n_contours]\\r\\n pos_x = pos_x[0]\\r\\n pos_y = pos_y[0] \\r\\n mu_orig = mu_origs[0]#[0:n_contours]\\r\\n area_orig = area_origs[0]#[0:n_contours]\\r\\n area_hull = area_hulls[0]#[0:n_contours]\\r\\n \\r\\n if area_orig>0:\\r\\n area_ratio = area_hull/area_orig\\r\\n else:\\r\\n area_ratio = np.nan\\r\\n\\r\\n arc = cv2.arcLength(hull, True) \\r\\n circularity = 2.0 * np.sqrt(np.pi * mu_orig[\\\"m00\\\"]) / arc\\r\\n\\r\\n\\r\\n dic = {\\\"mask\\\":mask,\\\"pos_x\\\":pos_x,\\\"pos_y\\\":pos_y,\\\"area_orig\\\":area_orig,\\\"area_hull\\\":area_hull,\\\\\\r\\n \\\"area_ratio\\\":area_ratio,\\\"circularity\\\":circularity}\\r\\n return dic\",\n \"def plot_screen(tiles, gazepoints, tolerance=0, filepath=None):\\n\\n #read gaze points\\n gazeX = gazepoints['pixels'].map(lambda x: x.x)\\n gazeY = gazepoints['pixels'].map(lambda x: x.y)\\n gazeI = gazepoints.index\\n\\n\\n #create figure\\n fig = plt.figure(figsize=(16,9))\\n ax = fig.add_subplot(111)\\n\\n ax.set_xlim(-200,2120)\\n ax.set_ylim(-200,1280)\\n ax.set_ylim(ax.get_ylim()[::-1])\\n ax.add_patch(plt.Rectangle((0,0),1920,1080,alpha = 0.05,color = 'b'))\\n gax = ax.scatter(gazeX, gazeY, s= 10, c = gazeI, cmap = plt.cm.Reds, label = 'gaze')\\n fig.colorbar(gax, format = '%d')\\n\\n #draw the objects\\n tolerances = []\\n for tile in tiles:\\n if tile.is_selected:\\n ax.text(tile.x, tile.y, tile.shape, size = 'xx-large', weight = 'bold',\\n color = tile.color, bbox=dict(facecolor='red', alpha=0.5))\\n else:\\n ax.text(tile.x, tile.y, tile.shape, size = 'xx-large', weight = 'bold', color = tile.color)\\n #draw the tolerance circles\\n circle = plt.Circle((tile.x, tile.y), tolerance, color='r', fill=False)\\n ax.add_patch(circle)\\n if filepath is not None:\\n fig.savefig(filepath, format=filepath.split('.')[1])\",\n \"def hot_plate(n,c=None):\\n A,b=finite_difference(n)\\n if c is None:\\n u=linalg.spsolve(A.tocsr(),b)\\n \\n else:\\n u=linalg.spsolve(A.tocsr(),c)\\n \\n \\n x=np.linspace(1,n,n)\\n y=np.linspace(1,n,n)\\n X,Y=np.meshgrid(x,y)\\n Z=u.reshape((n,n))\\n \\n \\n \\n \\n # Plot the heat map of f over the 2-D domain.\\n plt.pcolormesh(X, Y, Z, cmap=\\\"seismic\\\")\\n plt.colorbar()\\n plt.xlim(1,n)\\n plt.ylim(1,n)\\n plt.show()\",\n \"def create_local_grid(points: np.ndarray, edge_sides: dict, triangles: np.ndarray,\\n fault_is_plane: bool, resolution: float=5000.0, num_search_tris: int=10):\\n\\n # Edge coordinates.\\n left_edge = edge_sides['left_edge']\\n right_edge = edge_sides['right_edge']\\n bottom_edge = edge_sides['bottom_edge']\\n top_edge = edge_sides['top_edge']\\n\\n # Determine number of points in each direction.\\n left_diffs = np.diff(left_edge, axis=0)\\n left_length = np.sum(np.linalg.norm(left_diffs, axis=1))\\n num_divs_left = left_length/resolution\\n\\n right_diffs = np.diff(right_edge, axis=0)\\n right_length = np.sum(np.linalg.norm(right_diffs, axis=1))\\n num_divs_right = right_length/resolution\\n\\n num_vert_points = int(round(0.5*(num_divs_left + num_divs_right))) + 1\\n\\n bottom_diffs = np.diff(bottom_edge, axis=0)\\n bottom_length = np.sum(np.linalg.norm(bottom_diffs, axis=1))\\n num_divs_bottom = bottom_length/resolution\\n\\n top_diffs = np.diff(top_edge, axis=0)\\n top_length = np.sum(np.linalg.norm(top_diffs, axis=1))\\n num_divs_top = top_length/resolution\\n\\n num_horiz_points = int(round(0.5*(num_divs_bottom + num_divs_top))) + 1\\n num_points = num_vert_points*num_horiz_points\\n\\n # Get interpolated points on edges.\\n ygrid_left = np.linspace(left_edge[0,1], left_edge[-1,1], num=num_vert_points, dtype=np.float64)\\n xgrid_left = np.interp(ygrid_left, left_edge[:,1], left_edge[:,0])\\n zgrid_left = np.interp(ygrid_left, left_edge[:,1], left_edge[:,2])\\n ygrid_right = np.linspace(right_edge[0,1], right_edge[-1,1], num=num_vert_points, dtype=np.float64)\\n xgrid_right = np.interp(ygrid_right, right_edge[:,1], right_edge[:,0])\\n zgrid_right = np.interp(ygrid_right, right_edge[:,1], right_edge[:,2])\\n xgrid_bottom = np.linspace(bottom_edge[0,0], bottom_edge[-1,0], num=num_horiz_points, dtype=np.float64)\\n ygrid_bottom = np.interp(xgrid_bottom, bottom_edge[:,0], bottom_edge[:,1])\\n zgrid_bottom = np.interp(xgrid_bottom, bottom_edge[:,0], bottom_edge[:,2])\\n xgrid_top = np.linspace(top_edge[0,0], top_edge[-1,0], num=num_horiz_points, dtype=np.float64)\\n ygrid_top = np.interp(xgrid_top, top_edge[:,0], top_edge[:,1])\\n zgrid_top = np.interp(xgrid_top, top_edge[:,0], top_edge[:,2])\\n\\n # Create 2D mesh.\\n mesh_points = np.zeros((num_vert_points, num_horiz_points, 3), dtype=np.float64)\\n\\n # We need to do this for points on the boundary, which might fall outside a mesh triangle.\\n if not(fault_is_plane):\\n z = np.zeros((num_vert_points, num_horiz_points), dtype=np.float64)\\n is_mesh_edge = np.zeros((num_vert_points, num_horiz_points), dtype=np.bool)\\n is_mesh_edge[0,:] = True\\n is_mesh_edge[-1,:] = True\\n is_mesh_edge[:,0] = True\\n is_mesh_edge[:,-1] = True\\n z[:,0] = zgrid_left\\n z[:,-1] = zgrid_right\\n z[0,:] = zgrid_bottom\\n z[-1,:] = zgrid_top\\n \\n for row_num in range(num_vert_points):\\n mesh_points[row_num,:,0] = np.linspace(xgrid_left[row_num], xgrid_right[row_num],\\n num=num_horiz_points, dtype=np.float64)\\n for col_num in range(num_horiz_points):\\n mesh_points[:,col_num,1] = np.linspace(ygrid_bottom[col_num], ygrid_top[col_num],\\n num=num_vert_points, dtype=np.float64)\\n\\n # If surface is not a plane, interpolate to get z-coordinates.\\n mesh_points = mesh_points.reshape(num_points, 3)\\n if not(fault_is_plane):\\n is_mesh_edge = is_mesh_edge.reshape(num_points)\\n z = z.reshape(num_points)\\n mesh_points[:,2] = tri_interpolate_zcoords(points, triangles, mesh_points[:,0:2],\\n is_mesh_edge, num_search_tris=num_search_tris)\\n mesh_points[is_mesh_edge,2] = z[is_mesh_edge]\\n\\n return (mesh_points, num_horiz_points, num_vert_points)\",\n \"def triangle_contour(x_center, y_center, values, smoothing, ckwargs={}):\\n # make Triangulation object using the centers of each of the hexbins\\n triag = Triangulation(x_center, y_center)\\n refiner = UniformTriRefiner(triag) # refines the mesh of triangle\\n # returns refines triangle field of triangles and interpolated\\n # contour values by dividing each triangle into 4**subdiv triangles\\n tri_refi, c_refi = refiner.refine_field(values, subdiv=smoothing)\\n T = pl.tricontour(tri_refi, c_refi, **ckwargs)\\n return T\",\n \"def findminpath(tab, gxtab, gytab, pixtab):\\n\\n pathdist = 2 # the number of points each points on a ray can related to on the previous ray\\n pathdist_penalty = 0.3 # penalty of the difference of the pathdist\\n pathpix_penalty = 2 # penalty of the difference of pixel values between the point and the previous point\\n nray = tab.shape[1]\\n\\n #tab = np.hstack((tab,tab[:, 0].reshape(tab.shape[0], 1)))\\n #pixtab = np.hstack((pixtab,pixtab[:, 0].reshape(pixtab.shape[0], 1)))\\n #gxtab = np.hstack((gxtab,gxtab[:, 0].reshape(gxtab.shape[0], 1)))\\n #gytab = np.hstack((gytab,gytab[:, 0].reshape(gytab.shape[0], 1)))\\n\\n tab = np.hstack((tab,tab,tab)) # horizontally stack the tab matrix to prepare for the filtering on the result\\n pixtab = np.hstack((pixtab,pixtab,pixtab))\\n gxtab = np.hstack((gxtab,gxtab,gxtab))\\n gytab = np.hstack((gytab,gytab,gytab))\\n\\n tab = (tab - tab.min()) / (tab.max() - tab.min()) # noralize the tab matrix\\n pixtab = (pixtab - pixtab.min()) / (pixtab.max() - pixtab.min()) * -1 # for we want to find the white contour of the cell so we multipy -1 on the pixtab\\n # tab = tab / np.median(tab)\\n # pixtab = pixtab / np.median(pixtab)\\n path = np.zeros(tab.shape)\\n path[:, 0] = np.array(range(0, tab.shape[0]))\\n score = np.zeros(tab.shape)\\n score[:, 1] = tab[:, 1]\\n\\n for i in range(1, tab.shape[1]):\\n for j in range(tab.shape[0]):\\n mins = np.Inf # record the min value of the ray\\n minat = 0\\n for k in range(-pathdist, pathdist+1):\\n if(0 <= (j+k) and (j+k) < tab.shape[0]):\\n s = pixtab[j, i]\\n pixdiff = abs(pixtab[j, i] - pixtab[j+k, i-1])\\n s += pixdiff * pathpix_penalty # two kinds of penalty\\n s += abs(k) * pathdist_penalty\\n s += score[j+k, i-1]\\n\\n if(s < mins):\\n mins = s\\n minat = j + k\\n path[j, i] = minat\\n score[j, i]= mins\\n\\n start = int(np.argmin(score[:, -1]))\\n path = path.astype(np.int32)\\n minpath = [start]\\n for i in range(tab.shape[1]-1, 0, -1):\\n minpath.append(path[minpath[-1], i])\\n minpath = minpath[::-1]\\n # print(len(minpath))\\n minpath = savgol_filter(minpath, 15, 3) # apply a Savitzky-Golay filter to the raw minpath signal\\n minpath = minpath[nray:nray*2] # cut the middle part of minpath whose length is nray\\n return np.array(minpath).astype(np.int32)\",\n \"def do_jet_pt_plots(tree, output_dir, cut=''):\\n for logz, normx in product([True, False], [True, False]):\\n make_2d_plot(tree, 'httL1', HTT_L1_STR, NB_HTT, HTT_MIN, HTT_MAX, 'pt', PT_L1_STR, NB_PT, PT_MIN, PT_MAX,\\n os.path.join(output_dir, 'pt_httL1.pdf'), logz=logz, normx=normx,\\n cut=cut, title=TITLE, diagonal_line=True)\\n make_2d_plot(tree, 'httL1', HTT_L1_STR, NB_HTT, HTT_MIN, HTT_MAX, 'ptRef', PT_REF_STR, NB_PT, PT_MIN, PT_MAX,\\n os.path.join(output_dir, 'ptRef_httL1.pdf'), logz=logz, normx=normx,\\n cut=cut, title=TITLE, diagonal_line=True)\\n make_2d_plot(tree, 'httRef', HTT_REF_STR, NB_HTT, HTT_MIN, HTT_MAX, 'pt', PT_L1_STR, NB_PT, PT_MIN, PT_MAX,\\n os.path.join(output_dir, 'pt_httRef.pdf'), logz=logz, normx=normx,\\n cut=cut, title=TITLE, diagonal_line=True)\\n make_2d_plot(tree, 'httRef', HTT_REF_STR, NB_HTT, HTT_MIN, HTT_MAX, 'ptRef', PT_REF_STR, NB_PT, PT_MIN, PT_MAX,\\n os.path.join(output_dir, 'ptRef_httRef.pdf'), logz=logz, normx=normx,\\n cut=cut, title=TITLE, diagonal_line=True)\",\n \"def get_shortest_path_cell(\\n self,\\n xP0,\\n yP0,\\n xP1,\\n yP1,\\n npoint_ref=1,\\n debug_info=False,\\n ):\\n # find indices of endpoints\\n if self.on_sphere:\\n idxP0 = get_index_lonlat(xP0, yP0, self.xcell, self.ycell)\\n idxP1 = get_index_lonlat(xP1, yP1, self.xcell, self.ycell)\\n else:\\n idxP0 = get_index_xy(xP0, yP0, self.xcell, self.ycell)\\n idxP1 = get_index_xy(xP1, yP1, self.xcell, self.ycell)\\n print('Cell closest to P0: {:8.5f} {:8.5f}'.format(self.xcell[idxP0], self.ycell[idxP0]))\\n print('Cell closest to P1: {:8.5f} {:8.5f}'.format(self.xcell[idxP1], self.ycell[idxP1]))\\n # find reference points\\n x_ref, y_ref = gc_interpolate(self.xcell[idxP0], self.ycell[idxP0],\\n self.xcell[idxP1], self.ycell[idxP1], npoint_ref+2)\\n if self.on_sphere:\\n x_ref = np.mod(x_ref[1:-1], 360)\\n y_ref = np.mod(y_ref[1:-1], 360)\\n # initialize an empty path\\n out = CellPath()\\n # loop over reference points, find the path between these points\\n idx_sp0 = idxP0\\n for i in np.arange(npoint_ref):\\n idx_cell = np.minimum(i,1)\\n idx_sp1 = get_index_xy(x_ref[i], y_ref[i], self.xcell, self.ycell)\\n print(' - Cell closest to RefP{:d}: {:8.5f} {:8.5f}'.format(i+1, self.xcell[idx_sp1], self.ycell[idx_sp1]))\\n out_i = get_path_cell(idx_sp0, idx_sp1,\\n self.cellid, self.xcell, self.ycell,\\n self.cells_cell, self.nedges_cell,\\n self.on_sphere, debug_info)\\n out = out + out_i\\n idx_sp0 = idx_sp1\\n # last path, start from end points P1\\n out_n = get_path_cell(idxP1, idx_sp1,\\n self.cellid, self.xcell, self.ycell,\\n self.cells_cell, self.nedges_cell,\\n self.on_sphere, debug_info)\\n out = out + out_n.reverse()\\n return out\",\n \"def process_tir_image(ds, data_res, t_thresh=-50, min_mcs_size=5000):\\n ctt = (ds['tb']).squeeze()-273.15\\n min_pix_nb = min_mcs_size / data_res**2\\n\\n max_pix_nb = 300000 / data_res**2 # this is to capture satellite artefacts that come in large contiguous stripes.\\n labels, goodinds = mcs_define(ctt.values, t_thresh, minmax_area=[min_pix_nb, max_pix_nb]) # 7.7x7.7km = 64km2 per pix in gridsat? 83 pix is 5000km2\\n dic = dictionary()\\n #plt.figure()\\n #plt.pcolormesh(labels)\\n #plt.colorbar()\\n #plt.show()\\n for g in goodinds:\\n\\n if g==0:\\n continue\\n\\n pos = np.where(labels==g)\\n npos = np.where(labels!=g)\\n datestr = str(int(ctt['time.year'].values))+'-'+str(int(ctt['time.month'].values)).zfill(2)+'-'+str(int(ctt['time.day'].values)).zfill(2)+'_'+\\\\\\n str(int(ctt['time.hour'].values)).zfill(2)+':'+str(int(ctt['time.minute'].values)).zfill(2)\\n \\n dic['date'].append(datestr)\\n dic['month'].append(int(ctt['time.month']))\\n dic['hour'].append(int(ctt['time.hour']))\\n dic['year'].append(int(ctt['time.year']))\\n dic['day'].append(int(ctt['time.day']))\\n dic['minute'].append(int(ctt['time.minute']))\\n\\n storm = ctt.copy()\\n storm.values[npos] = np.nan\\n tmin_pos = np.nanargmin(storm.values)\\n tpos_2d = np.unravel_index(tmin_pos, storm.shape)\\n \\n latmin = np.nanmin(ctt.lat.values[pos[0]])\\n latmax = np.nanmax(ctt.lat.values[pos[0]])\\n lonmin = np.nanmin(ctt.lon.values[pos[1]])\\n lonmax = np.nanmax(ctt.lon.values[pos[1]])\\n dic['area'].append(np.sum(np.isfinite(storm.values))*data_res**2)\\n dic['70area'].append(np.sum(storm.values<=-70)*data_res**2)\\n dic['minlon'].append(lonmin)\\n dic['minlat'].append(latmin)\\n dic['maxlon'].append(lonmax)\\n dic['maxlat'].append(latmax)\\n dic['clon'].append(lonmin + (lonmax - lonmin)/2)\\n dic['clat'].append(latmin + (latmax - latmin)/2)\\n dic['tmin'].append(np.nanmin(storm))\\n dic['tminlat'].append(float(ctt.lat[tpos_2d[0]].values))\\n dic['tminlon'].append(float(ctt.lon[tpos_2d[1]].values))\\n dic['tmean'].append(float(np.nanmean(storm)))\\n dic['tp1'].append(float(np.nanpercentile(storm, 1)))\\n dic['tp99'].append(float(np.nanpercentile(storm, 99)))\\n dic['stormID'].append(datestr + '_' + str(g))\\n dic['cloudMask'].append(labels==g)\\n dic['tir'].append(storm.values)\\n\\n # for k in dic.keys():\\n # print(k, len(dic[k]))\\n return dic\",\n \"def plot_harris_points(image, filtered_coords):\\n\\n plt.plot()\\n plt.imshow(image)\\n plt.plot([p[1] for p in filtered_coords],\\n [p[0] for p in filtered_coords],\\n 'b.')\\n plt.axis('off')\\n plt.show()\",\n \"def surface_contacts(struc,SASA):\\n\\tplot_single = False\\n\\n\\tcmap_cutoff = 5.0 # nm\\n\\tsasa_cutoff = 0.5\\n\\t# identify surface residues\\n\\tS = []\\n\\tN = np.array(range(struc.n_residues))\\n\\tfor r in N:\\n\\t\\tind = struc.topology.select('resid '+str(r))\\n\\t\\tSASA_per_res = np.sum(SASA[0][ind[0]:ind[-1]],axis=0)\\n\\t\\tif SASA_per_res > sasa_cutoff:\\n\\t\\t\\tS.append(SASA_per_res)\\n\\t\\telse:\\n\\t\\t\\tS.append(0.0)\\n\\t#import ipdb; ipdb.set_trace()\\n\\tsurf_res = N[np.where(np.array(S) > 0)]\\n\\tcmap = contact_maps(struc.atom_slice(struc.topology.select('name CA'))[0].xyz[0])\\n\\tfor n in N:\\n\\t\\tfor m in N:\\n\\t\\t\\tif (n not in surf_res or m not in surf_res) or n < m:\\n\\t\\t\\t\\tcmap[n][m] = 0\\n\\t\\t\\telif cmap[n][m] < cmap_cutoff:\\n\\t\\t\\t\\tcmap[n][m] = 1\\n\\tif plot_single == True:\\n\\t\\tfor it,rn in enumerate(resnames):\\n\\t\\t\\tif rn in hydrophobic:\\n\\t\\t\\t\\tplt.axhline(y=it,c='grey',linewidth=2)\\n\\t\\t\\t\\tplt.axvline(x=it,c='grey',linewidth=2)\\n\\t\\t\\telif rn in hydrophilic:\\n\\t\\t\\t\\tplt.axhline(y=it,c='g',linewidth= 2)\\n\\t\\t\\t\\tplt.axvline(x=it,c='g',linewidth= 2)\\n\\t\\t\\telif rn in poscharge:\\n\\t\\t\\t\\tplt.axhline(y=it,c='b',linewidth= 2)\\n\\t\\t\\t\\tplt.axvline(x=it,c='b',linewidth= 2)\\n\\t\\t\\telif rn in negcharge:\\n\\t\\t\\t\\tplt.axhline(y=it,c='r',linewidth= 2)\\n\\t\\t\\t\\tplt.axvline(x=it,c='r',linewidth= 2)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tprint \\\"unknown restype:\\\", rn\\n\\t\\tscat = np.array(zip(np.where(np.array(cmap) > 0)[0], np.where(np.array(cmap) > 0)[1])).T\\n\\t\\tplt.scatter(scat[0], scat[1],marker='s',c='k',s=90)\\n\\t\\t#plt.imshow(cmap,cmap='Greys')\\n\\t\\tplt.show()\\n\\treturn cmap\",\n \"def get_table_corner_points(img):\\n\\n img_height, img_width, img_channels = img.shape\\n lower_bounds,upper_bounds = get_table_color_bounds() # Get the bounds for the table felt color\\n\\n \\\"\\\"\\\"\\n Table Image Masking\\n \\\"\\\"\\\"\\n res = cv2.cvtColor(img,cv2.COLOR_BGR2HSV) # Convert image to HSV color space\\n mask = cv2.inRange(res,lower_bounds,upper_bounds) # Get image mask from bounds\\n res = cv2.bitwise_and(img,img,mask = mask) # Mask the image\\n\\n \\\"\\\"\\\"\\n Contour Detection\\n \\\"\\\"\\\"\\n imgray = cv2.cvtColor(res,cv2.COLOR_BGR2GRAY) # Get res in gray color space\\n tmp,thresh = cv2.threshold(imgray,255,255,255) # Threshold on the gray image\\n retr = cv2.RETR_EXTERNAL # Contour parameters\\n mode = cv2.CHAIN_APPROX_SIMPLE\\n tmp, contours, hierarchy = cv2.findContours(thresh,retr,mode) # Get contours\\n res = np.zeros((img_height,img_width,3),np.uint8) # Blank image for contours\\n color = (255,255,255) # Contour drawing parameters\\n thickness = 3\\n cv2.drawContours(res,contours,-1,color,thickness) # Draw contours on blank image\\n\\n \\\"\\\"\\\"\\n Canny Detection\\n \\\"\\\"\\\"\\n blur = 9 # Blur parameter \\n res = cv2.medianBlur(res,blur) # Blur\\n res = cv2.Canny(res,100,150,apertureSize = 3) # Canny edge detection\\n\\n \\\"\\\"\\\"\\n Hough Line Detection\\n \\\"\\\"\\\"\\n rho = 0.75 # Hough parameters\\n theta = np.pi/180\\n threshold = 150\\n lines = cv2.HoughLines(res,rho,theta,threshold) # Get lines\\n\\n \\\"\\\"\\\"\\n K-Mean 4 Line Clustering\\n \\\"\\\"\\\"\\n criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER,10,1.0) # K-Means parameters\\n flags = cv2.KMEANS_PP_CENTERS\\n n = 4\\n max_iterations = 10 \\n compactness,labels,centers = cv2.kmeans(np.float32(lines),n,None,criteria,max_iterations,flags) # K-Means\\n \\n \\\"\\\"\\\"\\n Get And Return Points\\n \\\"\\\"\\\"\\n growth = 100 # Offset to expand corners\\n pts = _get_table_corners_from_lines_hough_space(centers,growth,img_width,img_height) # Gets the corner points\\n ''' \\n mask = np.zeros((img_height,img_width,3),np.uint8)\\n cv2.fillPoly(mask,np.array([pts],dtype = np.int32),(255,255,255))\\n show_img(mask)\\n cv2.resize(mask,(img.shape[0],img.shape[1]),fx = 2, fy = 2, interpolation = cv2.INTER_CUBIC)\\n show_img(mask*2)\\n res = cv2.bitwise_and(img,mask)\\n '''\\n return pts\",\n \"def plt3dpaint(nppoints, color_map = 'jet', reduce_for_vis = True, voxel_size = 0.2, pointsize = 0.1, subplots = 5):\\n assert (type(nppoints) == pclpy.pcl.PointCloud.PointXYZRGB) or (type(nppoints) == pclpy.pcl.PointCloud.PointXYZ) or (type(nppoints) == np.ndarray) or (type(nppoints) is list) or (type(nppoints) is tuple), 'Not valid point_cloud'\\n cloudlist = []\\n cloudcolors = []\\n if (type(nppoints) is not list) & (type(nppoints) is not tuple):\\n nppoints = [nppoints]\\n \\n if len(nppoints) > 1:\\n for n,i in enumerate(nppoints):\\n workpoints = i\\n if (type(workpoints) == pclpy.pcl.PointCloud.PointXYZRGB) or (type(workpoints) == pclpy.pcl.PointCloud.PointXYZ):\\n workpoints = workpoints.xyz\\n\\n if reduce_for_vis:\\n workpoints = seg_tree.voxelize(workpoints,voxel_size)\\n\\n \\n cloudmin = np.min(workpoints[:,2])\\n cloudmax = np.max(workpoints[:,2])\\n \\n points = workpoints\\n color_coef = n/len(nppoints)/2 + n%2*.5\\n if type(color_map) == np.ndarray:\\n color = color_map\\n elif color_map == 'jet':\\n color=cm.jet(color_coef)[:3]\\n else:\\n color=cm.Set1(color_coef)[:3]\\n cloudcolors.append(np.ones_like(workpoints)*color + 0.4*(np.ones_like(workpoints) * ((workpoints[:,2] - cloudmin)/(cloudmax - cloudmin)).reshape(-1,1)-0.5) )\\n cloudlist.append(points)\\n else:\\n workpoints = nppoints[0]\\n if (type(workpoints) == pclpy.pcl.PointCloud.PointXYZRGB) or (type(workpoints) == pclpy.pcl.PointCloud.PointXYZ):\\n workpoints = workpoints.xyz\\n\\n if reduce_for_vis:\\n workpoints = seg_tree.voxelize(workpoints,voxel_size)\\n cloudcolors.append(workpoints[:,2])\\n cloudlist.append(workpoints)\\n\\n plt_pointcloud = np.concatenate(cloudlist)\\n plt_colors = np.concatenate(cloudcolors)\\n if len(nppoints) > 1:\\n plt_colors = np.minimum(plt_colors,np.ones_like(plt_colors))\\n plt_colors = np.maximum(plt_colors,np.zeros_like(plt_colors))\\n fig = plt.figure(figsize=(30,16) )\\n for i in range(subplots):\\n ax = fig.add_subplot(1, subplots, i+1, projection='3d')\\n ax.view_init(30, 360*i/subplots)\\n ax.scatter3D(plt_pointcloud[:,0], plt_pointcloud[:,1], plt_pointcloud[:,2], c=plt_colors, s=pointsize)\",\n \"def TetrahedralProjection(c1=(0,0,0), c2=(2,0,0), c3=(0,2,0), c4=(0,0,2), points=None, npoints=10, equally_spaced=True):\\n\\n if points is None or not isinstance(points,np.ndarray):\\n if not isinstance(c1,tuple) or not isinstance(c2,tuple) or not isinstance(c3,tuple) \\\\\\n or not isinstance(c4,tuple):\\n raise ValueError(\\\"coordinates should be given in tuples of two elements (x,y)\\\")\\n else:\\n c1 = np.array(c1); c2 = np.array(c2); c3 = np.array(c3); c4 = np.array(c4)\\n opoints = np.vstack((c1,c2,c3,c4))\\n else:\\n opoints = points\\n\\n from scipy.spatial import Delaunay\\n from Florence.FunctionSpace import Tet\\n from Florence.QuadratureRules.EquallySpacedPoints import EquallySpacedPointsTet\\n from Florence.QuadratureRules.FeketePointsTet import FeketePointsTet\\n\\n if equally_spaced:\\n points = EquallySpacedPointsTet(npoints)\\n else:\\n points = FeketePointsTet(npoints)\\n\\n BasesTet = np.zeros((4,points.shape[0]),dtype=np.float64)\\n hpBases = Tet.hpNodal.hpBases\\n for i in range(points.shape[0]):\\n BasesTet[:,i] = hpBases(0,points[i,0],points[i,1],points[i,2],\\n Transform=1,EvalOpt=1,equally_spaced=equally_spaced)[0]\\n makezero(BasesTet,tol=1e-10)\\n\\n # func = Delaunay(points,qhull_options=\\\"QJ\\\") # this does not produce the expected connectivity\\n func = Delaunay(points)\\n tets = func.simplices\\n\\n mesh = Mesh()\\n mesh.element_type=\\\"tet\\\"\\n mesh.points = np.dot(BasesTet.T, opoints)\\n mesh.elements = tets\\n mesh.nelem = mesh.elements.shape[0]\\n mesh.nnode = mesh.points.shape[0]\\n mesh.GetBoundaryFaces()\\n mesh.GetBoundaryEdges()\\n\\n return mesh\",\n \"def get_segmented_point_clouds(seg_masks, depth): \\n obj_labels = np.unique(seg_masks)\\n num_objs = obj_labels.shape[0]+1\\n rows, cols = seg_masks.shape\\n cm = plt.get_cmap('gist_rainbow')\\n colors = [cm(1. * i/num_objs) for i in range(num_objs)]\\n \\n object_dict = {}\\n # key - object label; val - depth array of that object\\n for i in obj_labels:\\n object_dict[i] = np.zeros((rows,cols), dtype = np.float32)\\n\\n for i in range(rows):\\n for j in range(cols):\\n if seg_masks[i][j] != 0 and seg_masks[i][j] != -1:\\n object_dict[seg_masks[i][j]][i][j] = depth[i][j]\\n \\n segmented_pcds = []\\n for key, val in object_dict.items():\\n if key == -1 or key == 0:\\n continue\\n img = o3d.geometry.Image(val)\\n pcd_from_depth = o3d.geometry.PointCloud.create_from_depth_image(\\n img,\\n o3d.camera.PinholeCameraIntrinsic(\\n o3d.camera.PinholeCameraIntrinsicParameters.PrimeSenseDefault))\\n\\n # Multiply with Transformation matrix to get correct view of the PCD\\n pcd_from_depth.transform([[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0], [0, 0, 0, 1]])\\n pcd_from_depth.paint_uniform_color(np.array(colors[key][:3], dtype = np.uint8) * 255)\\n segmented_pcds.append(pcd_from_depth)\\n return segmented_pcds\",\n \"def footprint_corner_indices():\",\n \"def downloadSurroundingStreetView(point, directory, picNum, ptrNum, intersectionPointInfo):\\n result = []\\n for heading in CONFIG[\\\"gmap\\\"][\\\"headings\\\"]:\\n filename = \\\"%s/%010d_%s_%s_%s.jpg\\\" % (directory, picNum, str(point[1]), str(point[0]), heading[0])\\n paramDict = GoogleStreetView.makeParameterDict(point[1], point[0], heading[1])\\n metadata = GoogleStreetView.getMetadata(paramDict)\\n\\n result.append([picNum,\\n ptrNum,\\n str(point[1]) + \\\",\\\" + str(point[0]),\\n heading[0],\\n metadata[\\\"date\\\"],\\n filename.split(\\\"/\\\")[-1],\\n \\\",\\\".join(intersectionPointInfo[(point[0], point[1])])]\\n )\\n\\n param = GoogleStreetView.makeParameter(point[1], point[0], heading[1])\\n GoogleStreetView.downloadStreetView(param, filename)\\n picNum += 1\\n return result\",\n \"def ccs4_map(cfg_set_tds,figsize_x=12,figsize_y=12,hillshade=True,radar_loc=True,radar_vis=True):\\r\\n \\r\\n ## Load DEM and Swiss borders\\r\\n shp_path_CH = os.path.join(cfg_set_tds[\\\"root_path\\\"],u\\\"data/shapefile/swissBOUNDARIES3D_1_3_TLM_LANDESGEBIET.shp\\\")\\r\\n shp_path_Kantone = os.path.join(cfg_set_tds[\\\"root_path\\\"],u\\\"data/shapefile/swissBOUNDARIES3D_1_3_TLM_KANTONSGEBIET.shp\\\")\\r\\n shp_path_count = os.path.join(cfg_set_tds[\\\"root_path\\\"],u\\\"data/shapefile/CCS4_merged_proj_clip_G05_countries.shp\\\")\\r\\n dem_path = os.path.join(cfg_set_tds[\\\"root_path\\\"],u\\\"data/DEM/ccs4.png\\\")\\r\\n visi_path = os.path.join(cfg_set_tds[\\\"root_path\\\"],u\\\"data/radar/radar_composite_visibility.npy\\\")\\r\\n\\r\\n dem = Image.open(dem_path)\\r\\n dem = np.array(dem.convert('P'))\\r\\n\\r\\n sf_CH = shapefile.Reader(shp_path_CH)\\r\\n sf_KT = shapefile.Reader(shp_path_Kantone)\\r\\n sf_ct = shapefile.Reader(shp_path_count)\\r\\n\\r\\n ## Setup figure\\r\\n fig_extent = (255000,965000,-160000,480000)\\r\\n fig, axes = plt.subplots(1, 1)\\r\\n fig.set_size_inches(figsize_x, figsize_y)\\r\\n \\r\\n ## Plot altitude / hillshading\\r\\n if hillshade:\\r\\n ls = colors.LightSource(azdeg=315, altdeg=45)\\r\\n axes.imshow(ls.hillshade(-dem, vert_exag=0.05),\\r\\n extent=fig_extent, cmap='gray', alpha=0.5)\\r\\n else:\\r\\n axes.imshow(dem*0.6, extent=fig_extent, cmap='gray', alpha=0.5)\\r\\n \\r\\n ## Get borders of Cantons\\r\\n try:\\r\\n shapes_KT = sf_KT.shapes()\\r\\n except UnicodeDecodeError:\\r\\n print(\\\" *** Warning: No country shape plotted (UnicodeDecodeErrror)\\\")\\r\\n else:\\r\\n for KT_i, shape in enumerate(shapes_KT):\\r\\n x = np.array([i[0] for i in shape.points[:]])\\r\\n y = np.array([i[1] for i in shape.points[:]])\\r\\n endpoint = np.where(x==x[0])[0][1]\\r\\n x = x[:endpoint]\\r\\n y = y[:endpoint]\\r\\n axes.plot(x,y,color='darkred',linewidth=0.5,zorder=5)\\r\\n\\r\\n ## Get borders of neighbouring countries\\r\\n try:\\r\\n shapes_ct = sf_ct.shapes()\\r\\n except UnicodeDecodeError:\\r\\n print(\\\" *** Warning: No country shape plotted (UnicodeDecodeErrror)\\\")\\r\\n else:\\r\\n for ct_i, shape in enumerate(shapes_ct):\\r\\n if ct_i in [0,1]:\\r\\n continue\\r\\n x = np.array([i[0] for i in shape.points[:]])\\r\\n y = np.array([i[1] for i in shape.points[:]])\\r\\n x[x<=255000] = 245000\\r\\n x[x>=965000] = 975000\\r\\n y[y<=-159000] = -170000\\r\\n y[y>=480000] = 490000\\r\\n if ct_i in [3]:\\r\\n axes.plot(x[20:170],y[20:170],color='black',linewidth=0.5)\\r\\n if ct_i in [2]:\\r\\n ## Delete common border of FR and CH:\\r\\n x_south = x[y<=86000]; y_south = y[y<=86000]\\r\\n x_north = x[np.logical_and(np.logical_and(y>=270577,y<=491000),x>510444)]\\r\\n #x_north = x[np.logical_and(y>=270577,y<=491000)]\\r\\n y_north = y[np.logical_and(np.logical_and(y>=270577,y<=491000),x>510444)]\\r\\n #y_north = y[np.logical_and(y>=270577,y<=491000)]\\r\\n axes.plot(x_south,y_south,color='black',linewidth=0.5,zorder=4)\\r\\n axes.plot(x_north,y_north,color='black',linewidth=0.5,zorder=4)\\r\\n if ct_i in [4]:\\r\\n ## Delete common border of AT and CH:\\r\\n x_south = x[np.logical_and(x>=831155,y<235000)]\\r\\n y_south = y[np.logical_and(x>=831155,y<235000)]\\r\\n #x_north1 = x[np.logical_and(x>=756622,y>=260466)]\\r\\n x_north1 = x[np.logical_and(np.logical_and(x>=758622,y>=262466),x<=794261)]\\r\\n #y_north1 = y[np.logical_and(x>=756622,y>=260466)]\\r\\n y_north1 = y[np.logical_and(np.logical_and(x>=758622,y>=262466),x<=794261)]\\r\\n y_north2 = y[np.logical_and(np.logical_and(x>=774261,y>=229333),x<=967000)]\\r\\n x_north2 = x[np.logical_and(np.logical_and(x>=774261,y>=229333),x<=967000)]\\r\\n y_north2 = np.concatenate([y_north2[np.argmin(x_north2):],y_north2[:np.argmin(x_north2)]])\\r\\n x_north2 = np.concatenate([x_north2[np.argmin(x_north2):],x_north2[:np.argmin(x_north2)]])\\r\\n x_LI = x[np.logical_and(np.logical_and(x<=773555,y>=214400),y<=238555)]\\r\\n y_LI = y[np.logical_and(np.logical_and(x<=773555,y>=214400),y<=238555)]\\r\\n axes.plot(x_south,y_south,color='black',linewidth=0.5,zorder=4)\\r\\n axes.plot(x_north1,y_north1,color='black',linewidth=0.5,zorder=4)\\r\\n axes.plot(x_north2,y_north2,color='black',linewidth=0.5,zorder=4)\\r\\n axes.plot(x_LI,y_LI,color='black',linewidth=0.5,zorder=4)\\r\\n else:\\r\\n continue\\r\\n #axes.plot(x,y,color='black',linewidth=1,zorder=4)\\r\\n\\r\\n ## Get Swiss borders\\r\\n try:\\r\\n #shp_records = sf_CH.shapeRecords()\\r\\n shapes_CH = sf_CH.shapes()\\r\\n except UnicodeDecodeError:\\r\\n print(\\\" *** Warning: No country shape plotted (UnicodeDecodeErrror)\\\")\\r\\n else:\\r\\n for ct_i, shape in enumerate(shapes_CH): #sf_CH.shapeRecords():\\r\\n if ct_i!=0: continue\\r\\n x = np.array([i[0]-2000000 for i in shape.points[:]])\\r\\n y = np.array([i[1]-1000000 for i in shape.points[:]])\\r\\n endpoint = np.where(x==x[0])[0][1]\\r\\n x = x[:endpoint]\\r\\n y = y[:endpoint]\\r\\n \\r\\n ## Convert to swiss coordinates\\r\\n #x,y = lonlat2xy(lon, lat)\\r\\n axes.plot(x,y,color='darkred',linewidth=1,zorder=3)\\r\\n\\r\\n ## Add weather radar locations:\\r\\n if radar_loc:\\r\\n weather_radar_y = [237000,142000,100000,135000,190000]\\r\\n weather_radar_x = [681000,497000,708000,604000,780000]\\r\\n axes.scatter(weather_radar_x,weather_radar_y,marker=\\\"D\\\",#s=2,\\r\\n color='orange',edgecolor='black',zorder=10)\\r\\n \\r\\n ## Add radar visibility:\\r\\n if radar_vis:\\r\\n arr_visi = np.load(visi_path)\\r\\n arr_visi[arr_visi<9000] = 0\\r\\n arr_visi2 = morph.binary_opening(morph.binary_erosion(arr_visi, structure=np.ones((4,4))), structure=np.ones((4,4)))\\r\\n arr_visi[arr_visi<9000] = np.nan\\r\\n axes.imshow(arr_visi, cmap=\\\"gray\\\", alpha=0.2, extent=fig_extent)\\r\\n arr_visi[np.isnan(arr_visi)] = 1\\r\\n #axes.contour(arr_visi[::-1,:], levels=[2], cmap=\\\"gray\\\", linewidths=2,\\r\\n # linestyle=\\\"solid\\\", alpha=0.5, extent=fig_extent)\\r\\n #arr_visi = arr_visi[::4, ::4]\\r\\n #ys, xs = np.mgrid[arr_visi.shape[0]:0:-1,\\r\\n # 0:arr_visi.shape[1]]\\r\\n #axes.scatter(xs.flatten(), ys.flatten(), s=4,\\r\\n # c=arr_visi.flatten().reshape(-1, 3), edgecolor='face')\\r\\n \\r\\n ## Add further elements:\\r\\n axes.set_xlim([255000,965000])\\r\\n axes.set_ylim([-160000,480000])\\r\\n axes.grid()\\r\\n axes.set_ylabel(\\\"CH1903 Northing\\\")\\r\\n axes.set_xlabel(\\\"CH1903 Easting\\\")\\r\\n axes.get_xaxis().set_major_formatter( \\\\\\r\\n ticker.FuncFormatter(lambda x, p: format(int(x), \\\",\\\").replace(',', \\\"'\\\")))\\r\\n axes.get_yaxis().set_major_formatter( \\\\\\r\\n ticker.FuncFormatter(lambda x, p: format(int(x), \\\",\\\").replace(',', \\\"'\\\")))\\r\\n plt.yticks(rotation=90, verticalalignment=\\\"center\\\")\\r\\n return fig, axes, fig_extent\",\n \"def create_grid_and_edges(data, drone_altitude, safety_distance):\\n # minimum and maximum north coordinates\\n north_min = np.floor(np.min(data[:, 0] - data[:, 3]))\\n north_max = np.ceil(np.max(data[:, 0] + data[:, 3]))\\n\\n # minimum and maximum east coordinates\\n east_min = np.floor(np.min(data[:, 1] - data[:, 4]))\\n east_max = np.ceil(np.max(data[:, 1] + data[:, 4]))\\n\\n # given the minimum and maximum coordinates we can\\n # calculate the size of the grid.\\n north_size = int(np.ceil(north_max - north_min))\\n east_size = int(np.ceil(east_max - east_min))\\n\\n # Initialize an empty grid\\n grid = np.zeros((north_size, east_size))\\n # Initialize an empty list for Voronoi points\\n points = []\\n # Populate the grid with obstacles\\n for i in range(data.shape[0]):\\n north, east, alt, d_north, d_east, d_alt = data[i, :]\\n if alt + d_alt + safety_distance > drone_altitude:\\n obstacle = [\\n int(np.clip(north - d_north - safety_distance - north_min, 0, north_size-1)),\\n int(np.clip(north + d_north + safety_distance - north_min, 0, north_size-1)),\\n int(np.clip(east - d_east - safety_distance - east_min, 0, east_size-1)),\\n int(np.clip(east + d_east + safety_distance - east_min, 0, east_size-1)),\\n ]\\n grid[obstacle[0]:obstacle[1]+1, obstacle[2]:obstacle[3]+1] = 1\\n # add center of obstacles to points list\\n points.append([north - north_min, east - east_min])\\n\\n graph = Voronoi(points)\\n\\n edges = []\\n for v in graph.ridge_vertices:\\n p1 = graph.vertices[v[0]]\\n p2 = graph.vertices[v[1]]\\n cells = list(bresenham(int(p1[0]), int(p1[1]), int(p2[0]), int(p2[1])))\\n hit = False\\n\\n for c in cells:\\n if np.amin(c) < 0 or c[0] >= grid.shape[0] or c[1] >= grid.shape[1]:\\n hit = True\\n break\\n if grid[c[0], c[1]] == 1:\\n hit = True\\n break\\n\\n if not hit:\\n p1 = (p1[0], p1[1])\\n p2 = (p2[0], p2[1])\\n edges.append((p1, p2))\\n\\n return grid, edges, int(north_min), int(east_min)\",\n \"def compute_mesh(nrow, ncol, nele):\\n tri_index = np.zeros((nele, 3))\\n for i in range(nrow-1):\\n for j in range(NUM):\\n if j == 0:\\n tri_index[i*4*NUM+j*4, 0] = (i+1)+(2*j+1)*nrow\\n tri_index[i*4*NUM+j*4, 1] = (i+1)\\n tri_index[i*4*NUM+j*4, 2] = (i+2)\\n\\n tri_index[i*4*NUM+j*4+1, 0] = (i+1)+(2*j+1)*nrow\\n tri_index[i*4*NUM+j*4+1, 1] = (i+2)\\n tri_index[i*4*NUM+j*4+1, 2] = (i+2)+(2*j+1)*nrow\\n else:\\n tri_index[i*4*NUM+j*4, 0] = (i+1)+(2*j+1)*nrow\\n tri_index[i*4*NUM+j*4, 1] = (i+1)+(2*j-1)*nrow\\n tri_index[i*4*NUM+j*4, 2] = (i+2)+(2*j-1)*nrow\\n\\n tri_index[i*4*NUM+j*4+1, 0] = (i+1)+(2*j+1)*nrow\\n tri_index[i*4*NUM+j*4+1, 1] = (i+2)+(2*j-1)*nrow\\n tri_index[i*4*NUM+j*4+1, 2] = (i+2)+(2*j+1)*nrow\\n \\n tri_index[i*4*NUM+j*4+2, 0] = (i+1)+2*j*nrow\\n tri_index[i*4*NUM+j*4+2, 1] = (i+1)+2*(j+1)*nrow\\n tri_index[i*4*NUM+j*4+2, 2] = (i+2)+2*(j+1)*nrow\\n\\n tri_index[i*4*NUM+j*4+3, 0] = (i+1)+2*j*nrow\\n tri_index[i*4*NUM+j*4+3, 1] = (i+2)+2*(j+1)*nrow\\n tri_index[i*4*NUM+j*4+3, 2] = (i+2)+2*j*nrow\\n return tri_index\",\n \"def drawShadedContours(xlist, ylist, zmatrix, levels):\\n dislin.conshd(xlist, len(xlist), ylist, len(ylist), zmatrix, levels, len(levels))\",\n \"def plot_vor(self,x,ax,tri=False):\\n\\n L = self.L\\n grid_x, grid_y = np.mgrid[-1:2, -1:2]\\n grid_x[0, 0], grid_x[1, 1] = grid_x[1, 1], grid_x[0, 0]\\n grid_y[0, 0], grid_y[1, 1] = grid_y[1, 1], grid_y[0, 0]\\n y = np.vstack([x + np.array([i * L, j * L]) for i, j in np.array([grid_x.ravel(), grid_y.ravel()]).T])\\n\\n c_types_print = np.tile(self.c_types,9)\\n bleed = 0.1\\n c_types_print = c_types_print[(y<L*(1+bleed)).all(axis=1)+(y>-L*bleed).all(axis=1)]\\n y = y[(y<L*(1+bleed)).all(axis=1)+(y>-L*bleed).all(axis=1)]\\n regions, vertices = self.voronoi_finite_polygons_2d(Voronoi(y))\\n\\n\\n ax.set(aspect=1,xlim=(0,self.L),ylim=(0,self.L))\\n if type(self.c_types) is list:\\n # ax.scatter(x[:, 0], x[:, 1],color=\\\"grey\\\",zorder=1000)\\n for region in regions:\\n polygon = vertices[region]\\n plt.fill(*zip(*polygon), alpha=0.4, color=\\\"grey\\\")\\n\\n else:\\n cols = self.cols\\n if self.plot_scatter is True:\\n for j,i in enumerate(np.unique(self.c_types)):\\n ax.scatter(x[self.c_types==i, 0], x[self.c_types==i, 1],color=cols[i],zorder=1000)\\n patches = []\\n for i, region in enumerate(regions):\\n patches.append(Polygon(vertices[region], True,facecolor=cols[c_types_print[i]],ec=(1,1,1,1)))\\n\\n p = PatchCollection(patches, match_original=True)\\n # p.set_array(c_types_print)\\n ax.add_collection(p)\\n if tri is not False:\\n for TRI in tri:\\n for j in range(3):\\n a, b = TRI[j], TRI[np.mod(j + 1, 3)]\\n if (a >= 0) and (b >= 0):\\n X = np.stack((x[a], x[b])).T\\n ax.plot(X[0], X[1], color=\\\"black\\\")\",\n \"def _plot_sr_surface(self, varname):\\n\\n fig = plt.figure()\\n varname = self.layer_lookup[varname]\\n data = self.node_data[varname]\\n x_node_loc = np.arange(self.mins[0], self.maxs[0], self.min_grid_size) + self.min_grid_size/2\\n y_node_loc = np.arange(self.mins[1], self.maxs[1], self.min_grid_size) + self.min_grid_size/2\\n lon2d, lat2d = np.meshgrid(x_node_loc, y_node_loc)\\n\\n # mask NaN values\\n data_m = np.ma.array(data, mask=np.isnan(data))\\n plt.pcolormesh(lon2d, lat2d, data_m.T, vmin=data_m.min(), vmax=data_m.max())\",\n \"def make_hexgrid_for_tract(tract_info, spacing_pixels=64, rng=None):\\n if not isinstance(rng, np.random.RandomState):\\n rng = np.random.RandomState(seed=rng)\\n\\n # compute the dimensions of the tract\\n dimx = tract_info.getBBox().getDimensions().x\\n dimy = tract_info.getBBox().getDimensions().y\\n nx = int(dimx / spacing_pixels * np.sqrt(2) * 1.05)\\n # the factor of 0.866 makes sure the grid is square-ish\\n ny = int(dimy / spacing_pixels * np.sqrt(2) * 1.05 / 0.8660254)\\n\\n # make a base grid\\n # here the spacing between grid centers is 1\\n v, _ = create_hex_grid(nx=nx, ny=ny, rotate_deg=rng.uniform() * 365)\\n\\n # convert the spacing to right number of pixels\\n # we also recenter the grid since it comes out centered at 0,0\\n v *= spacing_pixels\\n v[:, 0] += (dimx / 2)\\n v[:, 1] += (dimy / 2)\\n\\n # now cut to things in the tract\\n # this is done with\\n # 1. an initial cut of the pixel location\\n # 2. transforming to ra,dec and using the sky polygon\\n # cut 1\\n msk = (\\n (v[:, 0] >= 0)\\n & (v[:, 0] < dimx)\\n & (v[:, 1] >= 0)\\n & (v[:, 1] < dimy)\\n )\\n v = v[msk, :]\\n\\n # cut 2\\n wcs = tract_info.getWcs()\\n ra, dec = wcs.pixelToSkyArray(v[:, 0], v[:, 1], degrees=True)\\n cvx = tract_info.getOuterSkyPolygon()\\n msk = np.array([\\n cvx.contains(geom.SpherePoint(ra[i], dec[i], geom.degrees).getVector())\\n for i in range(len(ra))\\n ])\\n ra = ra[msk]\\n dec = dec[msk]\\n v = v[msk, :]\\n\\n grid_data = np.zeros(v.shape[0], dtype=[\\n (\\\"ra\\\", \\\"f8\\\"),\\n (\\\"dec\\\", \\\"f8\\\"),\\n (\\\"x\\\", \\\"f8\\\"),\\n (\\\"y\\\", \\\"f8\\\")\\n ])\\n grid_data[\\\"ra\\\"] = ra\\n grid_data[\\\"dec\\\"] = dec\\n grid_data[\\\"x\\\"] = v[:, 0]\\n grid_data[\\\"y\\\"] = v[:, 1]\\n\\n return grid_data\",\n \"def tsne_points(feature_matrix: np.array, perplexity: int) -> list:\\n number_of_t_sne_components = 2\\n number_of_t_sne_iterations = 1000\\n t_sne_metric = \\\"manhattan\\\"\\n\\n tsne = TSNE(\\n n_components=number_of_t_sne_components,\\n perplexity=perplexity,\\n n_iter=number_of_t_sne_iterations,\\n metric=t_sne_metric,\\n )\\n results = tsne.fit_transform(feature_matrix)\\n\\n # This is where my hacky plotting script makes us do unseemly things.\\n tsne_1 = results[:, 0]\\n tsne_2 = results[:, 1]\\n plottable_list_form = []\\n for idx in range(len(tsne_1)):\\n plottable_list_form.append((tsne_1[idx], tsne_2[idx]))\\n\\n return plottable_list_form\",\n \"def get_element_for_location(self, points):\\n verts = np.zeros((points.shape[0], 4, 3))\\n bc = np.zeros((points.shape[0], 4))\\n tetras = np.zeros(points.shape[0], dtype=\\\"int64\\\")\\n inside = np.zeros(points.shape[0], dtype=bool)\\n npts = 0\\n npts_step = int(1e4)\\n # break into blocks of 10k points\\n while npts < points.shape[0]:\\n\\n cell_index = np.array(\\n self.aabb_grid.position_to_cell_index(points[: npts + npts_step, :])\\n )\\n inside = self.aabb_grid.inside(points[: npts + npts_step, :])\\n global_index = (\\n cell_index[:, 0]\\n + self.aabb_grid.nsteps_cells[None, 0] * cell_index[:, 1]\\n + self.aabb_grid.nsteps_cells[None, 0]\\n * self.aabb_grid.nsteps_cells[None, 1]\\n * cell_index[:, 2]\\n )\\n\\n tetra_indices = self.aabb_table[global_index[inside], :].tocoo()\\n # tetra_indices[:] = -1\\n row = tetra_indices.row\\n col = tetra_indices.col\\n # using returned indexes calculate barycentric coords to determine which tetra the points are in\\n vertices = self.nodes[self.elements[col, :4]]\\n pos = points[row, :]\\n vap = pos[:, :] - vertices[:, 0, :]\\n vbp = pos[:, :] - vertices[:, 1, :]\\n # # vcp = p - points[:, 2, :]\\n # # vdp = p - points[:, 3, :]\\n vab = vertices[:, 1, :] - vertices[:, 0, :]\\n vac = vertices[:, 2, :] - vertices[:, 0, :]\\n vad = vertices[:, 3, :] - vertices[:, 0, :]\\n vbc = vertices[:, 2, :] - vertices[:, 1, :]\\n vbd = vertices[:, 3, :] - vertices[:, 1, :]\\n\\n va = np.einsum(\\\"ij, ij->i\\\", vbp, np.cross(vbd, vbc, axisa=1, axisb=1)) / 6.0\\n vb = np.einsum(\\\"ij, ij->i\\\", vap, np.cross(vac, vad, axisa=1, axisb=1)) / 6.0\\n vc = np.einsum(\\\"ij, ij->i\\\", vap, np.cross(vad, vab, axisa=1, axisb=1)) / 6.0\\n vd = np.einsum(\\\"ij, ij->i\\\", vap, np.cross(vab, vac, axisa=1, axisb=1)) / 6.0\\n v = np.einsum(\\\"ij, ij->i\\\", vab, np.cross(vac, vad, axisa=1, axisb=1)) / 6.0\\n c = np.zeros((va.shape[0], 4))\\n c[:, 0] = va / v\\n c[:, 1] = vb / v\\n c[:, 2] = vc / v\\n c[:, 3] = vd / v\\n # inside = np.ones(c.shape[0],dtype=bool)\\n mask = np.all(c >= 0, axis=1)\\n\\n verts[: npts + npts_step, :, :][row[mask], :, :] = vertices[mask, :, :]\\n bc[: npts + npts_step, :][row[mask], :] = c[mask, :]\\n tetras[: npts + npts_step][row[mask]] = col[mask]\\n inside[: npts + npts_step][row[mask]] = True\\n npts += npts_step\\n return verts, bc, tetras, inside\",\n \"def plot(sigma, strikes, dips):\\n values, vectors = principal(sigma)\\n sigma1, sigma2, sigma3 = vectors\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection='stereonet')\\n plt.hold(True)\\n ax.density_contourf(strikes, dips)\\n #ax.pole(strikes, dips, 'b.')\\n ax.line(sigma1[0],sigma1[1], 'r^', label='sigma1', markersize=18)\\n ax.line(sigma2[0],sigma2[1], 'g^', label='sigma2', markersize=18)\\n ax.line(sigma3[0],sigma3[1], 'b^', label='sigma3', markersize=18)\",\n \"def plot_harris_points(image, filtered_coords):\\n plt.figure()\\n plt.imshow(image)\\n plt.plot([p[1] for p in filtered_coords], [p[0] for p in filtered_coords], 'r*')\\n plt.axis('off')\\n plt.title('harris points')\\n plt.show()\",\n \"def plotTsneE_3D(datadf,level,descname,v,path_output,Efilter,own_cmap,clustermethod=\\\"kmeans\\\",onlyShow=False,selected=False):\\n\\n if not selected:\\n datadf = datadf[datadf[\\\"{}Energy\\\".format(level)]<=Efilter].sort_values(by=\\\"{}_{}_klabel\\\".format(level,descname))\\n\\n klabels = datadf[\\\"{}_{}_klabel\\\".format(level,descname)].astype(str)\\n fig = px.scatter_3d(data_frame=datadf,\\n z=\\\"{}Energy\\\".format(level),\\n x=\\\"{}_{}_tsne1\\\".format(level,descname),\\n y=\\\"{}_{}_tsne2\\\".format(level,descname),\\n color=klabels,\\n color_discrete_sequence=own_cmap,\\n size=\\\"GyRadius\\\",\\n opacity=0.9,\\n #symbol=\\\"symbol\\\", # Use if needed in Jupyter\\n hover_name=datadf.index,\\n title=\\\"{}'s' t-SNE + {}Energy\\\".format(descname,level),\\n #range_z=[-36,-20],\\n width= 1200,\\n height= 900)\\n\\n\\n if onlyShow:\\n fig.show()\\n elif selected:\\n fig.write_html(\\\"{}/{}_{}_EtSNE_selected.html\\\".format(path_output,level,descname))\\n else:\\n fig.write_html(\\\"{}/{}_{}_EtSNE.html\\\".format(path_output,level,descname))\",\n \"def detect(image):\\n markers = []\\n # Stage 1: Detect edges in image\\n gray = cvtColor(image, COLOR_BGR2GRAY)\\n clahe = createCLAHE(clipLimit=1, tileGridSize=(6, 6))\\n cl1 = clahe.apply(gray)\\n _, thresh = threshold(cl1, 60, 255, THRESH_OTSU)\\n blurred = GaussianBlur(thresh, (5, 5), 0)\\n edges = Canny(blurred, 75, 100)\\n\\n # Stage 2: Find contours\\n contours = findContours(edges, RETR_TREE, CHAIN_APPROX_SIMPLE)\\n contours = sorted(contours, key=contourArea, reverse=True)[:]\\n\\n for contour in contours:\\n # Stage 3: Shape check\\n perimeter = arcLength(contour, True)\\n approx = approxPolyDP(contour, 0.01*perimeter, True)\\n\\n if len(approx) == QUADRILATERAL_POINTS:\\n area = contourArea(approx)\\n # (x, y, w, h) = boundingRect(approx)\\n # ar = float(h) / float(w)\\n # if area > 100 and ar >= 0.8 and ar <= 1.2:\\n if area > 700:\\n # putText(image, str(area), (10, 30), FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)\\n drawContours(image, [contour], -1, (0, 255, 0), 1)\\n\\n # Stage 4: Perspective warping\\n topdown_quad = get_topdown_quad(thresh, approx.reshape(4, 2))\\n\\n # Stage 5: Border check\\n if topdown_quad[int((topdown_quad.shape[0]/100.0)*5), int((topdown_quad.shape[1]/100.0)*5)] > BLACK_THRESHOLD:\\n continue\\n\\n # Stage 6: Get marker pattern\\n marker_pattern = None\\n\\n try:\\n marker_pattern = get_marker_pattern(topdown_quad, THRESHOLD_PERCENT)\\n except:\\n continue\\n\\n if not marker_pattern:\\n continue\\n\\n # Stage 7: Match marker pattern\\n marker_found, marker_rotation, marker_name = match_marker_pattern(marker_pattern)\\n\\n if marker_found:\\n markers.append([marker_name, marker_rotation])\\n\\n return markers, image\",\n \"def segmentRender(all_data_endo, all_data_epi, apex_pt, basal_pt, septal_pts, origin, transform, landmarks=True, ax=None, scar=None):\\n\\tif not ax:\\n\\t\\tfig = mplt.figure()\\n\\t\\tax = fig.add_subplot(111, projection='3d')\\n\\tdata_endo, data_epi, _, _, _ = meshhelper.prepData(all_data_endo, all_data_epi, apex_pt, basal_pt, septal_pts)\\n\\t# Subtract origin and transform data\\n\\tapex_transform = np.dot((apex_pt - origin), np.transpose(transform))\\n\\tbasal_transform = np.dot((basal_pt - origin), np.transpose(transform))\\n\\tseptal_transform1 = np.dot((septal_pts[0, :] - origin), np.transpose(transform))\\n\\tseptal_transform2 = np.dot((septal_pts[1, :] - origin), np.transpose(transform))\\n\\tseptal_transform3 = np.dot((septal_pts[2, :] - origin), np.transpose(transform))\\n\\t# Set up bins as the unique data in all_data_endo third column (the slices)\\n\\tbins = np.unique(all_data_endo[:, 2])\\n\\tfor jz in range(bins.size):\\n\\t\\t# Get the indices that match the current bin and append then append the first value\\n\\t\\ttracing = np.where(all_data_endo[:, 2] == bins[jz])[0]\\n\\t\\ttracing = np.append(tracing, tracing[0])\\n\\t\\t# Pull x, y, z from endo and epi and plot\\n\\t\\tx = data_endo[tracing, 2]\\n\\t\\ty = data_endo[tracing, 1]\\n\\t\\tz = data_endo[tracing, 0]\\n\\t\\tax.plot(x, y, -z, 'y-')\\n\\t\\t# Epi plotting\\n\\t\\tx = data_epi[tracing, 2]\\n\\t\\ty = data_epi[tracing, 1]\\n\\t\\tz = data_epi[tracing, 0]\\n\\t\\tax.plot(x, y, -z, 'c-')\\n\\tif landmarks:\\n\\t\\t# Plot the apex, basal, and septal points\\n\\t\\tab = np.array([apex_transform, basal_transform])\\n\\t\\tsi = np.array([septal_transform2, septal_transform3])\\n\\t\\t\\n\\t\\tax.plot(ab[:, 2], ab[:, 1], -ab[:, 0], 'k-.')\\n\\t\\tax.scatter(si[:, 2], si[:, 1], -si[:, 0], 'bo', s=50)\\n\\t\\tax.scatter(septal_transform1[2], septal_transform1[1], -septal_transform1[0], 'ro', s=50)\\n\\t\\n\\treturn(ax)\",\n \"def ShowOneContour(index,all_images,all_pointing,thex0,they0,all_titles,object_name,all_expo,dir_top_img,all_filt,figname):\\n plt.figure(figsize=(15,6))\\n spec_index_min=100 # cut the left border\\n spec_index_max=1900 # cut the right border\\n star_halfwidth=70\\n \\n YMIN=-15\\n YMAX=15\\n \\n figfilename=os.path.join(dir_top_img,figname) \\n \\n #center is approximately the one on the original raw image (may be changed)\\n #x0=int(all_pointing[index][0])\\n x0=int(thex0[index])\\n \\n \\n # Extract the image \\n full_image=np.copy(all_images[index])\\n \\n # refine center in X,Y\\n star_region_X=full_image[:,x0-star_halfwidth:x0+star_halfwidth]\\n \\n profile_X=np.sum(star_region_X,axis=0)\\n profile_Y=np.sum(star_region_X,axis=1)\\n\\n NX=profile_X.shape[0]\\n NY=profile_Y.shape[0]\\n \\n X_=np.arange(NX)\\n Y_=np.arange(NY)\\n \\n avX,sigX=weighted_avg_and_std(X_,profile_X**4) # take squared on purpose (weigh must be >0)\\n avY,sigY=weighted_avg_and_std(Y_,profile_Y**4)\\n \\n x0=int(avX+x0-star_halfwidth)\\n \\n \\n # find the center in Y on the spectrum\\n yprofile=np.sum(full_image[:,spec_index_min:spec_index_max],axis=1)\\n y0=np.where(yprofile==yprofile.max())[0][0]\\n\\n # cut the image in vertical and normalise by exposition time\\n reduc_image=full_image[y0-20:y0+20,x0:spec_index_max]/all_expo[index] \\n reduc_image[:,0:100]=0 # erase central star\\n \\n X_Size_Pixels=np.arange(0,reduc_image.shape[1])\\n Y_Size_Pixels=np.arange(0,reduc_image.shape[0])\\n Transverse_Pixel_Size=Y_Size_Pixels-int(float(Y_Size_Pixels.shape[0])/2.)\\n \\n # calibration in wavelength\\n #grating_name=all_filt[index].replace('dia ','')\\n grating_name=get_disperser_filtname(all_filt[index])\\n \\n lambdas=Pixel_To_Lambdas(grating_name,X_Size_Pixels,all_pointing[index],True)\\n \\n #if grating_name=='Ron200':\\n # holo = Hologram('Ron400',verbose=True)\\n #else: \\n # holo = Hologram(grating_name,verbose=True)\\n #lambdas=holo.grating_pixel_to_lambda(X_Size_Pixels,all_pointing[index])\\n #if grating_name=='Ron200':\\n # lambdas=lambdas*2.\\n \\n\\n X,Y=np.meshgrid(lambdas,Transverse_Pixel_Size) \\n T=np.transpose(reduc_image)\\n \\n \\n plt.contourf(X, Y, reduc_image, 100, alpha=1., cmap='jet',origin='lower')\\n C = plt.contour(X, Y, reduc_image , 20, colors='black', linewidth=.5,origin='lower')\\n \\n \\n for line in LINES:\\n if line == O2 or line == HALPHA or line == HBETA or line == HGAMMA:\\n plt.plot([line['lambda'],line['lambda']],[YMIN,YMAX],'-',color='lime',lw=0.5)\\n plt.text(line['lambda'],YMAX-3,line['label'],verticalalignment='bottom', horizontalalignment='center',color='lime', fontweight='bold',fontsize=16)\\n \\n \\n \\n plt.axis([X.min(), X.max(), Y.min(), Y.max()]); plt.grid(True)\\n plt.title(all_titles[index])\\n plt.grid(color='white', ls='solid')\\n plt.text(200,-5.,all_filt[index],verticalalignment='bottom', horizontalalignment='center',color='yellow', fontweight='bold',fontsize=16)\\n plt.xlabel('$\\\\lambda$ (nm)')\\n plt.ylabel('pixels')\\n plt.ylim(YMIN,YMAX)\\n plt.xlim(0.,1200.)\\n plt.savefig(figfilename)\",\n \"def point1(source, ants, elmin=15.0, showGUI=True, zoom=1, mode=0, \\n nextSource=None, writeFITS=True, brightness=50,isInner=False,\\n subtractBackground=False, ncoadd=1, dazbkg=2.0, centroidLoopMax=16,\\n minsamples=None):\\n global previous_source_\\n antlist = helpers.makeList(ants)\\n el = elevation(source)\\n \\n # Check for source too low, and bail out if it is\\n if el < elmin:\\n print 'Skipping %s because elevation(%.1f) is less than limit(%.1f)' \\\\\\n %(source,el,elmin)\\n return\\n \\n # Check for maximum elevation as well\\n maxelLimit = 87.0\\n if el > maxelLimit:\\n print 'Skipping %s because elevation(%.1f) is greater than limit(%.1f)' \\\\\\n %(source,el,maxelLimit)\\n return\\n\\n # Print message\\n msg = \\\"Pointing on %s at el=%5.1f (elmin = %5.1f); ants = %s\\\" % (source, el, elmin, str(ants))\\n print msg\\n SAC.scriptlog(msg)\\n \\n d = distance(source,previous_source_)\\n print \\\" Distance from %s to %s is %.1f deg\\\" %(previous_source_,source,d)\\n if mode > 0:\\n if nextSource != None:\\n print \\\" Next source will be %s\\\" % nextSource\\n else:\\n print \\\" Last source.\\\"\\n # Send all antennas tracking to new source, even though some are\\n # already there.\\n if isInner :\\n SAC.track(source)\\n else : SAC.track(source, antlist, phaseCenter=False, waiton=SAC.NONE)\\n antsTodo = antlist\\n while len(antsTodo) > 0 :\\n r = SAC.wait(SAC.TRACK, antsTodo, waiton=SAC.ANY)\\n antsReady = r.ready\\n antsTodo = r.notready\\n for i in antsReady :\\n show(source)\\n #print \\\"Loading camera on antenna %d\\\" %i\\n opticalSystem(i, auto=True, object=source, repeat=4, zoom=zoom,\\n showGUI=showGUI, dontClose=True, \\n brightness=brightness, ncoadd=ncoadd, dazbkg=dazbkg,\\n subtractBackground=subtractBackground, \\n centroidLoopMax=centroidLoopMax, minsamples=minsamples)\\n # now that this ant is done, send it to next source\\n if mode > 0:\\n if nextSource != None: \\n if isInner : SAC.track(nextSource)\\n else : SAC.track(nextSource, i, waiton=SAC.NONE)\\n previous_source_ = source\",\n \"def ray_label_simplex(grid, simplex, thresh):\\n coords = [grid[:,x] for x in simplex]\\n dist = squareform(pdist(coords,'euclidean'))\\n adjacency = dist<thresh\\n adjacency = adjacency.astype(int) \\n graph = csr_matrix(adjacency)\\n n_components, labels = connected_components(csgraph=graph, directed=False, return_labels=True)\\n\\n return n_components\",\n \"def create_grid_and_edges(data, drone_altitude, safety_distance):\\n\\n # minimum and maximum north coordinates\\n north_min = np.floor(np.min(data[:, 0] - data[:, 3]))\\n north_max = np.ceil(np.max(data[:, 0] + data[:, 3]))\\n\\n # minimum and maximum east coordinates\\n east_min = np.floor(np.min(data[:, 1] - data[:, 4]))\\n east_max = np.ceil(np.max(data[:, 1] + data[:, 4]))\\n\\n # given the minimum and maximum coordinates we can\\n # calculate the size of the grid.\\n north_size = int(np.ceil((north_max - north_min)))\\n east_size = int(np.ceil((east_max - east_min)))\\n\\n # Initialize an empty grid\\n grid = np.zeros((north_size, east_size))\\n\\n # Define a list to hold Voronoi points\\n points = []\\n # Populate the grid with obstacles\\n for i in range(data.shape[0]):\\n north, east, alt, d_north, d_east, d_alt = data[i, :]\\n\\n if alt + d_alt + safety_distance > drone_altitude:\\n obstacle = [\\n int(north - d_north - safety_distance - north_min),\\n int(north + d_north + safety_distance - north_min),\\n int(east - d_east - safety_distance - east_min),\\n int(east + d_east + safety_distance - east_min),\\n ]\\n grid[obstacle[0]:obstacle[1] + 1, obstacle[2]:obstacle[3] + 1] = 1\\n\\n # add center of obstacles to points list\\n points.append([north - north_min, east - east_min])\\n\\n # create a voronoi graph based on\\n # location of obstacle centres\\n graph = Voronoi(points)\\n # check each edge from graph.ridge_vertices for collision\\n edges = []\\n for v in graph.ridge_vertices:\\n p1 = graph.vertices[v[0]].astype(int)\\n p2 = graph.vertices[v[1]].astype(int)\\n # test each pair p1 and p2 for collision using Bresenham\\n # If the edge does not hit an obstacle add it to the list\\n in_collision = False\\n ridgeline = bresenham(p1[0], p1[1], p2[0], p2[1])\\n for b in ridgeline:\\n # eliminate out of range points in the line\\n if b[0] < 0 or b[0] >= grid.shape[0]:\\n in_collision = True\\n break\\n if b[1] < 0 or b[1] >= grid.shape[1]:\\n in_collision = True\\n break\\n # check if grid cell is an obstacle\\n if grid[b[0], b[1]] == 1:\\n in_collision = True\\n break\\n # keep ridge points not in collision\\n if not in_collision:\\n p1 = (p1[0], p1[1])\\n p2 = (p2[0], p2[1])\\n edges.append((p1, p2))\\n\\n return grid, edges\",\n \"def phosphorene_4band():\\n a = 0.222\\n ax = 0.438\\n ay = 0.332\\n theta = 96.79 * (pi / 180)\\n phi = 103.69 * (pi / 180)\\n\\n lat = pb.Lattice(a1=[ax, 0], a2=[0, ay])\\n\\n h = a * sin(phi - pi / 2)\\n s = 0.5 * ax - a * cos(theta / 2)\\n lat.add_sublattices(\\n ('A', [-s/2, -ay/2, h], 0),\\n ('B', [ s/2, -ay/2, 0], 0),\\n ('C', [-s/2 + ax/2, 0, 0], 0),\\n ('D', [ s/2 + ax/2, 0, h], 0)\\n )\\n\\n lat.register_hopping_energies({\\n 't1': -1.22,\\n 't2': 3.665,\\n 't3': -0.205,\\n 't4': -0.105,\\n 't5': -0.055\\n })\\n\\n lat.add_hoppings(\\n # t1\\n ([-1, 0], 'A', 'D', 't1'),\\n ([-1, -1], 'A', 'D', 't1'),\\n ([ 0, 0], 'B', 'C', 't1'),\\n ([ 0, -1], 'B', 'C', 't1'),\\n # t2\\n ([ 0, 0], 'A', 'B', 't2'),\\n ([ 0, 0], 'C', 'D', 't2'),\\n # t3\\n ([ 0, 0], 'A', 'D', 't3'),\\n ([ 0, -1], 'A', 'D', 't3'),\\n ([ 1, 1], 'C', 'B', 't3'),\\n ([ 1, 0], 'C', 'B', 't3'),\\n # t4\\n ([ 0, 0], 'A', 'C', 't4'),\\n ([ 0, -1], 'A', 'C', 't4'),\\n ([-1, 0], 'A', 'C', 't4'),\\n ([-1, -1], 'A', 'C', 't4'),\\n ([ 0, 0], 'B', 'D', 't4'),\\n ([ 0, -1], 'B', 'D', 't4'),\\n ([-1, 0], 'B', 'D', 't4'),\\n ([-1, -1], 'B', 'D', 't4'),\\n # t5\\n ([-1, 0], 'A', 'B', 't5'),\\n ([-1, 0], 'C', 'D', 't5')\\n )\\n\\n return lat\",\n \"def test_plot_mesh(self):\\n plt.close('all')\\n\\n #\\n # Initialize\\n #\\n fig, ax = plt.subplots(3,3)\\n plot = Plot()\\n #\\n # Define mesh\\n # \\n mesh = Mesh.newmesh(grid_size=(2,2))\\n mesh.refine() \\n mesh.root_node().children[1,1].mark(1)\\n mesh.refine(1)\\n \\n # Plot simple mesh\\n ax[0,0] = plot.mesh(ax[0,0], mesh)\\n \\n #\\n # Flag a few cells\\n # \\n mesh.unmark(nodes=True)\\n mesh.root_node().children[0,0].mark(2)\\n mesh.root_node().children[1,0].mark(1)\\n mesh.root_node().children[1,1].children['SW'].mark(3)\\n mesh.root_node().children[1,1].children['NE'].mark(3)\\n \\n # Color flagged cells\\n ax[0,1] = plot.mesh(ax[0,1], mesh, color_marked=[1,2,3], nested=True)\\n \\n # Plot vertex numbers\\n ax[0,2] = plot.mesh(ax[0,2], mesh, vertex_numbers=True)\\n \\n # Plot edge numbers\\n ax[1,0] = plot.mesh(ax[1,0], mesh, edge_numbers=True)\\n \\n # Plot cell numbers nested off\\n mesh.refine(2)\\n ax[1,1] = plot.mesh(ax[1,1], mesh, cell_numbers=True)\\n \\n # Plot cell numbers nested on\\n ax[1,2] = plot.mesh(ax[1,2], mesh, cell_numbers=True, nested=True)\\n\\n # Plot dofs\\n element = QuadFE(2,'Q1')\\n ax[2,0] = plot.mesh(ax[2,0], mesh, element=element, dofs=True)\\n \\n # Assign dofs in a nested way\\n ax[2,1] = plot.mesh(ax[2,1], mesh, element=element, dofs=True, \\\\\\n nested=True)\\n \\n # Display only dofs of flagged nodes \\n ax[2,2] = plot.mesh(ax[2,2], mesh, element=element, dofs=True, \\\\\\n node_flag=3, nested=True, show_axis=True)\",\n \"def plot_3d(trj: TrajaDataFrame, **kwargs) -> matplotlib.collections.PathCollection:\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection=\\\"3d\\\")\\n ax.set_xlabel(\\\"x\\\", fontsize=15)\\n ax.set_zlabel(\\\"time\\\", fontsize=15)\\n ax.set_ylabel(\\\"y\\\", fontsize=15)\\n title = kwargs.pop(\\\"title\\\", \\\"Trajectory\\\")\\n ax.set_title(f\\\"{title}\\\", fontsize=20)\\n ax.plot(trj.x, trj.y, trj.index)\\n cmap = kwargs.pop(\\\"cmap\\\", \\\"winter\\\")\\n cm = plt.get_cmap(cmap)\\n NPOINTS = len(trj)\\n ax.set_prop_cycle(color=[cm(1.0 * i / (NPOINTS - 1)) for i in range(NPOINTS - 1)])\\n for i in range(NPOINTS - 1):\\n ax.plot(trj.x[i : i + 2], trj.y[i : i + 2], trj.index[i : i + 2])\\n\\n dist = kwargs.pop(\\\"dist\\\", None)\\n if dist:\\n ax.dist = dist\\n labelpad = kwargs.pop(\\\"labelpad\\\", None)\\n if labelpad:\\n from matplotlib import rcParams\\n\\n rcParams[\\\"axes.labelpad\\\"] = labelpad\\n\\n return ax\",\n \"def tSNE_plot3(features, labels):\\n model = TSNE(n_components=3, random_state=0)\\n transformed = model.fit_transform(features)\\n\\n print(\\\"Data transformed, now plotting...\\\")\\n\\n # Plotting\\n x = transformed[:, 0]\\n y = transformed[:, 1]\\n z = transformed[:, 2]\\n colors = labels\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection='3d')\\n ax.scatter(x, y, z, s=20, c=colors, depthshade=True)\\n plt.show()\",\n \"def point_spatial_transformer(x, single=False, sdt_vol_resize=1):\\n\\n # surface_points is a N x D or a N x (D+1) Tensor\\n # trf is a *volshape x D Tensor\\n surface_points, trf = x\\n trf = trf * sdt_vol_resize\\n surface_pts_D = surface_points.get_shape().as_list()[-1]\\n trf_D = trf.get_shape().as_list()[-1]\\n assert surface_pts_D in [trf_D, trf_D + 1]\\n\\n if surface_pts_D == trf_D + 1:\\n li_surface_pts = K.expand_dims(surface_points[..., -1], -1)\\n surface_points = surface_points[..., :-1]\\n\\n # just need to interpolate.\\n # at each location determined by surface point, figure out the trf...\\n # note: if surface_points are on the grid, gather_nd should work as well\\n fn = lambda x: ne.utils.interpn(x[0], x[1])\\n diff = tf.map_fn(fn, [trf, surface_points], dtype=tf.float32)\\n ret = surface_points + diff\\n\\n if surface_pts_D == trf_D + 1:\\n ret = tf.concat((ret, li_surface_pts), -1)\\n\\n return ret\",\n \"def plot_contours(clf, points,labels):\\n def make_meshgrid(x, y,h=0.02):\\n \\\"\\\"\\\"Create a mesh of points to plot in\\n Parameters\\n ----------\\n x: data to base x-axis meshgrid on\\n y: data to base y-axis meshgrid on\\n h: stepsize for meshgrid, optional\\n Returns\\n -------\\n xx, yy : ndarray\\n \\\"\\\"\\\"\\n x_min, x_max = x.min() - 1, x.max() + 1\\n y_min, y_max = y.min() - 1, y.max() + 1\\n xx, yy = np.meshgrid(np.arange(x_min, x_max, h),\\n np.arange(y_min, y_max, h))\\n return xx, yy\\n X0, X1 = points[:, 0], points[:, 1]\\n xx, yy = make_meshgrid(X0, X1,0.5)\\n Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])\\n Z = Z.reshape(xx.shape)\\n #VISUALIZATION OF DECISION\\n fig2 = plt.figure(figsize=(5,5))\\n ax = fig2.add_subplot(1,1,1)\\n out = plt.contourf(xx, yy, Z, cmap=plt.cm.coolwarm, alpha=0.8)\\n ax.scatter(X0, X1, c=labels, cmap=plt.cm.coolwarm, s=80, edgecolors='k')\\n ax.scatter(X0[clf.support_],X1[clf.support_],c=labels[clf.support_], cmap=plt.cm.coolwarm, s=80, edgecolors='w')\\n ax.set_xlim(xx.min(), xx.max())\\n ax.set_ylim(yy.min(), yy.max())\\n plt.show()\\n return out\",\n \"def trip_grid(\\n trj: TrajaDataFrame,\\n bins: Union[tuple, int] = 10,\\n log: bool = False,\\n spatial_units: str = None,\\n normalize: bool = False,\\n hist_only: bool = False,\\n **kwargs,\\n) -> Tuple[np.ndarray, PathCollection]:\\n after_plot_args, kwargs = _get_after_plot_args(**kwargs)\\n\\n bins = traja.trajectory._bins_to_tuple(trj, bins)\\n # TODO: Add kde-based method for line-to-cell gridding\\n df = trj[[\\\"x\\\", \\\"y\\\"]].dropna()\\n\\n # Set aspect if `xlim` and `ylim` set.\\n if \\\"xlim\\\" in kwargs and \\\"ylim\\\" in kwargs:\\n xlim, ylim = kwargs.pop(\\\"xlim\\\"), kwargs.pop(\\\"ylim\\\")\\n else:\\n xlim, ylim = traja.trajectory._get_xylim(df)\\n xmin, xmax = xlim\\n ymin, ymax = ylim\\n\\n x, y = zip(*df.values)\\n\\n hist, x_edges, y_edges = np.histogram2d(\\n x, y, bins, range=((xmin, xmax), (ymin, ymax)), normed=normalize\\n )\\n\\n # rotate to keep y as first dimension\\n hist = np.rot90(hist)\\n\\n if log:\\n hist = np.log(hist + np.e)\\n if hist_only: # TODO: Evaluate potential use cases or remove\\n return (hist, None)\\n fig, ax = plt.subplots()\\n\\n image = ax.imshow(\\n hist, interpolation=\\\"bilinear\\\", aspect=\\\"equal\\\", extent=[xmin, xmax, ymin, ymax]\\n )\\n # TODO: Adjust colorbar ytick_labels to correspond with time\\n label = \\\"Frames\\\" if not log else \\\"$ln(frames)$\\\"\\n plt.colorbar(image, ax=ax, label=label)\\n\\n _label_axes(trj, ax)\\n\\n plt.title(\\\"Time spent{}\\\".format(\\\" (Logarithmic)\\\" if log else \\\"\\\"))\\n\\n _process_after_plot_args(**after_plot_args)\\n # TODO: Add method for most common locations in grid\\n # peak_index = unravel_index(hist.argmax(), hist.shape)\\n return hist, image\",\n \"def teselado(self,points):\\n #muestrea todo el espacio de la envolvente para conseguir las fronteras de decision a intervalos regulares \\n #get_hull\\n area = boundingbox(points)\\n #(min_x,min_y),(max_x,min_y),(max_x,max_y),(min_x,max_y)\\n #sample inside hull\\n lat_sample = np.arange(min_y, max_y, 0.001).tolist()\\n lon_sample = np.arange(min_x,max_x, 0.001)\\n sampling_space = [[x,y] for x in lat_sample for y in lon_sample]\\n sampling_space = np.asarray(sampling_space, dtype=np.float32)\\n prediction = kmeans_instance.predict(sampling_space)\\n pol = [[list(sampling_space[index]) for index in [i for i, j in enumerate(prediction) if j == k]] for k in range(centers)]\\n hull = [shapely.geometry.MultiPoint(pol[i]).convex_hull.exterior._get_coords() for i in range(len(pol))]\",\n \"def plot_contour( m, lat, lon, data, contour, clr = 'k' ):\\n \\n x, y = m( lon,lat )\\n \\n CS = m.contour( x, y, data, contour , linewidths = 0.8, colors = clr )\",\n \"def calculate_watershed_of_node(landscape, outlet_coords_r_c, d4):\\n landscape.heights = util.fill_single_cell_depressions(landscape.heights, landscape.ny, landscape.nx)\\n watersheds, steepest, flow_dir = util.calculate_watersheds(landscape.heights, landscape.nx, landscape.ny, landscape.step_size, d4)\\n # spill_heights = util.get_spill_heights(watersheds, landscape.heights, steepest)\\n # traps, size_of_traps = util.get_all_traps(watersheds, landscape.heights, spill_heights)\\n\\n # Increase heights of traps and recalculate flow. Remove flow from some indices in traps.\\n util.make_landscape_depressionless(watersheds, steepest, landscape)\\n print 'Made landscape depressionless'\\n # Test if traps are merged\\n watersheds, steepest, flow_dir = util.calculate_watersheds(landscape.heights, landscape.nx, landscape.ny, landscape.step_size, d4)\\n spill_heights = util.get_spill_heights(watersheds, landscape.heights, steepest)\\n traps, size_of_traps = util.get_all_traps(watersheds, landscape.heights, spill_heights)\\n\\n flow = util.get_flow_direction_indices(landscape.heights, landscape.step_size, landscape.ny, landscape.nx, d4)\\n flow_dir = util.get_flow_directions(landscape.heights, landscape.step_size, landscape.ny, landscape.nx, d4)\\n\\n for i in range(len(traps)):\\n trap_in_2d = util.map_1d_to_2d(traps[i], landscape.nx)\\n flow[trap_in_2d] = -1\\n flow_dir[trap_in_2d] = -1\\n\\n # Create connections and expand matrix to accommodate trap nodes\\n node_conn_mat = util.make_sparse_node_conn_matrix(flow, landscape.ny, landscape.nx)\\n node_conn_mat = expand_conn_mat(node_conn_mat, len(traps))\\n expanded_conn_mat = reroute_trap_connections(node_conn_mat, landscape.ny, landscape.nx, traps, steepest, d4)\\n\\n # Get the watershed of the node\\n ws_of_node, trap_nodes_in_ws = get_watershed_of_node(outlet_coords_r_c, expanded_conn_mat, traps, landscape.ny, landscape.nx)\\n\\n return ws_of_node, traps, spill_heights, trap_nodes_in_ws, steepest, flow_dir, landscape.heights\",\n \"def draw_heaters(ax, windtunnel):\\n draw_heater(ax, windtunnel.heater_l)\\n draw_heater(ax, windtunnel.heater_r)\",\n \"def plot_features(im, locs, circle=False):\\n def draw_circle(c, r):\\n t = arrange(0, 1.01, .01) * 2 * pi\\n x = r * cos(t) + c[0]\\n y = r * sin(t) + c[1]\\n plot(x, y, \\\"b\\\", linewidth=2)\\n\\n imshow(im)\\n if circle:\\n for p in locs:\\n draw_circle(p[:2], p[2])\\n else:\\n plot(locs[:, 0], locs[:, 1], \\\"ob\\\")\\n axis(\\\"off\\\")\",\n \"def mpl_triangulation(self):\\n tris=[] # [ (n1,n2,n3), ...]\\n\\n for c in self.valid_cell_iter():\\n nodes=np.array(self.cell_to_nodes(c))\\n\\n # this only works for convex cells\\n for i in range(1,len(nodes)-1):\\n tris.append( nodes[ [0,i,i+1] ] )\\n\\n tris=np.array(tris)\\n tri=Triangulation(self.nodes['x'][:,0],self.nodes['x'][:,1],\\n triangles=tris )\\n return tri\",\n \"def plot_trips(data, n_trips, name):\\n savedir = \\\"./\\\"\\n bins = 1000\\n lat_min, lat_max = 41.04961, 41.24961\\n lon_min, lon_max = -8.71099, -8.51099\\n z = np.zeros((bins, bins))\\n latlon = np.array([(lat, lon)\\n for path in data.POLYLINE\\n for lon, lat in path if len(path) > 0])\\n figure()\\n z += np.histogram2d(*latlon.T, bins=bins,\\n range=[[lat_min, lat_max],\\n [lon_min, lon_max]])[0]\\n log_density = np.log(1 + z)\\n title(str(n_trips) + ' Taxi trips')\\n imshow(log_density[::-1, :], # flip vertically\\n extent=[lat_min, lat_max, lon_min, lon_max])\\n savefig(savedir + name)\\n print \\\"img file saved in \\\" + savedir + name\",\n \"def plot_mesh(corners):\\r\\n triangle = tri.Triangulation(corners[:, 0], corners[:, 1])\\r\\n\\r\\n refiner = tri.UniformTriRefiner(triangle)\\r\\n trimesh = refiner.refine_triangulation(subdiv=4)\\r\\n \\r\\n plt.figure(figsize=(6, 4))\\r\\n for i, mesh in enumerate((triangle, trimesh)):\\r\\n plt.subplot(1, 2, i+1)\\r\\n plt.triplot(mesh)\\r\\n plt.axis('off')\\r\\n plt.axis('equal')\",\n \"def plot_dist_4p(\\n hst,\\n xi,\\n yi,\\n ax=None,\\n filled=False,\\n fcolors=None,\\n **kwargs,\\n ):\\n vl = [0.3, 0.6, 0.9, 0.99]\\n fig = plot_dist_xp(hst, xi, yi, ax=ax, levels=vl, filled=filled, fcolors=fcolors, **kwargs)\\n return fig\",\n \"def plot_vor_boundary(self,x,ax,tri=False):\\n\\n x = x[~np.isnan(x[:,0])]\\n c_types_print = np.ones(x.shape[0],dtype=np.int32)*-1\\n c_types_print[:self.n_C] = self.c_types\\n regions, vertices = self.voronoi_finite_polygons_2d(Voronoi(x))\\n\\n\\n ax.set(aspect=1,xlim=(0,self.L),ylim=(0,self.L))\\n if type(self.c_types) is list:\\n # ax.scatter(x[:, 0], x[:, 1],color=\\\"grey\\\",zorder=1000)\\n for region in regions:\\n polygon = vertices[region]\\n plt.fill(*zip(*polygon), alpha=0.4, color=\\\"grey\\\")\\n\\n else:\\n cols = self.cols\\n patches = []\\n if self.plot_scatter is True:\\n ax.scatter(x[:self.n_C, 0], x[:self.n_C, 1], color=\\\"black\\\", zorder=1000)\\n ax.scatter(x[self.n_C:, 0], x[self.n_C:, 1], color=\\\"grey\\\", zorder=1000)\\n\\n for i, region in enumerate(regions):\\n patches.append(Polygon(vertices[region], True,facecolor=cols[c_types_print[i]],edgecolor=\\\"white\\\",alpha=0.5))\\n\\n p = PatchCollection(patches, match_original=True)\\n # p.set_array(c_types_print)\\n ax.add_collection(p)\\n if tri is not False:\\n for TRI in tri:\\n for j in range(3):\\n a, b = TRI[j], TRI[np.mod(j + 1, 3)]\\n if (a >= 0) and (b >= 0):\\n X = np.stack((x[a], x[b])).T\\n ax.plot(X[0], X[1], color=\\\"black\\\")\",\n \"def find_interpolation_coefficients(grid,pt,tessellation,ndx):\\n\\n if (pt is None): return None, None\\n if (tessellation is None): return None, None\\n pt1 = np.asarray(pt[0:-1],dtype=gtype)\\n val = tessellation.find_simplex(pt1.reshape((1,grid.ndim)))[0]\\n\\n # see if point is outside tessellation\\n if (val == -1): return None, None\\n mat = tessellation.transform[val]\\n\\n # make sure the transformation matrix is defined:\\n if (math.isnan(np.sum(mat))): return None, None\\n\\n b = mat[:grid.ndim].dot(pt1-mat[grid.ndim])\\n coefs = np.r_[b, 1.0-b.sum()]\\n ind = tessellation.simplices[val]\\n\\n # check to make sure you're not outside the grid:\\n for coef in coefs:\\n if (coef < -tol): return None, None\\n\\n # produce results, filtering out zero elements:\\n coefs_out = []\\n tracks = []\\n for coef,i in zip(coefs,ind):\\n # remove negative coefficients to avoid problems.\\n if (coef > 0.0):\\n coefs_out.append(coef)\\n tracks.append(grid.tracks[ndx[i]])\\n\\n return coefs_out, tracks\",\n \"def closest_pair_strip(cluster_list, horiz_center, half_width):\\n indices = [] \\n\\n # Let S be a list of the set {i: |xi - mid| < half_width}\\n indices = [index for index in range(len(cluster_list)) if abs(cluster_list[index].horiz_center()-horiz_center)<=half_width]\\n \\n\\t# Sort the indices in S in nondecreasing order of the vertial (y) coordinates of their associated points;\\n indices.sort(key = lambda index: cluster_list[index].vert_center())\\n\\n cl_sorted = cluster_list[:]\\n cl_sorted.sort(key = lambda cluster: cluster.vert_center())\\n\\n # k <-- length(S);\\n len_indices = len(indices)\\n\\n # (d,i,j) <-- (infinity, -1, -1);\\n output_list = [float('inf'), -1, -1]\\t\\n\\n # for u <-- 0 to k - 2 do\\n for value1 in range(len_indices-1):\\n \\t# \\tfor v <-- u + 1 to min{u+3,k-1} do\\n for value2 in range(value1+1, min(value1+6,len_indices)):\\n # (d,i,j) <-- min{(d,i,j),(dsub(psubS[u],PsubS[v]), S[u],S[v])}\\n min_dist = min(output_list[0], pair_distance(cluster_list,indices[value1],indices[value2])[0])\\n if output_list[0] > min_dist:\\n indices_sorted = sorted([indices[value1], indices[value2]])\\n \\toutput_list = [pair_distance(cluster_list,indices[value1],indices[value2])[0], indices_sorted[0], indices_sorted[1]]\\n\\n # return(d,i,j)\\n return tuple(output_list)\",\n \"def pf_plot(pf, t):\\n xx = pf.XS[t, :, 0]\\n yy = pf.XS[t, :, 1]\\n ww = pf.WS[t, :]\\n plt.scatter(xx, yy, s=ww * 5000)\",\n \"def solveTetris(self,**kwargs):\\n #self.showCamera()\\n self.locator.recognise_grid()\",\n \"def makemesh(pts,vec,growsize=0.2,curvilinear_neighbors=10,\\n\\tcurvilinear=True,debug=False,growsize_nm=None,excise=True,areas_only=False):\\n\\tif debug: \\n\\t\\timport time\\n\\t\\tst = time.time()\\n\\t\\tdef checkpoint(note):\\n\\t\\t\\tprint(note)\\n\\t\\t\\tst = time.time()\\n\\n\\tnmol = len(pts)\\n\\tpts = pts\\n\\tvec = vec\\n\\tif debug: \\n\\t\\timport time\\n\\t\\tst = time.time()\\n\\t\\tprint(\\\"[STATUS] start makemesh %0.2f\\\"%(time.time()-st))\\n\\tptsb,ptsb_inds = beyonder(pts,vec,growsize=growsize,growsize_nm=growsize_nm,return_ids=True)\\n\\tif debug: print(\\\"[STATUS] project curvilinear=\\\"+str(curvilinear)+\\\" %0.2f\\\"%(time.time()-st))\\n\\t#---if curvilinear then use the isomap otherwise project onto the xy plane\\n\\tif curvilinear: \\n\\t\\timport sklearn\\n\\t\\tfrom sklearn import manifold\\n\\t\\tproj = manifold.Isomap(curvilinear_neighbors,2).fit_transform(ptsb)\\n\\telse: proj = ptsb[...,:2]\\n\\tif debug: checkpoint(\\\"[STATUS] delaunay %0.2f\\\"%(time.time()-st))\\n\\tif debug: checkpoint(\\\"[STATUS] shape=\\\"+str(np.shape(ptsb)))\\n\\tdl = scipy.spatial.Delaunay(proj)\\n\\tif debug: checkpoint(\\\"[STATUS] reclock %0.2f\\\"%(time.time()-st))\\n\\tsimplices = np.array([a[reclock(ptsb[a])] for a in dl.simplices])\\n\\t#---rework simplices and ptsb to exclude superfluous points\\n\\tif debug: checkpoint(\\\"[STATUS] trim %0.2f\\\"%(time.time()-st))\\n\\t#---relevants is a unique list of simplices with exactly one member that is equal to a core vertex point\\n\\trelevants = np.unique(np.concatenate([simplices[\\n\\t\\tnp.where(np.sum(simplices==i,axis=1)==1)[0]] for i in range(nmol)]))\\n\\tpoints = ptsb[relevants]\\n\\tghost_indices = ptsb_inds[relevants]\\n\\tptsb = points\\n\\n\\tif debug: checkpoint(\\\"[STATUS] simplices %0.2f\\\"%(time.time()-st))\\n\\tsimplices = np.array([[np.where(relevants==r)[0][0] for r in s] \\n\\t\\tfor s in simplices if np.all([r in relevants for r in s])])\\n\\t#---end rework\\n\\tif debug: checkpoint(\\\"[STATUS] areas %0.2f\\\"%(time.time()-st))\\n\\tareas = np.array([triarea(ptsb[a]) for a in simplices])\\n\\tif areas_only: return {'simplices':simplices,'areas':areas,'nmol':nmol,'vec':vec,'points':points}\\n\\tif debug: checkpoint(\\\"[STATUS] facenorms %0.2f\\\"%(time.time()-st))\\n\\tfacenorms = np.array([vecnorm(facenorm(ptsb[a])) for a in simplices])\\t\\n\\tif debug: checkpoint(\\\"[STATUS] vertex-to-simplex %0.2f\\\"%(time.time()-st))\\n\\tv2s = [np.where(np.any(simplices==i,axis=1))[0] for i in range(nmol)]\\n\\tif debug: checkpoint(\\\"[STATUS] vertex normals %0.2f\\\"%(time.time()-st))\\n\\tvertnorms = np.array([vecnorm(np.sum(facenorms[ind]*\\\\\\n\\t\\tnp.transpose([areas[ind]/np.sum(areas[ind])]),axis=0)) for ind in v2s])\\n\\tprincipals = np.zeros((nmol,2))\\n\\tnl = []\\n\\tif debug: checkpoint(\\\"[STATUS] curvatures %0.2f\\\"%(time.time()-st))\\n\\tfor v in range(nmol):\\n\\t\\tneighbors = np.unique(simplices[np.where(np.any(simplices==v,axis=1))[0]])\\n\\t\\tneighbors = neighbors[neighbors!=v]\\n\\t\\tnl.append(neighbors)\\n\\t\\tedges = ptsb[neighbors]-ptsb[v]\\n\\t\\tweights = [areas[sl]/2./np.sum(areas[v2s[v]]) for sl in v2s[v]]\\n\\t\\ttijs = [vecnorm(np.dot(np.identity(3)-np.outer(vertnorms[v],\\n\\t\\t\\tvertnorms[v].T),ab)) for ab in edges]\\n\\t\\tkijs = [np.dot(vertnorms[v].T,ab)/linalg.norm(ab)**2 for ab in edges]\\n\\t\\tct = np.sum([weights[ind]*kijs[ind]*np.outer(tijs[ind],tijs[ind]) \\n\\t\\t\\tfor ind,i in enumerate(v2s[v])],axis=0)\\n\\t\\twsign = 1-2*(linalg.norm(np.array([1,0,0])+\\\\\\n\\t\\t\\tvertnorms[v])<linalg.norm(np.array([1,0,0])-vertnorms[v]))\\n\\t\\twvi = vecnorm(np.array([1,0,0])+wsign*vertnorms[v])\\n\\t\\thm = np.identity(3)-2*np.outer(wvi,wvi.T)\\n\\t\\thhm = np.dot(np.dot(hm.T,ct),hm)\\n\\t\\tprincipals[v] = -1*hhm[1,1],-1*hhm[2,2]\\n\\tif debug: checkpoint(\\\"[STATUS] PBC neighborlist %0.2f\\\"%(time.time()-st))\\n\\t#---neighborlist under PBCs\\n\\tchecksubssort,nlsubs = np.where(torusnorm(points[nmol:],points[:nmol],vec)==0)\\n\\t#if not all(checksubssort==np.arange(len(points)-nmol)): raise Exception('torusnorm lookup fail')\\n\\ttry: nlpbc = [[(i if i<nmol else nlsubs[i-nmol]) for i in n] for n in nl]\\n\\texcept: nlpbc = []\\n\\tgauss = (3*principals[:,0]-principals[:,1])*(3*principals[:,1]-\\\\\\n\\t\\tprincipals[:,0])\\n\\tmean = 1./2*((3*principals[:,0]-principals[:,1])+\\\\\\n\\t\\t(3*principals[:,1]-principals[:,0]))\\n\\tif debug: checkpoint(\\\"[STATUS] complete %0.2f\\\"%(time.time()-st))\\n\\n\\tif debug:\\n\\t\\timport matplotlib as mpl;import matplotlib.pylab as plt\\n\\t\\tplt.scatter(points[:,0],points[:,1])\\n\\t\\tplt.show()\\n\\t\\timport pdb;pdb.set_trace()\\n\\n\\treturn {'nmol':nmol,'vec':vec,'simplices':simplices,'points':points,\\n\\t\\t'areas':areas,'facenorms':facenorms,'vertnorms':vertnorms,'principals':principals,\\n\\t\\t'ghost_ids':ghost_indices,'gauss':gauss,'mean':mean}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.54688436","0.54646534","0.53946656","0.5362895","0.5319889","0.52629554","0.52503395","0.52421236","0.52283096","0.52271646","0.52166325","0.5207605","0.52060854","0.5204232","0.51916236","0.51884454","0.5186699","0.5146042","0.5143565","0.51160043","0.50919545","0.5090334","0.508701","0.50867134","0.50778216","0.5064369","0.5054932","0.5054675","0.5051651","0.5049823","0.50346136","0.50282055","0.5027212","0.50164115","0.50120175","0.5009744","0.49854687","0.49837428","0.4973019","0.495727","0.4951383","0.49503356","0.4942126","0.49369863","0.4925688","0.4923949","0.49173486","0.49155957","0.49153972","0.49125367","0.49124163","0.49105042","0.49054322","0.49040496","0.48965207","0.48933393","0.48930952","0.48920572","0.4875953","0.4870051","0.4868379","0.4866499","0.4864252","0.48574284","0.4856445","0.48558512","0.48555052","0.48534364","0.4852181","0.4849446","0.4847012","0.48454884","0.4843147","0.48425025","0.48369077","0.4825535","0.4824713","0.4811965","0.48043242","0.4795936","0.47830528","0.47829413","0.47813252","0.4777155","0.47767302","0.4774344","0.476803","0.47642237","0.47619107","0.4759078","0.47539914","0.47537866","0.4751826","0.47492847","0.4747364","0.4747246","0.47341442","0.473305","0.47323143","0.47319615"],"string":"[\n \"0.54688436\",\n \"0.54646534\",\n \"0.53946656\",\n \"0.5362895\",\n \"0.5319889\",\n \"0.52629554\",\n \"0.52503395\",\n \"0.52421236\",\n \"0.52283096\",\n \"0.52271646\",\n \"0.52166325\",\n \"0.5207605\",\n \"0.52060854\",\n \"0.5204232\",\n \"0.51916236\",\n \"0.51884454\",\n \"0.5186699\",\n \"0.5146042\",\n \"0.5143565\",\n \"0.51160043\",\n \"0.50919545\",\n \"0.5090334\",\n \"0.508701\",\n \"0.50867134\",\n \"0.50778216\",\n \"0.5064369\",\n \"0.5054932\",\n \"0.5054675\",\n \"0.5051651\",\n \"0.5049823\",\n \"0.50346136\",\n \"0.50282055\",\n \"0.5027212\",\n \"0.50164115\",\n \"0.50120175\",\n \"0.5009744\",\n \"0.49854687\",\n \"0.49837428\",\n \"0.4973019\",\n \"0.495727\",\n \"0.4951383\",\n \"0.49503356\",\n \"0.4942126\",\n \"0.49369863\",\n \"0.4925688\",\n \"0.4923949\",\n \"0.49173486\",\n \"0.49155957\",\n \"0.49153972\",\n \"0.49125367\",\n \"0.49124163\",\n \"0.49105042\",\n \"0.49054322\",\n \"0.49040496\",\n \"0.48965207\",\n \"0.48933393\",\n \"0.48930952\",\n \"0.48920572\",\n \"0.4875953\",\n \"0.4870051\",\n \"0.4868379\",\n \"0.4866499\",\n \"0.4864252\",\n \"0.48574284\",\n \"0.4856445\",\n \"0.48558512\",\n \"0.48555052\",\n \"0.48534364\",\n \"0.4852181\",\n \"0.4849446\",\n \"0.4847012\",\n \"0.48454884\",\n \"0.4843147\",\n \"0.48425025\",\n \"0.48369077\",\n \"0.4825535\",\n \"0.4824713\",\n \"0.4811965\",\n \"0.48043242\",\n \"0.4795936\",\n \"0.47830528\",\n \"0.47829413\",\n \"0.47813252\",\n \"0.4777155\",\n \"0.47767302\",\n \"0.4774344\",\n \"0.476803\",\n \"0.47642237\",\n \"0.47619107\",\n \"0.4759078\",\n \"0.47539914\",\n \"0.47537866\",\n \"0.4751826\",\n \"0.47492847\",\n \"0.4747364\",\n \"0.4747246\",\n \"0.47341442\",\n \"0.473305\",\n \"0.47323143\",\n \"0.47319615\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6441977"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21298,"cells":{"query":{"kind":"string","value":"Read from powerlaw database input files"},"document":{"kind":"string","value":"def plot_powerlaw_output(timeDB, xunits='yr', yunits='MPa', skip=8, P0=33.0):"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def read_stock(db, openfile):\n pass","def read_locations(db, openfile):\n pass","def read_sql(self):\n pass","def read(self):\n file_path = os.path.join(self.query_path, self.filename + '.sql')\n with open(file_path, 'r') as f:\n self.raw_sql = f.read()","def build_input_db():\n build_input_database()","def read(self, database ='project'):\n\t\tfile = open(self.file_name, \"r\")\n\n\t\ti = 1\n\t\tseptics = []\n\t\tfor line in file:\n\t\t\tif i > 2:\n\t\t\t\tval = line.split()\n\t\t\t\tself.check_cols(val, 13, 'septic')\n\n\t\t\t\tsep = {\n\t\t\t\t\t'name': val[0].lower(),\n\t\t\t\t\t'q_rate': val[1],\n\t\t\t\t\t'bod': val[2],\n\t\t\t\t\t'tss': val[3],\n\t\t\t\t\t'nh4_n': val[4],\n\t\t\t\t\t'no3_n': val[5],\n\t\t\t\t\t'no2_n': val[6],\n\t\t\t\t\t'org_n': val[7],\n\t\t\t\t\t'min_p': val[8],\n\t\t\t\t\t'org_p': val[9],\n\t\t\t\t\t'fcoli': val[10],\n\t\t\t\t\t'description': val[12] if val[12] != 'null' else None # 12 index because extra column\n\t\t\t\t}\n\t\t\t\tseptics.append(sep)\n\t\t\ti += 1\n\n\t\tif database == 'project':\n\t\t\tdb_lib.bulk_insert(project_base.db, project_parmdb.Septic_sep, septics)\n\t\telse:\n\t\t\tdb_lib.bulk_insert(datasets_base.db, datasets_parmdb.Septic_sep, septics)","def read_database():\n file = tables.open_file(glob.datafile)\n table_d = file.root.VelibData.dynamic\n table_s = file.root.VelibData.static\n n_rows = len(table_d)\n print \"Nrows in dynamic table:\", n_rows\n print \"N stations:\", len(table_d[0][\"last_update\"])\n print \"Time of most recent sampling:\", \\\n time.asctime(time.localtime(recover_time(table_d[-1][\"sample_time\"])))\n print \"Nbikes available at most recent sampling:\", \\\n table_d[n_rows-1][\"available_bikes\"]\n print \"Time of last_update at most recent sampling:\", \\\n time.asctime(\n time.localtime(recover_time(table_d[n_rows-1][\"last_update\"][0])))\n print \"Number arr\", table_s[0][\"number\"]\n file.close()","def read_relations(db, openfile):\n pass","def readVCTPINPUTS(self): \n #fname= os.environ['VMECFDIR'] +\"/CFG/ctp/DB/VALID.CTPINPUTS\"\n fname= os.environ['VMECFDIR'] +\"/CFG/ctp/DB/ctpinputs.cfg\"\n try:\n database=open(fname,\"r\") \n except IOError:\n print \"Cannot open \",fname\n return None\n else:\n print \"File \",fname,\" open successfuly.\"\n #print \"database= \",database\n lines=database.readlines()\n database.close() \n #print lines,len(lines) \n dbinputs=[]\n count=0\n #print \"look for me if you want different inputs range...\"\n for i in lines:\n if(i[0] == 'l' and i[1] == '0'): continue\n if i == \"\\n\": continue\n if(i[0] != '#'):\n items=string.split(i)\n #print 'items= ',items,len(items)\n if(len(items)<6):\n print \"Error parsing database, not enough items in line:\"\n print items\n continue\n #return None\n if items[3] == 'M': continue\n count=count+1\n #if count<6 or count>11 : continue\n #if count>10 and count<24 : continue\n #if count<16: continue\n #if count > 4 and count < 15: continue\n #if items[3] != '1': continue\n #if items[2] != \"EMCAL\": continue\n #if (items[2] != \"SPD\") and (items[2] != \"T0\"): continue\n flag=1\n for i in self.detectors:\n if items[2].find(i)>=0 or i.find(\"ALL\")>=0:\n flag=0;\n break\n if flag: continue\n # input not connected\n if items[7] == '0' and items[3] == '0': continue\n db={}\n db['name']=items[0]\n db['detector']=items[2]\n db['level']='L'+items[3]\n db['signature']=items[4]\n #db['number']=items[5]\n db['number']=items[7]\n db['numberDIM']=items[6]\n db['ctpnum']=items[5]\n db['Edge'] = items[8]\n db['Delay'] = items[9]\n dbinputs.append(db)\n #print \"Adding: \", db\n return dbinputs","def ReadPDB (self, pdb_path, db_path):\n\n ReadPDBFile (pdb_path, db_path)\t#","def read_file(self):\n colspecs = [[0, 7]] # for the id\n names = ['id']\n for question in self.question_list:\n colspecs.extend(question.get_column_range())\n names.extend(question.get_column_names())\n\n self.data = pd.read_fwf(self.file, colspecs=colspecs, encoding=self.encoding, names=names, header=None)\n self.data.fillna(0, inplace=True)\n self.data = self.data.astype(int)\n return self.data","def _read_input_file(self):\n pass","def readdatabase2(self):\n fname=\"/home/alice/rl/v/vme/ADCI/DB/INPUTS.txt\"\n try:\n database=open(fname,\"r\") \n except IOError:\n print \"Cannot open \",fname\n return None\n else:\n print \"File \",fname,\" open successfuly.\"\n #print \"database= \",database\n lines=database.readlines()\n database.close() \n #print lines,len(lines) \n dbinputs=[]\n for i in lines:\n if(i[0] != '#'):\n items=string.split(i)\n #print 'items= ',items,len(items)\n if(len(items)<6):\n print \"Error parsing database, not enough items in line:\"\n print items\n return None\n db={}\n db['number']=items[0]\n db['numberDIM']=items[1]\n db['level']=items[2]\n db['name']=items[3]\n db['detector']=items[4]\n db['signature']=items[5]\n dbinputs.append(db)\n return dbinputs","def read_database(db_path, db_file, *args):\n\n db_filepath = os.path.join(db_path, db_file)\n\n # list to store loaded data\n data_imported = []\n conn = sqlite3.connect(db_filepath)\n\n for data_name in args:\n\n\n info = f'Reading {data_name} from database................'\n print(info, end=\"\")\n data_name_in_db = conn.execute(\n f\"\"\"SELECT name FROM sqlite_master WHERE type='table' \n AND name='{data_name}'; \"\"\").fetchall()\n if data_name_in_db:\n df = pd.read_sql(f\"select * from {data_name}\", con=conn)\n substitute_names(df)\n # revert single column DataFrame to Series\n if 'index' in df.columns:\n df.set_index('index', inplace=True)\n df = df.squeeze('columns')\n data_imported.append(df)\n print('ok')\n else:\n data_imported.append(None)\n print('no data')\n conn.close()\n return data_imported #if len(data_imported)>1 else data_imported[0]","def loadSQL_beddays(filepath='O:\\Administration\\\\02 - Økonomi og PDK\\Medarbejdermapper\\Kasper\\Focus1 - Ad hoc opgaver\\Lungemed sengedage og visitationer\\Lungemed.sql'):\n content = open(filepath, 'r').read()\n return content","def read():\n with open(DBNAME) as f:\n foo = pickle.loads(f.read())\n print foo","def loadDatabase ():\n database = []\n # Open a file\n path = \"lyd/\"\n dirs = os.listdir( path )\n \n # This prints all of the files and directories\n for file in dirs:\n if file == \".DS_Store\": #Mac file\n continue\n songdict = {}\n print (file)\n Zxx = STFTsignal.getSTFTofFile(path + file) #STFT of the file\n #mean, eigen and weights are stored in dictionary songdict\n songdict[\"mean\"], songdict[\"eigen\"], songdict[\"weights\"] = PCA(Zxx)\n songdict[\"name\"] = file\n database.append (songdict) \n return database","def readFromFile(self, inp):\n f = open(inp, \"r\")\n line = f.readline()\n line = line.strip().split(sep=\" \", maxsplit=3)\n self.columns, self.chars, self.pwdLength, _ = line\n self.columns = int(self.columns)\n self.pwdLength = int(self.pwdLength)\n self.func = lmdes\n line = f.readline()\n while line != '':\n pwd, hashV = line.strip().split(sep=\" \", maxsplit=1)\n self.table.insert(hashV, pwd)\n line = f.readline()\n f.close()","def _load_ludb(self, path):\n signal, info = wfdb.rdsamp(path)\n self.fs = 500\n self.lead_match = ['I', 'II', 'III', 'aVR', 'aVL', 'aVF', 'V1', 'V2', 'V3', 'V4', 'V5', 'V6']\n self.raw_data = np.transpose(np.array([signal]), (2, 0, 1))\n self.symbol = []\n self.coords = []\n for lead in ['i', 'ii', 'iii', 'avr', 'avl', 'avf', 'v1', 'v2', 'v3', 'v4', 'v5', 'v6']:\n ann_ii = wfdb.rdann(path, extension='atr_{}'.format(lead))\n symbol_1 = ann_ii.symbol\n coords_1 = ann_ii.sample\n if list(np.unique(np.array(symbol_1))) != ['(', ')', 'N', 'p', 't'] and list(np.unique(np.array(symbol_1))) != ['(', ')', 'N', 'p', 't', 'u']:\n print(\"Invalid symbols in ECG annotations.\")\n raise ValueError\n self.symbol.append(symbol_1)\n self.coords.append(coords_1)\n self.label_name = ['(', 'p', ')', '(', 'N', ')', '(', 't', ')']\n self._generate_beatlabel_from_label()","def loadDB(self,dbfilename):\n \n db=[]\n with open(dbfilename,'r',encoding='ISO-8859-1') as dbfilename:\n dbreader= csv.reader(dbfilename,delimiter=self.sDelimiter )\n for lFields in dbreader:\n db.append(lFields)\n\n return db","def _read_pkl(self, input_file):\n data = pickle.load(open(input_file, 'rb'))\n return data","def read_data(cls, input_file,quotechar = None):\n if 'pkl' in str(input_file):\n lines = load_pickle(input_file)\n else:\n lines = input_file\n return lines","def read(filename: str) -> orm.Data:\n return from_bands_inspect(load(hdf5_file=filename))","def read_pfeatures(namefile):\n db = shelve.open(namefile)\n hashes = db['hashes']\n nif = db['nif']\n year = db['year']\n pfeatures = db['pfeatures']\n methodvalues = db['methodvalues']\n db.close()\n return hashes, nif, year, pfeatures, methodvalues","def _load_file(self):\n getLogger(__name__).debug(\"Loading {} in {} mode.\".format(self.filename, self.mode))\n try:\n kwargs = {'driver': 'H5FD_CORE'} if self.in_memory else {}\n self.file = tables.open_file(self.filename, mode='a' if self.mode == 'write' else 'r', **kwargs)\n except (IOError, OSError):\n raise\n\n # get important cal params\n self.nominal_wavelength_bins = self.nyquist_wavelengths()\n\n # get the beam image\n self.beamImage = self.file.get_node('/beammap/map').read()\n self._flagArray = self.file.get_node('/beammap/flag') # The absence of .read() here is correct\n self.nXPix, self.nYPix = self.beamImage.shape\n\n # get the photontable\n self.photonTable = self.file.get_node('/photons/photontable')","def read_opsim_db(opsim_db_path='/global/projecta/projectdirs/lsst/groups/SSim/DC2/minion_1016_desc_dithered_v4.db'):\n conn = sqlite3.connect(opsim_db_path)\n # Check the table names\n cursor = conn.cursor()\n cursor.execute(\"SELECT name FROM sqlite_master WHERE type='table';\")\n table_names = cursor.fetchall()\n print(table_names)\n # Turn table into Pandas df\n obs_history = pd.read_sql(sql=\"SELECT * from ObsHistory\", con=conn, index_col=None)\n field = pd.read_sql(sql=\"SELECT * from Field\", con=conn, index_col=None)\n return obs_history, field","def read_ppdb(fname):\n\tlst=[]\n\twith open(fname) as fp:\n\t\tfor line in fp:\n\t\t\ttmp1,tmp2,tmp3=line.split('|||')[:3]\n\t\t\ttmp1=tmp1.strip(' ')\n\t\t\ttmp2=tmp2.strip(' ')\n\t\t\ttmp3=tmp3.strip(' ')\n\t\t\tlst.append([tmp1,tmp2,tmp3])\n\t#lst.sort()t\n\treturn lst","def load_file():\n global list_of_table, data_base, new_data\n open_name = askopenfilename()\n\n if Path(open_name).suffix == '.db':\n data_base = open_name\n data_base = str(data_base)\n new_data_base = parse(data_base)\n new_data = update_list_tables(new_data_base)\n new_data.clear()\n\n else:\n mistake_db_file()","def read_database(self):\n # open the database\n f = open('KISS_LINES','r')\n # make a list which will contain lines\n tlc = []\n for row in f:\n tlc.append(f.readline())\n f.close()\n\n return tlc","def readLBOMDIN(self):\n logger = logging.getLogger(__name__)\n\n if os.path.exists(\"lbomd.IN\"):\n f = open(\"lbomd.IN\")\n\n try:\n f.readline()\n f.readline()\n f.readline()\n f.readline()\n\n line = f.readline().strip()\n array = line.split()\n try:\n PBC = [0] * 3\n PBC[0] = int(array[0])\n PBC[1] = int(array[1])\n PBC[2] = int(array[2])\n\n except IndexError:\n logger.warning(\"Index error 2 (check lbomd.IN format)\")\n\n except Exception:\n err = \"Read lbomd.IN failed with error:\\n\\n%s\" % \"\".join(traceback.format_exception(*sys.exc_info()))\n self.displayError(err)\n\n finally:\n f.close()","def Read_Palik_Al2O3_d():\n fid = open('/Users/simonvassant/TheseSave/PaliK_Opticalconstant/Al2O3_B_Palik.dat','r')\n L,eps = [],[]\n while 1: \n line = fid.readline()\n if line =='': \n break \n else :\n L.append(float(line[18:25]))\n eps.append((float(line[74:81])+1j*float(line[82:]))**2)\n return np.array(L),np.array(eps)","def read_input_file(file_name):\n with open(file_name, 'r') as file_handle:\n\n rows, cols, drones, turns, max_payload = map(int, file_handle.readline().strip().split(' '))\n num_prod_types = int(file_handle.readline())\n\n product_weights = map(int, file_handle.readline().strip().split(' '))\n assert num_prod_types == len(product_weights)\n\n num_warehouses = int(file_handle.readline())\n warehouse_locations = [None] * num_warehouses\n warehouse_stock = [None] * num_warehouses\n for w_id in xrange(num_warehouses):\n warehouse_locations[w_id] = map(int, file_handle.readline().strip().split(' '))\n warehouse_stock[w_id] = map(int, file_handle.readline().strip().split(' '))\n\n if DEBUG:\n print 'Warehouse locations', warehouse_locations[:2]\n print 'Warehouse stock', warehouse_stock[:2]\n\n num_orders = int(file_handle.readline())\n order_locations = [None] * num_orders\n order_items = [None] * num_orders\n for o_id in xrange(num_orders):\n order_locations[o_id] = map(int, file_handle.readline().strip().split(' '))\n order_len = int(file_handle.readline())\n order_items[o_id] = map(int, file_handle.readline().strip().split(' '))\n assert order_len == len(order_items[o_id])\n\n if DEBUG:\n print 'Order locations', order_locations[:2]\n print 'Order items', order_items[:2]\n\n file_handle.close()\n\n return (rows, cols), \\\n drones, turns, max_payload, \\\n warehouse_locations, warehouse_stock, \\\n order_locations, order_items, product_weights","def open_input_files(self):\n self.dictionaryFile = open(self.dictionaryFile, 'r', encoding=self.encoding)\n\n if self.annotationFile :\n self.annotationFile = open(self.annotationFile, 'r', encoding=self.encoding)\n elif self.annotationFile is None:\n try:\n self.annotationFile = open(os.path.join(self.dictionaryPath, self.dictionaryName + '.ann'), 'r', encoding=self.encoding)\n except FileNotFoundError:\n if self.verbose >= 2:\n sys.stdout.write (\"Warning: annotation file is not found.\\n\")\n\n if self.abbreviationsFile :\n self.abbreviationsFile = open(self.abbreviationsFile, 'r', encoding=self.encoding)\n elif self.abbreviationsFile is None:\n try:\n self.abbreviationsFile = open(os.path.join(self.dictionaryPath, self.dictionaryName + '_abrv.dsl'), 'r', encoding=self.encoding)\n except FileNotFoundError:\n if self.verbose >= 2:\n sys.stdout.write (\"Warning: abbreviations file is not found.\\n\")","def read_df_from_binary(file_name_mask):\n data = read_matrix_from_binary(file_name_mask + '-value.bin')\n with open(file_name_mask + '-name.txt', 'r') as f:\n index = f.readline().strip().split('\\t')\n columns = f.readline().strip().split('\\t')\n return pandas.DataFrame(data=data, index=index, columns=columns)","def read_db(self):\n with open(self.filename, 'r') as database:\n data = json.load(database)\n self.data = data","def readMAXIPOLdataLuis(filename):\n\n ia=[]; ja=[]\n i=[]; j=[]; beam=[]; sig=[]; cts=[]\n for line in open(filename, \"r\"):\n line = line.strip().split()\n i1, j1, b1, s1, c1 = (int(line[0]), int(line[1]), \n float(line[2]), float(line[3]), int(line[4]))\n ia.append(i1); ja.append(j1)\n if b1 != 0 and s1 !=0:\n ## only keep pixels with data\n i.append(i1); j.append(j1); beam.append(b1)\n sig.append(s1); cts.append(c1)\n\n beam = asarray(beam, float64)\n sig = asarray(sig, float64)\n ## map i and j (before deletion) onto (-1,1)\n x = array([2*(ii-min(ia))/(max(ia)-min(ia))-1 for ii in i], float64)\n y = array([2*(jj-min(ja))/(max(ja)-min(ja))-1 for jj in j], float64)\n\n return BeamData(x, y, beam, sig, cts=cts)","def readDataFromFile(self):\n #import pdb; pdb.set_trace()\n if self.wantAnyDbm:\n try:\n if os.path.exists(self.filepath):\n self.data = anydbm.open(self.filepath,'w')\n self.notify.debug('Opening existing anydbm database at: %s.' % \\\n (self.filepath,))\n else:\n self.data = anydbm.open(self.filepath,'c')\n self.notify.debug('Creating new anydbm database at: %s.' % \\\n (self.filepath,))\n except anydbm.error:\n self.notify.warning('Cannot open anydbm database at: %s.' % \\\n (self.filepath,))\n \n else:\n try:\n # Try to open the backup file:\n file = open(self.filepath + '.bu', 'r')\n self.notify.debug('Opening backup pickle data file at %s.' % \\\n (self.filepath+'.bu',))\n # Remove the (assumed) broken file:\n if os.path.exists(self.filepath):\n os.remove(self.filepath)\n except IOError:\n # OK, there's no backup file, good.\n try:\n # Open the real file:\n file = open(self.filepath, 'r')\n self.notify.debug('Opening old pickle data file at %s..' % \\\n (self.filepath,))\n except IOError:\n # OK, there's no file.\n file = None\n self.notify.debug('New pickle data file will be written to %s.' % \\\n (self.filepath,))\n if file:\n data = cPickle.load(file)\n file.close()\n self.data = data\n else:\n self.data = {}","def load(self, input):","def testReadDataFile(self):\n try:\n blockNameList = []\n myReader = ParseCifSimple(self.__pathPdbxDataFile, False, 0, 255, \"?\", self.__logFileName)\n blockNameList = myReader.GetBlockNames(blockNameList)\n #\n for blockName in blockNameList:\n block = myReader.GetBlock(blockName)\n tableNameList = []\n tableNameList = block.GetTableNames(tableNameList)\n for tableName in tableNameList:\n table = block.GetTable(tableName)\n columnNameList = table.GetColumnNames()\n logger.debug(\"Table %s colunms %r\", tableName, columnNameList)\n numRows = table.GetNumRows()\n rowList = []\n for iRow in range(0, numRows):\n row = table.GetRow(iRow)\n rowList.append(row)\n logger.debug(\"table %s row length %d\", tableName, len(rowList))\n except Exception as e:\n logger.exception(\"Failing with %s\", str(e))\n self.fail()","def Read_Al_Palik():\n fid = open('/Volumes/Stock/PostDoc_Erlangen/DocMatos/Materials_Data_Base/Al_from_Palik.dat','r')\n L,eps = [],[]\n while 1: \n line = fid.readline()\n if line =='': \n break \n else :\n L.append(float(line[:25]))\n eps.append(float(line[27:54])+1j*float(line[55:-2]))\n return np.array(L),np.array(eps)","def _read_data(self) -> MMD:\n\t\tif self.config.source_type == SourceType.LOCAL_FILE:\n\t\t\treturn self._read_files()\n\t\telif self.config.source_type == SourceType.HDFS:\n\t\t\treturn self._read_hdfs()\n\t\telif self.config.source_type == SourceType.NEO4J:\n\t\t\treturn self._read_neo4j(self.config.graph_db)\n\n\t\telse:\n\t\t\traise NotImplementedError(\"The source type {} has not been implemented yet.\".format(loader_config.source_type))","def loadDb(self,dbContent,base):\n \n db = utilities.db2bitarray(dbContent,self.dbSize,1,1,base)\n db = np.array(db).reshape(self.dbSize,-1)\n # track the size of each file\n fileSize = db.shape[-1]\n \n return (db,fileSize)","def input_data(self):\n return read_file(self.file_path)","def Read_Palik_Al2O3_b():\n fid = open('/Users/simonvassant/TheseSave/PaliK_Opticalconstant/Al2O3_B_Palik.dat','r')\n L,eps = [],[]\n while 1: \n line = fid.readline()\n if line =='': \n break \n else :\n L.append(float(line[18:25]))\n eps.append((float(line[59:65])+1j*float(line[66:73]))**2)\n return np.array(L),np.array(eps)","def readFastaFile(filename):","def readInput(in_file_name):\n in_file = open(in_file_name, 'r')\n positions = []\n samples = []\n M = []; P = [];\n MC = []; PC = [];\n while True:\n line = in_file.readline()\n if not line: break\n if line[0] == '#': continue #skip comment\n line = line.rstrip('\\n').split('\\t')\n \n #genomic positions and allele support in plasma samples\n positions.append(int(line[0]))\n samples.append(tuple(map(int, line[1:5])))\n \n #maternal and paternal alleles\n M.append(tuple(line[5:7]))\n MC.append(tuple(map(float, line[7:9])))\n \n P.append(tuple(line[9:11]))\n PC.append(tuple(map(float, line[11:13]))) \n \n in_file.close()\n return positions, samples, M, P, MC, PC","def update_db(db_name=_db_indicators, start=1950, end=dt.datetime.now().year, write_db=True):\n def read_indicators(pdfI=None, coutries=[], ctry_chunksize=50, write_db=True):\n print('UPDATE IMF: Start reading {0} indicators'.format(pdfI.shape[0]))\n #dct_not_data=dict()\n lst_ret=[]\n for k, v in pdfI.iterrows():\n\n lst_pdf=list()\n lst_not_country=list()\n tbl_name=k #'{0}_{1}'.format(k, freq)\n print('UPDATE IMF ({2}-{3}): reading {0}, tDS={1}\\t'.format(k, v['Dataset'], start, end), end='... ')\n for cs in cmm.iterate_group(coutries, ctry_chunksize):\n\n try:\n pdf = pds.read_imf(strDataSetID=v['Dataset'], indiID=k, countryCode=cs,\n frequency=v['Freq'], startDate=start, endDate=end)\n\n lst_pdf.append(pdf)\n lst_not_country+=pdf.not_country\n #print(pdf.name, pdf.shape, len(pdf.not_country))\n except ValueError as e:\n lst_not_country += cs\n\n #print(e, k, 0, 50)\n try:\n pdfC=pds.DataFrameDATA(pd.concat([ppdf for ppdf in lst_pdf if not ppdf.empty]))\n pdfC.name=tbl_name\n #dct_not_data.update({'IND_NOT':tbl_name, 'NOT_DATA':lst_not_country})\n print('read {name},\\tlen {len_df},\\tnot data countries - {nc}'.format(name=pdfC.name,\n len_df=pdfC.shape[0],\n nc=len(lst_not_country)), end='... ')\n if write_db:\n print('write to DB...', end='')\n\n lstWrite=[c for c in pdfC.columns.tolist() if c !='mult']\n\n pdfC[lstWrite].to_sql(pdfC.name, coni, if_exists='upsert')\n cmm.write_status(db_name, k, pdfC.shape[0], mult=pdfC['mult'].unique()[0])\n\n print('done', end='\\n')\n pdfC['INDI']=k\n lst_ret.append(pdfC)\n #print(dct_not_data)\n except ValueError as e:\n print(e, 'not data for ', k, v['Dataset'], len(cs))\n\n return pd.concat(lst_ret)\n\n coni = sa.create_engine('sqlite+pysqlite:///{db_name}'.format(db_name=db_name))\n # pdfIndi=pd.read_sql('select * from INDICATORS where LastUpdateDateA is NULL', coni, index_col='Code')\n pdfIndi = pd.read_sql('select * from {INDI_NAME}'.format(INDI_NAME=cmm.strINDI_db_name), coni, index_col='Code')#.iloc[:40]\n pdfCountry = pd.read_sql('select * from {COUNTRY_NAME}'.format(COUNTRY_NAME=cmm.strCOUNTRY_db_name), coni, index_col='id')\n country_list = pdfCountry.index.tolist()\n print('UPDATE IMF: reading {0} countries'.format(len(country_list)))\n\n pdfQ=read_indicators(pdfI=pdfIndi.sort_index(), coutries=country_list, write_db=write_db)\n print('=' * 50)\n\n print('UPDATE IMF: all done')\n return pdfQ","def read_data(cls, input_file, quotechar=None):\r\n if 'pkl' in str(input_file):\r\n lines = load_pickle(input_file)\r\n else:\r\n lines = input_file\r\n return lines","def read_syn_data():\n dipy_home = pjoin(os.path.expanduser('~'), '.dipy')\n folder = pjoin(dipy_home, 'syn_test')\n t1_name = pjoin(folder, 't1.nii.gz')\n b0_name = pjoin(folder, 'b0.nii.gz')\n\n md5_dict = {'t1': '701bda02bb769655c7d4a9b1df2b73a6',\n 'b0': 'e4b741f0c77b6039e67abb2885c97a78'}\n\n check_md5(t1_name, md5_dict['t1'])\n check_md5(b0_name, md5_dict['b0'])\n\n t1 = nib.load(t1_name)\n b0 = nib.load(b0_name)\n return t1, b0","def _read(self):\n # initializng data dictionary\n self.data={}\n\n f = FortranFile(self.filename)\n # Default omnivor binary header\n self.data['MK'] = f.readInts('i')\n self.data['itime'] = f.readInts('i')\n self.data['version'] = f.readString()\n self.data['file_id'] = f.readInts('i')\n self.data['sversion'] = f.readString()\n # Velocity field\n self.data['stype'] = f.readString()\n self.data['is_grid'] = f.readInts('i')\n nCPs = f.readInts('i')\n self.data['nCPs'] = nCPs\n if self.data['MK'] == 8:\n real_char='d'\n else:\n real_char='f'\n if self.data['is_grid']:\n #print('File is a velocity grid file')\n n1 = f.readInts('i')\n n2 = f.readInts('i')\n n3 = f.readInts('i')\n self.data['n1'] = n1\n self.data['n2'] = n2\n self.data['n3'] = n3\n self.data['is_straight'] = f.readInts('i')\n self.data['v1'] = f.readReals(real_char)\n self.data['v2'] = f.readReals(real_char)\n self.data['v3'] = f.readReals(real_char)\n\n CPs_raw = f.readReals(real_char)\n Utot_raw = f.readReals(real_char)\n CPs = np.reshape(CPs_raw,(3,nCPs),order = 'F')\n Utot = np.reshape(Utot_raw,(3,nCPs),order = 'F')\n\n acc=-1\n CPsTab = np.zeros((3, n1,n2,n3))\n UtotTab = np.zeros((3, n1,n2,n3))\n # Reshaping the nasty way (this is natural order). \n for i in range(0,n1):\n for j in range(0,n2):\n for k in range(0,n3):\n acc=acc+1\n CPsTab[0:3,i,j,k] = CPs[0:3,acc]\n UtotTab[0:3,i,j,k] = Utot[0:3,acc]\n\n self.data['CPs'] = CPs\n self.data['CPsTab'] = CPsTab\n self.data['Utot'] = Utot\n self.data['UtotTab'] = UtotTab","def read():\n # TODO","def _read_dataset(self):\n import pandas as pd\n\n freesolv_path = get_data_file_path(FREESOLV_PATH)\n\n freesolv_db = pd.read_csv(freesolv_path, delimiter=';',\n skipinitialspace=True,\n skiprows=[0, 1, 2], header=0,\n names=['compound id', 'SMILES',\n 'iupac name',\n 'experimental value',\n 'experimental uncertainty',\n 'calculated value (GAFF)',\n 'calculated uncertainty',\n 'experimental reference',\n 'calculated reference',\n 'notes'])\n\n compound_ids = freesolv_db['compound id'].to_list()\n smiles_tags = freesolv_db['SMILES'].to_list()\n experimental_v = freesolv_db['experimental value'].to_list()\n return compound_ids, smiles_tags, experimental_v","def read_pdb_into_database_flat(self, filePath, specific_chain=False, read_header=False, header_only=False, ):\n if filePath == \"PDB\":\n print \"Fetching \"+self.pdbID+\" from the PDB\"\n FILE = urllib2.urlopen(self.pdb_url+'/'+self.pdbID.lower()+'.pdb')\n else:\n FILE = open(filePath)\n line_num = 1\n with self.db:\n cur = self.db.cursor()\n\n l = 1\n if read_header:\n cur.execute(\"CREATE TABLE IF NOT EXISTS header(id integer PRIMARY KEY, pdbID TEXT, modelID TEXT, method TEXT, resolution REAL, species TEXT, engineered TEXT, protein TEXT)\")\n if not header_only:\n cur.execute(\"CREATE TABLE IF NOT EXISTS pdb(l integer PRIMARY KEY, pdbID TEXT, modelID TEXT, strucID INT, type TEXT, atomNum INT, atomName TEXT, altLoc TEXT, residue TEXT, chain TEXT, resNum INT, icode TEXT, x REAL, y REAL, z REAL, occupancy REAL, bfactor REAL)\")\n print \"Tables created. Loading \"+self.pdbID+\" data into table.\"\n for line in FILE:\n line = line.strip()\n lineSP = line.split()\n if not header_only:\n if (lineSP[0]==\"ATOM\" or lineSP[0]==\"HETATM\"):\n\n #Only copy a specific chain into the database.\n if not specific_chain:\n pass\n else:\n if specific_chain != line[21].strip():\n continue\n\n\n cur.execute(\"INSERT INTO pdb VALUES(NULL, ?, ?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)\", \\\n (self.pdbID, self.modelID, self.structID, lineSP[0], \\\n\n\n #atomNum INT atomName TEXT altLoc TEXT residue TEXT\n line[6:11].strip(), line[12:16], line[16], line[17:21].strip(), \\\n #chain TEXT resNum INT icode TEXT x REAL\n line[21].strip(), line[22:26].strip(), line[26], line[27:38].strip(), \\\n #y REAL z REAL occupancy REAL bfactor REAL\n line[38:46].strip(), line[46:54].strip(), line[54:60].strip(), line[60:66].strip()))\n l+=1\n\n\n\n #self.stripped_pdb[line_num][\"element\"]=line[66:78].strip(); self.stripped_pdb[line_num][\"charge\"]=line[78:79].strip())","def schema_load(filename):\n print(uc.schema_load(filename))","def __init__(self):\n f = open(configuration.dataDirectory+'Muon_ID_iso_Efficiencies_Run_2012ABCD_53X.pkl', 'r')\n if f :\n self._map = pickle.load(f)\n self._range = ''\n else :\n print 'ERROR: Input file for muon SF not existing!'","def read_all_odbsql_stn_withfeedback(dataset, odbfile):\n columns, kinds, tdict = make_odb_header(odbfile, dataset) \n try: \n t=time.time() \n try:\n f=gzip.open(odbfile) \n except:\n print(odbfile, 'The zipped ODB file was not found !')\n return\n \n #d=['date@hdr','time@hdr','statid@hdr','vertco_reference_1@body','varno@body','reportype','andate','antime',\n # 'obsvalue@body','fg_depar@body','an_depar@body','biascorr@body','sonde_type@conv','collection_identifier@conv','source@hdr']\n \n # had to remove 'collection_identifier@conv' to make it work with 1, 3188, 1759, 1761 \n \n tdict['sensor@hdr']=numpy.float32\n tdict['ppcode@conv_body']=numpy.float32\n \n '''\n d=['date@hdr','time@hdr','statid@hdr','vertco_reference_1@body','varno@body','lon@hdr','lat@hdr','seqno@hdr',\n 'obsvalue@body','source@hdr' , 'vertco_type@body']\n \n if 'fg_depar@body' in columns: # creating the colkumns for era5fb \n d=d+['fg_depar@body','an_depar@body','biascorr@body','sonde_type@conv','reportype','andate','antime']\n '''\n \n# restrict feedback to certain columns \n #for c in columns:\n # if c not in d:\n # del tdict[c]\n \n #columns=d.copy()\n \n alldict=pd.read_csv(f,delimiter='\\t', usecols=columns, quoting=3,comment='#', skipinitialspace=True, dtype=tdict) #nrows=1000000)\n \n \"\"\" Case where erafb is not available \"\"\"\n if 'fg_depar@body' not in columns:\n alldict['fg_depar@body']=numpy.float32(numpy.NaN)\n alldict['an_depar@body']=numpy.float32(numpy.NaN)\n alldict['biascorr@body']=numpy.float32(numpy.NaN)\n alldict['sondetype@conv']=numpy.int32(-2147483648)\n alldict['reportype']=numpy.int32(-2147483648)\n \n #print(time.time()-t,sys.getsizeof(alldict)//1024//1024)\n idx=numpy.where(numpy.logical_or(alldict.reportype.values==16045,alldict.reportype.values==16068))[0]\n if len(idx)>0:\n \n #alldict.drop(index=alldict.index[idx],inplace=True)\n y=numpy.int64(alldict['date@hdr'].values)*1000000+alldict['time@hdr'].values\n x=numpy.unique(y)\n dropindex=[]\n for i in range(1,x.shape[0]):\n if x[i]-x[i-1]<60:\n idx=numpy.where(y==x[i-1])[0]\n if idx.shape[0]>0:\n dropindex.append(idx)\n else:\n print('empty index')\n if dropindex: \n dropindex = numpy.concatenate(dropindex).ravel()\n alldict.drop(index=alldict.index[dropindex],inplace=True)\n \n #print(time.time()-t) #,sys.getsizeof(alldict)//1024//1024)\n \n #idx=numpy.where(alldict.reportype.values==16045)[0]\n #if idx.shape[0]>0:\n #idy=numpy.where(numpy.logical_and(alldict.reportype.values!=16045,alldict.reportype.values!=16068))[0]\n #if idy.shape[0]>0:\n #idz=numpy.isin(alldict.andate.values[idy],alldict.andate.values[idx])\n #if numpy.sum(idz)>0:\n #alldict.drop(index=alldict.index[idy[idz]],inplace=True)\n \n #idx=numpy.where(alldict.reportype.values==16068)[0]\n #if idx.shape[0]>0:\n #idy=numpy.where(numpy.logical_and(alldict.reportype.values!=16045,alldict.reportype.values!=16068))[0]\n #if idy.shape[0]>0:\n #idz=numpy.isin(alldict.andate.values[idy],alldict.andate.values[idx])\n #if numpy.sum(idz)>0:\n #alldict.drop(index=alldict.index[idy[idz]],inplace=True)\n \n \n #print(time.time()-t,sys.getsizeof(alldict)//1024//1024)\n \n alldict['source_id'] = dataset.rjust(10)\n\n for c in alldict.columns:\n \n if type(alldict[c].iloc[0]) in [str,bytes]:\n l=alldict[c].shape[0]\n slen=len(alldict[c].values[0])\n alldict[c]=numpy.array(alldict.pop(c).values,dtype='S{}'.format(slen))\n #alldict[c]=numpy.string_(alldict[c])\n \n if type(alldict[c].iloc[0]) is numpy.int64:\n alldict[c]=numpy.int32(alldict[c])\n \n if type(alldict[c].iloc[0]) is numpy.float64:\n alldict[c]=numpy.float32(alldict[c])\n \n #print('after odb:',time.time()-t)\n \n except MemoryError:\n print('Reading ODB failed ! ' + odbfile)\n return alldict\n \n #print(odbfile,time.time()-t)#, sys.getsizeof(alldict))\n\n \n return alldict","def read_file(path_to_file):\n 8","def load_inputs():\n\n print \"Daily inputs\"\n\n Daily_Input.query.delete()\n\n\n for row in open(\"seed_data/u.input.txt\"):\n row = row.rstrip()\n input_id, date, user_id, sleep, exercise, screen_time, well_being_rating = row.split(\"|\")\n\n date = datetime.strptime(date, \"%m-%d-%y\")\n \n daily_input = Daily_Input(input_id=input_id, date=date, user_id=user_id, sleep=sleep, exercise=exercise, screen_time=screen_time, well_being_rating=well_being_rating)\n db.session.add(daily_input)\n\n db.session.commit()","def _read_data(self):","def import_db(import_file):\n import_data(import_file)","def db(filename = 'P51-11'):\n import pdb\n sys.argv[1:] = ['-v', filename]\n pdb.run('extract.main()')","def test_readfile(self):\n fname = os.path.join(self.datadir, 'monol_testA_E3-50_rebin4_gti') + \\\n HEN_FILE_EXTENSION\n command = \"{0}\".format(fname)\n\n hen.io.main(command.split())","def read_db():\n\n # Look for database in the same folder as this script\n script_dir = os.path.dirname(os.path.realpath(__file__))\n db_filepath = os.path.join(script_dir, 'cn_loads_database.dat')\n\n db = None\n if os.path.isfile(db_filepath):\n with open(db_filepath, 'r') as f:\n db = yaml.load(f.read())\n if db == None:\n db = dict()\n else:\n db = dict()\n\n return db","def Read_Palik_Al2O3_a():\n fid = open('/Users/simonvassant/TheseSave/PaliK_Opticalconstant/Al2O3_B_Palik.dat','r')\n L,eps = [],[]\n while 1: \n line = fid.readline()\n if line =='': \n break \n else :\n L.append(float(line[18:25]))\n eps.append((float(line[26:34])+1j*float(line[35:40]))**2)\n return np.array(L),np.array(eps)","def read_data(feature_file, label_file):","def get_demand_data():\r\n with open(\"{}DEMAND.txt\".format(db_folder_path), \"r\", encoding=\"utf8\") as demand_file:\r\n return eval(demand_file.read(), {'__builtins__':None}, {})","def read_password_db(fname='input.txt'):\n with open(fname) as fp:\n matches = [regex.match(line) for line in fp.readlines()]\n \n passwords = [{\n 'num_1': int(m.group(1)),\n 'num_2': int(m.group(2)),\n 'character': m.group(3),\n 'password': m.group(4)\n } for m in matches]\n \n return passwords","def open_input(self):\n gdal.SetConfigOption(\"GDAL_PAM_ENABLED\", \"YES\")\n gdal.AllRegister()\n # self.options.verbose=True\n if self.options.tms_osm:\n self.s_y_type=\"osm\"\n else:\n self.s_y_type=\"tms\"\n if self.options.verbose:\n print \"open_input :\", self.input,\" osm[\",self.options.tms_osm,\",\",self.s_y_type,\"] mbtiles[\",self.options.mbtiles,\"] mbtiles_todisk[\",self.options.mbtiles_todisk,\"] mbtiles_fromdisk[\",self.options.mbtiles_fromdisk,\"]\";\n # Open the input file\n if self.input:\n self.in_ds = gdal.Open(self.input, gdal.GA_ReadOnly)\n else:\n raise Exception(\"No input file was specified\")\n\n if self.options.verbose:\n print \"Input file:\", \"( %sP x %sL - %s bands)\" % (self.in_ds.RasterXSize, self.in_ds.RasterYSize, self.in_ds.RasterCount)\n\n if not self.in_ds:\n # Note: GDAL prints the ERROR message too\n self.error(\"It is not possible to open the input file '%s'.\" % self.input )\n\n # Read metadata from the input file\n if self.in_ds.RasterCount == 0:\n self.error( \"Input file '%s' has no raster band\" % self.input )\n\n if self.in_ds.GetRasterBand(1).GetRasterColorTable():\n # TODO: Process directly paletted dataset by generating VRT in memory\n self.error( \"Please convert this file to RGB/RGBA and run gdal2mbtiles on the result.\",\n \"\"\"From paletted file you can create RGBA file (temp.vrt) by:\ngdal_translate -of vrt -expand rgba %s temp.vrt\nthen run:\ngdal2mbtiles temp.vrt\"\"\" % self.input )\n\n # Get NODATA value\n # User supplied values overwrite everything else.\n if self.options.srcnodata is not None:\n nds = map(float, self.options.srcnodata.split(','))\n if len(nds) < self.in_ds.RasterCount:\n self.in_nodata = (nds * self.in_ds.RasterCount)[:self.in_ds.RasterCount]\n else:\n self.in_nodata = nds\n else:\n # If the source dataset has NODATA, use it.\n self.in_nodata = []\n for i in range(1, self.in_ds.RasterCount+1):\n if self.in_ds.GetRasterBand(i).GetNoDataValue() != None:\n self.in_nodata.append( self.in_ds.GetRasterBand(i).GetNoDataValue() )\n\n if self.options.verbose:\n print \"NODATA: %s\" % self.in_nodata\n\n # INIT DEST\n if self.options.init_dest is not None:\n if self.options.tile_format == \"jpeg\":\n if self.in_ds.RasterCount == 4:\n nbands = 3\n else:\n nbands = self.in_ds.RasterCount\n\n nds = map(float, self.options.init_dest.split(','))\n\n if len(nds) == 1:\n init_dest = nds * nbands\n elif len(nds) == nbands:\n init_dest = nds\n else:\n print \"WARNING: you suplied %d '--init-dest' values but the dataset has %d data bands\" % (len(nds), nbands)\n init_dest = None\n else:\n init_dest = None\n print \"WARNING: --init-dest can be used only with 'jpeg' tile format\"\n else:\n if self.options.tile_format == \"jpeg\":\n init_dest = [255,255,255]\n else:\n init_dest = None\n\n #\n # Here we should have RGBA input dataset opened in self.in_ds\n #\n\n if self.options.verbose:\n print \"Preprocessed file:\", \"( %sP x %sL - %s bands)\" % (self.in_ds.RasterXSize, self.in_ds.RasterYSize, self.in_ds.RasterCount)\n\n # Spatial Reference System of the input raster\n\n\n self.in_srs = None\n\n if self.options.s_srs:\n self.in_srs = osr.SpatialReference()\n self.in_srs.SetFromUserInput(self.options.s_srs)\n self.in_srs_wkt = self.in_srs.ExportToWkt()\n else:\n self.in_srs_wkt = self.in_ds.GetProjection()\n if not self.in_srs_wkt and self.in_ds.GetGCPCount() != 0:\n self.in_srs_wkt = self.in_ds.GetGCPProjection()\n if self.in_srs_wkt:\n self.in_srs = osr.SpatialReference()\n self.in_srs.ImportFromWkt(self.in_srs_wkt)\n #elif self.options.profile != 'raster':\n # self.error(\"There is no spatial reference system info included in the input file.\",\"You should run gdal2mbtiles with --s_srs EPSG:XXXX or similar.\")\n\n # Spatial Reference System of tiles\n\n self.out_srs = osr.SpatialReference()\n\n if self.options.profile == 'mercator':\n self.out_srs.ImportFromEPSG(900913)\n elif self.options.profile in ('geodetic', 'gearth', 'garmin'):\n self.out_srs.ImportFromEPSG(4326)\n else:\n self.out_srs = self.in_srs\n\n # Are the reference systems the same? Reproject if necessary.\n\n self.out_ds = None\n\n if self.options.profile in ('mercator', 'geodetic', 'gearth', 'garmin'):\n\n if (self.in_ds.GetGeoTransform() == (0.0, 1.0, 0.0, 0.0, 0.0, 1.0)) and (self.in_ds.GetGCPCount() == 0):\n self.error(\"There is no georeference - neither affine transformation (worldfile) nor GCPs. You can generate only 'raster' profile tiles.\",\n \"Either gdal2mbtiles with parameter -p 'raster' or use another GIS software for georeference e.g. gdal_transform -gcp / -a_ullr / -a_srs\")\n\n if self.in_srs:\n\n if (self.in_srs.ExportToProj4() != self.out_srs.ExportToProj4()) or (self.in_ds.GetGCPCount() != 0):\n\n # Generation of VRT dataset in tile projection, default 'nearest neighbour' warping\n self.out_ds = gdal.AutoCreateWarpedVRT( self.in_ds, self.in_srs_wkt, self.out_srs.ExportToWkt() )\n\n # TODO: HIGH PRIORITY: Correction of AutoCreateWarpedVRT according the max zoomlevel for correct direct warping!!!\n\n if self.options.verbose:\n print \"Warping of the raster by AutoCreateWarpedVRT (result saved into 'tiles.vrt')\"\n self.out_ds.GetDriver().CreateCopy(\"tiles.vrt\", self.out_ds)\n\n # Note: self.in_srs and self.in_srs_wkt contain still the non-warped reference system!!!\n\n # Correction of AutoCreateWarpedVRT for NODATA values\n if self.in_nodata != []:\n import tempfile\n tempfilename = tempfile.mktemp('-gdal2mbtiles.vrt')\n self.out_ds.GetDriver().CreateCopy(tempfilename, self.out_ds)\n # open as a text file\n s = open(tempfilename).read()\n # Add the warping options\n s = s.replace(\"\"\"<GDALWarpOptions>\"\"\",\"\"\"<GDALWarpOptions>\n <Option name=\"UNIFIED_SRC_NODATA\">YES</Option>\n <Option name=\"INIT_DEST\">NO_DATA</Option>\"\"\")\n # replace BandMapping tag for NODATA bands....\n if init_dest is None:\n dstnodata = self.in_nodata\n else:\n dstnodata = init_dest\n for i in range(len(self.in_nodata)):\n s = s.replace(\"\"\"<BandMapping src=\"%i\" dst=\"%i\"/>\"\"\" % ((i+1),(i+1)),\"\"\"<BandMapping src=\"%i\" dst=\"%i\">\n <SrcNoDataReal>%i</SrcNoDataReal>\n <SrcNoDataImag>0</SrcNoDataImag>\n <DstNoDataReal>%i</DstNoDataReal>\n <DstNoDataImag>0</DstNoDataImag>\n </BandMapping>\"\"\" % ((i+1), (i+1), self.in_nodata[i], dstnodata[i]))\n # save the corrected VRT\n open(tempfilename,\"w\").write(s)\n # open by GDAL as self.out_ds\n self.out_ds = gdal.Open(tempfilename) #, gdal.GA_ReadOnly)\n # delete the temporary file\n os.unlink(tempfilename)\n\n # set NODATA_VALUE metadata\n self.out_ds.SetMetadataItem('NODATA_VALUES','%s' % \" \".join(str(int(f)) for f in self.in_nodata))\n\n if self.options.verbose:\n print \"Modified warping result saved into 'tiles1.vrt'\"\n open(\"tiles1.vrt\",\"w\").write(s)\n\n # -----------------------------------\n # Correction of AutoCreateWarpedVRT for Mono (1 band) and RGB (3 bands) files without NODATA:\n # equivalent of gdalwarp -dstalpha\n elif self.in_nodata == [] and self.out_ds.RasterCount in (1,3):\n import tempfile\n tempfilename = tempfile.mktemp('-gdal2mbtiles.vrt')\n self.out_ds.GetDriver().CreateCopy(tempfilename, self.out_ds)\n # open as a text file\n s = open(tempfilename).read()\n # Add the warping options\n s = s.replace(\"\"\"<BlockXSize>\"\"\",\"\"\"<VRTRasterBand dataType=\"Byte\" band=\"%i\" subClass=\"VRTWarpedRasterBand\">\n <ColorInterp>Alpha</ColorInterp>\n </VRTRasterBand>\n <BlockXSize>\"\"\" % (self.out_ds.RasterCount + 1))\n s = s.replace(\"\"\"</GDALWarpOptions>\"\"\", \"\"\"<DstAlphaBand>%i</DstAlphaBand>\n </GDALWarpOptions>\"\"\" % (self.out_ds.RasterCount + 1))\n if init_dest is None:\n init_dest_str = \"0\"\n else:\n init_dest_str = \",\".join(str(f) for f in init_dest)\n s = s.replace(\"\"\"</WorkingDataType>\"\"\", \"\"\"</WorkingDataType>\n <Option name=\"INIT_DEST\">%s</Option>\"\"\" % init_dest_str)\n # save the corrected VRT\n open(tempfilename,\"w\").write(s)\n # open by GDAL as self.out_ds\n self.out_ds = gdal.Open(tempfilename) #, gdal.GA_ReadOnly)\n # delete the temporary file\n os.unlink(tempfilename)\n\n if self.options.verbose:\n print \"Modified -dstalpha warping result saved into 'tiles1.vrt'\"\n open(\"tiles1.vrt\",\"w\").write(s)\n\n elif init_dest is not None:\n import tempfile\n tempfilename = tempfile.mktemp('-gdal2mbtiles.vrt')\n self.out_ds.GetDriver().CreateCopy(tempfilename, self.out_ds)\n # open as a text file\n s = open(tempfilename).read()\n # Add the warping options\n s = s.replace(\"\"\"</WorkingDataType>\"\"\", \"\"\"</WorkingDataType>\n <Option name=\"INIT_DEST\">%s</Option>\"\"\" % \",\".join(str(f) for f in init_dest))\n # save the corrected VRT\n open(tempfilename,\"w\").write(s)\n # open by GDAL as self.out_ds\n self.out_ds = gdal.Open(tempfilename) #, gdal.GA_ReadOnly)\n # delete the temporary file\n os.unlink(tempfilename)\n\n if self.options.verbose:\n print \"Modified warping result saved into 'tiles1.vrt'\"\n open(\"tiles1.vrt\",\"w\").write(s)\n\n # For raster with 4-bands: 4th unknown band set to alpha\n if (self.out_ds.RasterCount == 4\n and self.out_ds.GetRasterBand(4).GetRasterColorInterpretation() == gdal.GCI_Undefined):\n self.out_ds.GetRasterBand(4).SetRasterColorInterpretation(gdal.GCI_AlphaBand)\n\n s = '''\n '''\n\n else:\n self.error(\"Input file has unknown SRS.\", \"Use --s_srs ESPG:xyz (or similar) to provide source reference system.\" )\n\n if self.out_ds and self.options.verbose:\n print \"Projected file:\", \"tiles.vrt\", \"( %sP x %sL - %s bands)\" % (self.out_ds.RasterXSize, self.out_ds.RasterYSize, self.out_ds.RasterCount)\n\n if not self.out_ds:\n self.out_ds = self.in_ds\n\n #\n # Here we should have a raster (out_ds) in the correct Spatial Reference system\n #\n\n # KML test\n self.isepsg4326 = False\n srs4326 = osr.SpatialReference()\n srs4326.ImportFromEPSG(4326)\n if self.out_srs and srs4326.ExportToProj4() == self.out_srs.ExportToProj4():\n self.kml = True\n self.isepsg4326 = True\n if self.options.verbose:\n print \"KML autotest OK!\"\n\n # Read the georeference\n\n self.out_gt = self.out_ds.GetGeoTransform()\n\n #originX, originY = self.out_gt[0], self.out_gt[3]\n #pixelSize = self.out_gt[1] # = self.out_gt[5]\n\n # Test the size of the pixel\n\n # MAPTILER - COMMENTED\n #if self.out_gt[1] != (-1 * self.out_gt[5]) and self.options.profile != 'raster':\n # TODO: Process corectly coordinates with are have swichted Y axis (display in OpenLayers too)\n #self.error(\"Size of the pixel in the output differ for X and Y axes.\")\n\n # Report error in case rotation/skew is in geotransform (possible only in 'raster' profile)\n if (self.out_gt[2], self.out_gt[4]) != (0,0):\n self.error(\"Georeference of the raster contains rotation or skew. Such raster is not supported. Please use gdalwarp first.\")\n # TODO: Do the warping in this case automaticaly\n\n #\n # Here we expect: pixel is square, no rotation on the raster\n #\n\n # Output Bounds - coordinates in the output SRS\n self.ominx = self.out_gt[0]\n self.omaxx = self.out_gt[0]+self.out_ds.RasterXSize*self.out_gt[1]\n self.omaxy = self.out_gt[3]\n self.ominy = self.out_gt[3]-self.out_ds.RasterYSize*self.out_gt[1]\n # Note: maybe round(x, 14) to avoid the gdal_translate behaviour, when 0 becomes -1e-15\n # user defined bounds to extract - coordinates in the output SRS\n if self.options.te_bounds != '':\n if self.te_minx >= self.ominx and self.te_minx <= self.omaxx:\n if self.te_maxx >= self.ominx and self.te_maxx <= self.omaxx:\n if self.te_miny >= self.ominy and self.te_miny <= self.omaxy:\n if self.te_maxy >= self.ominy and self.te_maxy <= self.omaxy:\n # replace only if inside the read bounds\n self.ominx = self.te_minx\n self.omaxx = self.te_maxx\n self.ominy = self.te_miny\n self.omaxy = self.te_maxy\n if self.options.verbose:\n print \"User defined Bounds (output srs) have been set:\", round(self.ominx, 13), self.ominy, self.omaxx, self.omaxy\n\n if self.options.verbose:\n print \"Bounds (output srs):\", round(self.ominx, 13), self.ominy, self.omaxx, self.omaxy\n\n if self.options.mbtiles:\n self.options.profile = 'mercator'\n if self.options.profile == 'mercator':\n self.mercator = GlobalMercator(self.options.tms_osm) # from globalmaptiles.py\n\n #\n # Calculating ranges for tiles in different zoom levels\n #\n\n # Function which generates SWNE in LatLong for given tile\n self.tileswne = self.mercator.TileLatLonBounds\n\n # Generate table with min max tile coordinates for all zoomlevels\n self.tminmax = range(0,32)\n for tz in range(0, 32):\n tminx, tminy = self.mercator.MetersToTile( self.ominx, self.ominy, tz )\n tmaxx, tmaxy = self.mercator.MetersToTile( self.omaxx, self.omaxy, tz )\n # crop tiles extending world limits (+-180,+-90)\n tminx, tminy = max(0, tminx), max(0, tminy)\n tmaxx, tmaxy = min(2**tz-1, tmaxx), min(2**tz-1, tmaxy)\n self.tminmax[tz] = (tminx, tminy, tmaxx, tmaxy)\n\n # TODO: Maps crossing 180E (Alaska?)\n\n # Get the minimal zoom level (map covers area equivalent to one tile)\n if self.tminz == None:\n self.tminz = self.mercator.ZoomForPixelSize( self.out_gt[1] * max( self.out_ds.RasterXSize, self.out_ds.RasterYSize) / float(self.tilesize) )\n\n # Get the maximal zoom level (closest possible zoom level up on the resolution of raster)\n if self.tmaxz == None:\n self.tmaxz = self.mercator.ZoomForPixelSize( self.out_gt[1] )\n\n if self.options.verbose:\n print \"Bounds (latlong):\", self.mercator.MetersToLatLon( self.ominx, self.ominy), self.mercator.MetersToLatLon( self.omaxx, self.omaxy)\n print 'MinZoomLevel:', self.tminz\n print \"MaxZoomLevel:\", self.tmaxz, \"(\", self.mercator.Resolution( self.tmaxz ),\")\"\n\n # this must be call befor ImageOutput is called (self.output may be changed)\n if self.options.mbtiles:\n if not self.mbtiles_db:\n self.mbtiles_setup(1);\n\n # Instantiate image output.\n self.image_output = ImageOutput(self.options.tile_format, self.out_ds, self.tilesize,\n self.options.resampling, init_dest, self.output,\n self.options.verbose,self.options.mbtiles)\n if self.options.profile == 'geodetic':\n\n self.geodetic = GlobalGeodetic() # from globalmaptiles.py\n\n # Function which generates SWNE in LatLong for given tile\n self.tileswne = self.geodetic.TileLatLonBounds\n\n # Generate table with min max tile coordinates for all zoomlevels\n self.tminmax = range(0,32)\n for tz in range(0, 32):\n tminx, tminy = self.geodetic.LatLonToTile( self.ominx, self.ominy, tz )\n tmaxx, tmaxy = self.geodetic.LatLonToTile( self.omaxx, self.omaxy, tz )\n # crop tiles extending world limits (+-180,+-90)\n tminx, tminy = max(0, tminx), max(0, tminy)\n tmaxx, tmaxy = min(2**(tz+1)-1, tmaxx), min(2**tz-1, tmaxy)\n self.tminmax[tz] = (tminx, tminy, tmaxx, tmaxy)\n\n # TODO: Maps crossing 180E (Alaska?)\n\n # Get the maximal zoom level (closest possible zoom level up on the resolution of raster)\n if self.tminz == None:\n self.tminz = self.geodetic.ZoomForPixelSize( self.out_gt[1] * max( self.out_ds.RasterXSize, self.out_ds.RasterYSize) / float(self.tilesize) )\n\n # Get the maximal zoom level (closest possible zoom level up on the resolution of raster)\n if self.tmaxz == None:\n self.tmaxz = self.geodetic.ZoomForPixelSize( self.out_gt[1] )\n\n if self.options.verbose:\n print \"Bounds (latlong):\", self.ominx, self.ominy, self.omaxx, self.omaxy\n\n if self.options.profile in ('raster', 'gearth', 'garmin'):\n\n log2 = lambda x: math.log10(x) / math.log10(2) # log2 (base 2 logarithm)\n\n self.nativezoom = int(max( math.ceil(log2(self.out_ds.RasterXSize/float(self.tilesize))),\n math.ceil(log2(self.out_ds.RasterYSize/float(self.tilesize)))))\n\n if self.options.verbose:\n print \"Native zoom of the raster:\", self.nativezoom\n\n # Get the minimal zoom level (whole raster in one tile)\n if self.tminz == None:\n self.tminz = 0\n\n # Get the maximal zoom level (native resolution of the raster)\n if self.tmaxz == None:\n self.tmaxz = self.nativezoom\n\n # Garmin has maximally 100 tiles - lower the tmaxz if necessary\n if self.options.profile == 'garmin':\n tno = math.ceil(self.out_ds.RasterXSize / self.tilesize) * math.ceil(self.out_ds.RasterYSize / self.tilesize)\n for tz in range(self.tmaxz, 1, -1):\n if tno > 100:\n tno /= 4\n self.tmaxz -= 1\n print \"Warning: GARMIN has a limit 100 tiles per device: lowering the max zoom level to:\", self.tmaxz\n else:\n continue\n\n # Force only one zoom level for the 'garmin' tile profile\n if self.options.profile == 'garmin':\n self.tminz = self.tmaxz\n\n # Generate table with min max tile coordinates for all zoomlevels\n self.tminmax = range(0, self.tmaxz+1)\n self.tsize = range(0, self.tmaxz+1)\n for tz in range(0, self.tmaxz+1):\n tsize = 2.0**(self.nativezoom-tz)*self.tilesize\n tminx, tminy = 0, 0\n tmaxx = int(math.ceil( self.out_ds.RasterXSize / tsize )) - 1\n tmaxy = int(math.ceil( self.out_ds.RasterYSize / tsize )) - 1\n self.tsize[tz] = math.ceil(tsize)\n self.tminmax[tz] = (tminx, tminy, tmaxx, tmaxy)\n\n # Function which generates SWNE in LatLong for given tile\n if self.kml and self.in_srs_wkt:\n self.ct = osr.CoordinateTransformation(self.in_srs, srs4326)\n def rastertileswne(x,y,z):\n pixelsizex = (2**(self.nativezoom-z) * self.out_gt[1]) # X-pixel size in level\n pixelsizey = (2**(self.nativezoom-z) * self.out_gt[5]) # Y-pixel size in level (usually -1*pixelsizex)\n west = self.out_gt[0] + x*self.tilesize*pixelsizex\n east = west + self.tilesize*pixelsizex\n south = self.ominy + y*self.tilesize*pixelsizex\n north = south + self.tilesize*pixelsizex\n if not self.isepsg4326:\n # Transformation to EPSG:4326 (WGS84 datum)\n west, south = self.ct.TransformPoint(west, south)[:2]\n east, north = self.ct.TransformPoint(east, north)[:2]\n return south, west, north, east\n\n self.tileswne = rastertileswne\n else:\n self.tileswne = lambda x, y, z: (0,0,0,0)","def read_results():\r\n with open(\"packing.nfo\", \"r\") as fin:\r\n fin.readline()\r\n fin.readline()\r\n por_theory = float(fin.readline().split()[2])\r\n por_final = float(fin.readline().split()[2])\r\n print('Theoretical porosity:', por_theory)\r\n print('Final porosity:', por_final)\r\n with open(\"packing.xyzd\", \"rb\") as fin:\r\n btxt = fin.read()\r\n txt = list(struct.unpack(\"<\" + \"d\" * (len(btxt) // 8), btxt))\r\n data = array(zip(*[iter(txt)] * 4))\r\n data[:, 3] = data[:, 3] * \\\r\n ((1 - por_final) / (1 - por_theory))**(1 / 3)\r\n return data","def read_db():\n with open(\"config.json\") as f:\n config = json.load(f)\n \n conn = psycopg2.connect(dbname='cage_sc_db', user='cage_db_user', \n password='legend', host='10.66.193.71')\n cursor = conn.cursor()\n\n # cmd = \"SELECT value_raw, timestamp FROM numeric_data WHERE endpoint_name='krstc_baseline' AND timestamp>'2019-09-27T00:00';\"\n \n # cmd = \"SELECT * FROM endpoint_id_map;\"\n \n # cmd = \"SELECT value_cal, timestamp FROM numeric_data WHERE endpoint_name='cage_coldPlate_temp' AND timestamp>'2019-09-03T00:02';\"\n \n # cmd = \"SELECT value_cal, timestamp FROM numeric_data WHERE endpoint_name='cage_pressure' AND timestamp>'2019-09-27T00:00';\"\n \n cmd = \"SELECT value_cal, timestamp FROM numeric_data WHERE endpoint_name='cage_ln_level' AND timestamp>'2019-09-27T00:00';\"\n \n # cmd = \"SELECT value_raw, timestamp FROM string_data WHERE endpoint_name='krstc_hv_status' AND timestamp>'2019-08-01';\"\n \n cursor.execute(cmd)\n\n # retrieve data. returns a list of tuples.\n record = cursor.fetchall()\n \n # print(type(record[0]))\n \n # dt = record[0][1]\n \n # print(dt)\n \n for rec in record:\n print(rec)","def load_raw_aflw(sqlite_path, image_dir):\n print('Load raw AFLW dataset from \"{}\"'.format(sqlite_path))\n\n # Temporary dataset variables\n dataset_dict = dict()\n\n # Open sqlite file\n conn = sqlite3.connect(sqlite_path)\n cursor = conn.cursor()\n\n # Basic property\n select_str = \"faces.face_id, imgs.filepath, \" \\\n \"rect.x, rect.y, rect.w, rect.h, \" \\\n \"pose.roll, pose.pitch, pose.yaw, metadata.sex\"\n from_str = \"faces, faceimages imgs, facerect rect, facepose pose, \" \\\n \"facemetadata metadata\"\n where_str = \"faces.file_id = imgs.file_id and \" \\\n \"faces.face_id = rect.face_id and \" \\\n \"faces.face_id = pose.face_id and \" \\\n \"faces.face_id = metadata.face_id\"\n query_res = exec_sqlite_query(cursor, select_str, from_str, where_str)\n # Register to dataset_dict\n for face_id, path, rectx, recty, rectw, recth, roll, pitch, yaw, gender in query_res:\n # Data creation or conversion\n img_path = os.path.join(image_dir, path) if image_dir else path\n landmark = np.zeros((N_LANDMARK, 2), dtype=np.float32)\n landmark_visib = np.zeros(N_LANDMARK, dtype=np.float32)\n pose = np.array([roll, pitch, yaw], dtype=np.float32)\n gender = np.array([1, 0] if gender == 'm' else [0, 1], dtype=np.int32)\n others_landmark_pts = list()\n # Register\n data = {'face_id': face_id,\n 'img_path': img_path,\n 'face_rect': (rectx, recty, rectw, recth),\n 'landmark': landmark,\n 'landmark_visib': landmark_visib,\n 'pose': pose,\n 'gender': gender,\n 'others_landmark_pts': others_landmark_pts}\n dataset_dict[face_id] = data\n\n # Landmark property\n # (Visibility is expressed by lack of the coordinate's row.)\n select_str = \"faces.face_id, coords.feature_id, \" \\\n \"coords.x, coords.y\"\n from_str = \"faces, featurecoords coords\"\n where_str = \"faces.face_id = coords.face_id\"\n query_res = exec_sqlite_query(cursor, select_str, from_str, where_str)\n # Register to dataset_dict\n invalid_face_ids = list()\n for face_id, feature_id, x, y in query_res:\n assert (1 <= feature_id <= N_LANDMARK)\n if face_id in dataset_dict:\n idx = feature_id - 1\n dataset_dict[face_id]['landmark'][idx][0] = x\n dataset_dict[face_id]['landmark'][idx][1] = y\n dataset_dict[face_id]['landmark_visib'][idx] = 1\n elif face_id not in invalid_face_ids:\n print('Invalid face id ({}) in AFLW'.format(face_id))\n invalid_face_ids.append(face_id)\n\n # Landmarks of other faces, file_id could have more than one face_id, thats why !=\n select_str = \"a.face_id, coords.x, coords.y\"\n from_str = \"faces a, faces b, featurecoords coords\"\n where_str = \"a.face_id != b.face_id and a.file_id = b.file_id and \" \\\n \"b.face_id = coords.face_id\"\n query_res = exec_sqlite_query(cursor, select_str, from_str, where_str)\n # Register to dataset_dict\n for face_id, others_x, others_y in query_res:\n if face_id in dataset_dict:\n other_coord = [others_x, others_y]\n dataset_dict[face_id]['others_landmark_pts'].append(other_coord)\n else:\n assert (face_id in invalid_face_ids)\n # Convert list to np.ndarray\n for data in dataset_dict.values():\n pts = np.array(data['others_landmark_pts'], dtype=np.float32)\n data['others_landmark_pts'] = pts\n\n # Exit sqlite\n cursor.close()\n\n # Return dataset_dict's value (list)\n return list(dataset_dict.values())","def readDriverFile(self, input_file):\n\n\n fid = open(self.basePath + input_file,'r')\n\n # Line 1\n line = fid.readline()\n l_input = line.split('!')\n mshfile = l_input[0].rstrip()\n\n # Line 2\n line = fid.readline()\n l_input = line.split('!')\n obsfile = l_input[0].rstrip()\n\n # Line 3\n line = fid.readline()\n l_input = re.split('[!\\s]',line)\n if l_input=='null':\n topofile = []\n\n else:\n topofile = l_input[0].rstrip()\n\n\n # Line 4\n line = fid.readline()\n l_input = re.split('[!\\s]',line)\n if l_input[0]=='VALUE':\n mstart = float(l_input[1])\n\n else:\n mstart = l_input[0].rstrip()\n\n # Line 5\n line = fid.readline()\n l_input = re.split('[!\\s]',line)\n if l_input[0]=='VALUE':\n mref = float(l_input[1])\n\n else:\n mref = l_input[0].rstrip()\n\n # Line 6\n line = fid.readline()\n l_input = re.split('[!\\s]',line)\n if l_input[0]=='VALUE':\n staticInput = float(l_input[1])\n\n elif l_input[0]=='DEFAULT':\n staticInput = None\n\n else:\n staticInput = l_input[0].rstrip()\n\n\n # Line 7\n line = fid.readline()\n l_input = re.split('[!\\s]',line)\n if l_input=='DEFAULT':\n magfile = []\n\n else:\n magfile = l_input[0].rstrip()\n\n # Line 8\n line = fid.readline()\n l_input = re.split('[!\\s]',line)\n if l_input=='DEFAULT':\n wgtfile = []\n\n else:\n wgtfile = l_input[0].rstrip()\n\n # Line 9\n line = fid.readline()\n l_input = re.split('[!\\s]',line)\n chi = float(l_input[0])\n\n # Line 10\n line = fid.readline()\n l_input = re.split('[!\\s]',line)\n val = np.array(l_input[0:4])\n alphas = val.astype(np.float)\n\n # Line 11\n line = fid.readline()\n l_input = re.split('[!\\s]',line)\n if l_input[0]=='VALUE':\n val = np.array(l_input[1:3])\n bounds = val.astype(np.float)\n\n else:\n bounds = l_input[0].rstrip()\n\n # Line 12\n line = fid.readline()\n l_input = re.split('[!\\s]',line)\n if l_input[0]=='VALUE':\n val = np.array(l_input[1:6])\n lpnorms = val.astype(np.float)\n\n else:\n lpnorms = l_input[0].rstrip()\n\n # Line 13\n line = fid.readline()\n l_input = re.split('[!\\s]',line)\n if l_input[0]=='VALUE':\n val = np.array(l_input[1:3])\n eps = val.astype(np.float)\n\n else:\n eps = [None,None]\n\n self.mshfile = mshfile\n self.obsfile = obsfile\n self.topofile = topofile\n self.mstart = mstart\n self._mrefInput = mref\n self._staticInput = staticInput\n self.magfile = magfile\n self.wgtfile = wgtfile\n self.chi = chi\n self.alphas = alphas\n self.bounds = bounds\n self.lpnorms = lpnorms\n self.eps = eps","def read_data_set():\n # shapes of datasets -- [] means expanded form:\n # - X: J\n # - net.R: J [x J x 1]\n # - F_DIST: J x J x num_features\n # - F_DIST_w1: J x J x num_features\n # - w['except_first'][-1]: (last weights) J x num_features [x 1]\n # - w['except_first'][1:-1]: (second to last weights) J x J x num_features\n # - first weights **were** also J x J x num_features\n # - w['first_for_r']: J x 1 x num_features\n\n read_X()\n read_weights(read_FDIST())","def read(self) :\n # Open the file.\n f = open(self.output, 'r')\n lines = f.readlines()\n \n # Find the eigenvalue.\n count = 0\n while True :\n words = lines[count].split()\n if len(words) == 5 :\n if words[0] == \"*\" and words[1] == \"K-EFF\":\n self.keff = float(words[3])\n break\n count += 1\n \n # Find the peaking.\n a = 0 # Assembly index\n \n while True :\n words = lines[count].split()\n if len(words) == 8 :\n if words[0] == \"NODE\" and words[1] == \"AVERAGE\" and words[2] == \"POWERS\" :\n count += 5 # Powers start 5 lines below title\n for row in range(0, self.dimension) :\n words = lines[count].split()\n assert(len(words) >= self.dimension)\n for col in range(0, self.dimension) :\n self.peaking_map[row, col] = float(words[col+1])\n if self.core.stencil[row, col] > 0:\n #print \" a=\", a, \" row=\", row, \" col=\", col, len(self.peaking)\n self.peaking[a] = self.peaking_map[row, col]\n a += 1\n count += 1\n break\n count += 1 \n # Maximum peaking.\n self.maxpeak = np.max(self.peaking)","def read_fatlasa_results(filename):\n\n pass","def read(self):","def load_data(database_filepath):\n\n # create engine to get connection\n engine = create_engine(\"sqlite:///{}\".format(database_filepath))\n with engine.connect() as connection:\n df = pd.read_sql_table(\"appen\", connection)\n # define the features and output of the model\n X = df[\"message\"]\n Y = df.drop([\"message\", \"id\", \"original\", \"genre\"], axis=1)\n category_names = list(Y.columns)\n\n return X, Y, category_names","def read_data(filename):\n data=''\n with zipfile.ZipFile(filename) as f:\n \n for file in f.namelist():\n subdata = tf.compat.as_str(f.read(file))\n data+=subdata\n return nlp(data)","def Read_Palik():\n fid = open('/Users/simonvassant/TheseSave/Matlab_RMCA/RMCA_Fab_CuN17_Champ/Au_Palik.dat','r')\n L,eps = [],[]\n while 1: \n line = fid.readline()\n if line =='': \n break \n else :\n L.append(float(line[:25]))\n eps.append(float(line[27:54])+1j*float(line[55:-2]))\n return np.array(L),np.array(eps)","def _read_query(self):\n try:\n # Open Google Drive and read the sql file\n self.query = GDrive().read_drive_file(self.input_source_id)\n except Exception as e:\n raise e","def read_sql(name=\"total_trips.sql\"):\n template = pkg_resources.resource_filename(\"gojek\", join(\"sql\", name))\n with open(template, 'r') as myfile:\n query = myfile.read()\n return query","def load_data(self, filename):\r\n #sqlcontext = SQLContext(self.sc)\r\n #df = sqlcontext.read.format('com.databricks.spark.csv').options(header='false', inferschema='true').load(filename)\r\n #df = sc.textFile(r\"C:\\Users\\mohan\\Downloads\\patches.csv\").map(lambda line: line.split(\",\"))\r\n #print (df.count())\r\n df = self.sc.textFile(filename).map(lambda line: line.split(\",\"))\r\n l = df.map(lambda w: [int(float(c)) for c in w]).zipWithIndex()\r\n return l\r\n raise NotImplementedError","def readfields(self, dbname, line1, nlines, startdate): \n\n conn=sqlite3.connect(dbname)\n c=conn.cursor()\n self.obsHistID=np.zeros(nlines)\n self.fieldMJD=np.zeros(nlines)\n self.fieldRA=np.zeros(nlines)\n self.fieldDec=np.zeros(nlines)\n self.rotSkyPos=np.zeros(nlines)\n self.filter=np.zeros(nlines, dtype=str)\n self.fiveSigmaDepth=np.zeros(nlines)\n self.seeingFwhmEff=np.zeros(nlines)\n\n count=0\n# exec_str='SELECT obsHistID,expMJD,fieldRA,fieldDec,rotSkyPos FROM Summary order by expMJD limit %d,%d' %(line1-1,nlines)\n exec_str='SELECT observationId,observationStartMJD,FieldRA,FieldDec,rotSkyPos,filter,fiveSigmaDepth,seeingFwhmEff FROM SummaryAllProps order by observationStartMJD limit %d,%d' %(line1-1,nlines)\n for row in c.execute(exec_str):\n self.obsHistID[count] = row[0]\n self.fieldMJD[count] = row[1]\n self.fieldRA[count] = np.deg2rad(row[2])\n self.fieldDec[count] = np.deg2rad(row[3])\n self.rotSkyPos[count] = np.deg2rad(row[4])\n self.filter[count] = row[5]\n self.fiveSigmaDepth[count] = row[6]\n self.seeingFwhmEff[count] = row[7]\n count +=1\n\n # startdate is 0 if not provided by user. In this case use the default MJDs.\n if (startdate > 1):\n self.fieldMJD=self.fieldMJD+(int(startdate)-int(self.fieldMJD[0]))","def read_input(inputfile):\n print(ColorText('\\nReading input file ...').bold())\n # read in datatable\n df = pd.read_table(inputfile, sep='\\t')\n\n # set df index\n locuscol = 'unstitched_locus' if 'unstitched_locus' in df.columns else 'locus'\n if locuscol not in df:\n print(ColorText('\\nFAIL: There must be a column for locus IDs - either \"unstitched_locus\" or \"locus\"').fail())\n print(ColorText('FAIL: The column is the hyphen-separated CHROM and POS.').fail())\n print(ColorText('exiting cmh_test.py').fail())\n exit()\n df.index = df[locuscol].tolist()\n\n return df","def dbRead(dbPoint):\n raise NotImplementedError('dbRead in simu mode')","def ReadIndex_binary(indexfile, isPrintWarning = False):#{{{\n# return (indexList, headerinfo, dbfileindexList)\n indexList = []\n indexFileHeaderText = []\n size_indexfile = os.path.getsize(indexfile)\n cntReadByte = 0\n try:\n fpin=open(indexfile, \"rb\")\n vI = array('I')\n vI.fromfile(fpin,1)\n cntReadByte += vI.itemsize\n dumpedtext = fpin.read(vI[0])\n cntReadByte += vI[0]\n\n strs = dumpedtext.split(\"\\n\")\n origdbname = \"\"\n origversion = \"\"\n origext = \"\"\n origprefix = \"\"\n for line in strs:\n if not line or line[0] == \"#\":\n continue\n ss=line.split()\n if ss[0] == \"DEF_DBNAME\":\n if len(ss)>=2:\n origdbname=ss[1]\n elif ss[0] == \"DEF_VERSION\":\n if len(ss)>=2:\n origversion=ss[1]\n elif ss[0] == \"DEF_EXTENSION\":\n if len(ss)>=2:\n origext=ss[1]\n elif ss[0] == \"DEF_PREFIX\":\n if len(ss)>=2:\n origprefix=ss[1]\n if isPrintWarning:\n if origversion == \"\": \n msg = \"{}: Warning! No version info in the index file {}\"\n print(msg.format(sys.argv[0],indexfile), file=sys.stderr)\n elif origversion != version:\n msg = \"{}: Warning! Version conflicts. \"\\\n \"Version of the index file {} ({}) \"\\\n \"!= version of the program ({})\"\n print(msg.format(sys.argv[0], indexfile,\n origversion, version), file=sys.stderr)\n\n headerinfo = (origdbname, origversion, origext, origprefix)\n #read in other information\n vI = array('I')\n vI.fromfile(fpin,1)\n cntReadByte += vI.itemsize\n\n dumpedidlist=fpin.read(vI[0])\n cntReadByte += vI[0]\n\n idlist = dumpedidlist.split(\"\\n\")\n vI=array('I')\n vI.fromfile(fpin,1)\n cntReadByte += vI.itemsize\n\n numRecord = vI[0]\n if numRecord != len(idlist):\n msg = \"{}: numID ({}) != numRecord ({}) for indexfile {} \"\n print(msg.format(sys.argv[0], len(idlist),\n numRecord, indexfile), file=sys.stderr)\n\n sizeRecord_I = (array('B').itemsize + array('I').itemsize +\n array('I').itemsize)\n sizeRecord_L = (array('B').itemsize + array('L').itemsize +\n array('I').itemsize)\n sizeRecord = int(mybase.FloatDivision(size_indexfile - cntReadByte, numRecord))\n if abs(sizeRecord - sizeRecord_I) < abs(sizeRecord - sizeRecord_L):\n vIarray=[array('B'), array('I'), array('I')]\n else:\n vIarray=[array('B'), array('L'), array('I')]\n for i in range(3):\n vIarray[i].fromfile(fpin,numRecord)\n\n lastDBFileIndex = vIarray[0][numRecord-1]\n dbfileindexList = list(range(lastDBFileIndex+1))\n\n indexList.append(idlist)\n for i in range(3):\n indexList.append(vIarray[i])\n fpin.close()\n return (indexList, headerinfo, dbfileindexList)\n except IOError:\n msg = \"Failed to read index file {} in function {}\"\n print(msg.format(indexfile, sys._getframe().f_code.co_name), file=sys.stderr)\n return (None, None, None)","def load_data(database_filepath):\n\n logging.info(\"run load_data\")\n\n # create engine and connect to file based-database\n engine = create_engine(f\"sqlite:///{database_filepath}\")\n\n # load data in dataframe\n df = pd.read_sql_table('data', engine)\n logging.info(f\"data retrieved from db file: {database_filepath}\")\n\n # shuffle data\n df = df.sample(frac=1, random_state=42)\n\n # split data between input and outputs\n X = df['message']\n Y = df.drop(['id', 'message', 'original', 'genre'], axis=1)\n\n return X, Y, Y.columns","def get_raw_data():\n data_files = []\n for i, f in enumerate(os.listdir(config.RAW_DATA_DIR)):\n data_files.append(f)\n print i, \": \", f\n while True:\n try:\n index = int(raw_input(\"Type the index of the data file you'd like to import: \"))\n fn_raw_data = data_files[int(index)]\n break\n except ValueError:\n print(\"Not a valid index. Try again.\")\n except IndexError:\n print(\"Not a valid index. Try again.\")\n print \"Importing %s...\" % fn_raw_data\n with open(config.RAW_DATA_DIR + fn_raw_data) as infile:\n next(infile)\n raw_data = list(csv.DictReader(infile))\n return (fn_raw_data, raw_data)","def wellBoreDataRead(fileName = None, onePhase = None):\n materialIndex = 1\n wellBoreDataDict = {}\n if onePhase == None:\n onePhase = True\n pass\n if fileName == None:\n if onePhase == True:\n fileName = environ[\"PWD\"]+\"/Data/wellbore.dat\"\n pass\n else:\n fileName = environ[\"PWD\"]+\"/Data/twophasewellbore.dat\"\n pass\n try:\n dataFile = open(fileName,\"r\")\n except:\n input(\" Necessary data have been read from\\n\"+\\\n \" the generic wellbore data file: $WRAPPER/Data/Wellbore/wellbore.dat\\n\"+\\\n \" A copy of that file is now in your reference directory as $PWD/Data/wellbore.dat.\\n\"+\n \" Modify it now to your own specific wellbore data.\\n\"+\\\n \" Now, enter any ascii key to continue the simulation\")\n if (onePhase == True):\n system(\"mkdir -p $PWD/Data;cp -p $WRAPPER/Data/Wellbore/wellbore.dat ./Data;chmod u+w $PWD/Data/wellbore.dat\")\n pass\n else:\n system(\"mkdir -p $PWD/Data;cp -p $WRAPPER/Data/Wellbore/twophasewellbore.dat ./Data;chmod u+w $PWD/Data/twophasewellbore.dat\")\n pass\n dataFile = open(fileName,\"r\")\n line = dataFile.readline()\n #print(\"first line\", line)\n \n while \"Transient terms\" not in line:\n line = dataFile.readline()\n if \"material\" in line.lower():\n wellBoreDataDict[\"Material\"+str(materialIndex)] = {}\n wellBoreDataDict1 = wellBoreDataDict[\"Material\"+str(materialIndex)]\n wellBoreDataDict[line.lower().replace(\"material\",\"\").replace(\"!\",\"\").replace(\"\\n\",\"\").replace(\" \",\"\")] = \"Material\"+str(materialIndex)\n materialIndex+=1\n elif (\"=\" in line) and (\"True\" in line):\n var, varType, varValue = wellBoreDataLineAnalysis(line)\n wellBoreDataDict1[var] = {varType:[varValue]}\n elif \"=\" in line:\n #print \"debug1 \",line\n pythonString, var, varValue, varType, unit = wellBoreDataLineAnalysis(line)\n if varType == \"Real\" or varType == \"Int\":\n wellBoreDataDict1[var] = {varType:[varValue,unit]}\n else:\n line = dataFile.readline().replace(\"\\n\",\"\")\n wellBoreDataDict1[var] = {varType:[line,unit]} # the type is implicitely variable due to the fact we have\n # to deal with a formula,\n # the variation is over the coordinate\n wellBoreDataDict1[var] = {varType:[line,unit]}\n #print(wellBoreDataDict); raw_input(\"wellBoreDataDict:\"+\"Material\"+str(materialIndex))\n return wellBoreDataDict","def Read_Palik_Al2O3_c():\n fid = open('/Users/simonvassant/TheseSave/PaliK_Opticalconstant/Al2O3_B_Palik.dat','r')\n L,eps = [],[]\n while 1: \n line = fid.readline()\n if line =='': \n break \n else :\n L.append(float(line[18:25]))\n eps.append((float(line[42:49])+1j*float(line[50:57]))**2)\n return np.array(L),np.array(eps)","def read(self, filename):\n pass","def read(self, filename):\n pass","def read (self, path):\n\n\t\tself.data = []\n\t\t# print \"*** path: %s***\" % path\n\t\tdir, filename = os.path.split (path)\n\t\troot, ext = os.path.splitext (filename)\n\t\t# encoding = 'ISO-8859-1' # utf-8\n\t\ts = codecs.open(path,'r', self.encoding).read()\n\t\t## s = unicode(f.read(),'utf-8')\n\t\ts = self.preprocess (s)\n\t\tlines = split (s, self.linesep)\n\t\tschema = self.splitline(lines[0])\n\n\t\t## print \"** %s **\" % os.path.splitext(filename)[0]\n\t\tif self.verbose:\n\t\t\tprint \"read %d lines from %s\" % (len(lines), path)\n\n\t\tfor i in range(1,len(lines)):\n\t\t\tif not lines[i].strip(): \n\t\t\t\t# print 'skipping line (%d)' % i\n\t\t\t\tcontinue\n\t\t\tfields = self.splitline(lines[i])\n\t\t\titem = self.entry_class (fields, schema)\n\t\t\tif self.accept (item):\n\t\t\t\tself.add (item)\n\n\t\tself.schema = schema\n\t\t# self.data.sort (lastNameCmp)","def read_input_data(input_f, features_file, output):\n\n print('\\n Reading input...')\n log_write(output['log'], 'Input file: %s\\n' % input_f, 'w+')\n\n # Read input data\n df = pd.read_csv(input_f, low_memory=False)\n df = df.astype({'Column': int,\n 'Row': int,\n 'ImageNumber': int,\n 'ObjectNumber': int\n })\n\n # Data features\n if features_file:\n data_features = [l.rstrip() for l in open(features_file).readlines()]\n else:\n data_features = [c for c in df.columns.values if 'PC' in c]\n\n return df, wt_strains(df), data_features","def readFromFile(filename):\n raise NotImplementedError","def read_model(self):\n filename = self.name + '_words'\n f = open(filename, 'r') \n d_str = f.read() \n f.close()\n d = dict(eval(d_str))\n self.words = d\n \n filename2 = self.name + '_word_lengths'\n f = open(filename2, 'r') \n d2_str = f.read() \n f.close()\n d2 = dict(eval(d2_str))\n self.word_lengths = d2\n \n filename3 = self.name + '_stems'\n f = open(filename3, 'r') \n d3_str = f.read() \n f.close()\n d3 = dict(eval(d3_str))\n self.stems = d3\n \n filename4 = self.name + '_sentence_lengths'\n f = open(filename4, 'r') \n d4_str = f.read() \n f.close()\n d4 = dict(eval(d4_str))\n self.sentence_lengths = d4\n \n filename5 = self.name + '_punctuation'\n f = open(filename5, 'r') \n d5_str = f.read() \n f.close()\n d5 = dict(eval(d5_str))\n self.punctuation = d5","def produce_database(database_name, is_debug):\n\t\n\t# read files from a01-a35, every file including whole ecg data and the corresponding annotation\n\tdata_annotations_set = get_ecg_data_annotations(database_name, is_debug)\n\t# divide ECG data to minute-by-minute ECG segments\n\t_ = process_ecg_data_segments(database_name, data_annotations_set, is_debug)","def read_old(lookup_cnfg, lookup_qn, diagram, T, directory, verbose=0):\n\n data = []\n\n for cnfg in lookup_cnfg:\n # filename and path\n filename = directory + '/' + diagram + '_cnfg%i' % cnfg + '.h5'\n # open file\n try:\n fh = h5py.File(filename, \"r\")\n except IOError:\n print 'file %s not found' % filename\n raise\n\n # to achieve hirarchical indexing for quantum numbers build DataFrame for\n # each loop seperately\n # TODO: is it necessary to build that completely or can that be \n # constructed by successively storing each operator with pd.HDFStore()?\n data_qn = pd.DataFrame()\n# print DataFrame(lookup_p)\n# print DataFrame(lookup_g)\n ndata = 0\n nfailed = 0\n\n for op in lookup_qn.index:\n ndata += 1\n # generate operator name\n p = lookup_qn.ix[op, ['p_{so}', 'p_{si}']]\n g = lookup_qn.ix[op, ['\\gamma_{so}', '\\gamma_{si}']]\n groupname = set_groupname(diagram, p, g)\n\n # read operator from file and store in data frame\n try:\n tmp = np.asarray(fh[groupname])\n except KeyError:\n #if diagram == 'C4+C' and cnfg == 714:\n # print(\"could not read %s for config %d\" % (groupname, cnfg))\n nfailed += 1\n continue\n data_qn[op] = pd.DataFrame(tmp, columns=['re/im'])\n if nfailed > 0 and verbose > 0:\n print(\"could not read %d of %d data\" % (nfailed, ndata))\n\n # append all data for one config and close the file\n data.append(data_qn)\n fh.close()\n # generate data frame containing all operators for all configs\n data = pd.concat(data, keys=lookup_cnfg, axis=0, names=['cnfg', 'T'])\n\n if verbose:\n print '\\tfinished reading'\n\n return data.sort_index(level=[0,1])\n ##############################################################################","def read_data(db_name, query_file):\r\n con = sqlite3.connect(db_name)\r\n cursor = con.cursor()\r\n\r\n sql = open(query_file,'r')\r\n query = sql.read()\r\n sql.close()\r\n\r\n data = pd.read_sql_query(query, con=con)\r\n data.drop_duplicates(subset=['Title'], inplace=True)\r\n data = data[data['Type']=='movie']\r\n data.set_index('imdbID', inplace=True)\r\n\r\n con.commit()\r\n con.close()\r\n\r\n return data","def loadDatabase(database):\n for file_name in os.listdir(\"Users\"):\n chemin = os.path.join(\"Users\", file_name)\n key = file_name.lower()\n database[key]=pickle.load(open(chemin,\"rb\"))","def _read_dataset(a_files):\n return [(list(ifields[TXT_IDX]), ifields[GLD_IDX])\n for ifile in a_files for ifields in iterlines(ifile)]"],"string":"[\n \"def read_stock(db, openfile):\\n pass\",\n \"def read_locations(db, openfile):\\n pass\",\n \"def read_sql(self):\\n pass\",\n \"def read(self):\\n file_path = os.path.join(self.query_path, self.filename + '.sql')\\n with open(file_path, 'r') as f:\\n self.raw_sql = f.read()\",\n \"def build_input_db():\\n build_input_database()\",\n \"def read(self, database ='project'):\\n\\t\\tfile = open(self.file_name, \\\"r\\\")\\n\\n\\t\\ti = 1\\n\\t\\tseptics = []\\n\\t\\tfor line in file:\\n\\t\\t\\tif i > 2:\\n\\t\\t\\t\\tval = line.split()\\n\\t\\t\\t\\tself.check_cols(val, 13, 'septic')\\n\\n\\t\\t\\t\\tsep = {\\n\\t\\t\\t\\t\\t'name': val[0].lower(),\\n\\t\\t\\t\\t\\t'q_rate': val[1],\\n\\t\\t\\t\\t\\t'bod': val[2],\\n\\t\\t\\t\\t\\t'tss': val[3],\\n\\t\\t\\t\\t\\t'nh4_n': val[4],\\n\\t\\t\\t\\t\\t'no3_n': val[5],\\n\\t\\t\\t\\t\\t'no2_n': val[6],\\n\\t\\t\\t\\t\\t'org_n': val[7],\\n\\t\\t\\t\\t\\t'min_p': val[8],\\n\\t\\t\\t\\t\\t'org_p': val[9],\\n\\t\\t\\t\\t\\t'fcoli': val[10],\\n\\t\\t\\t\\t\\t'description': val[12] if val[12] != 'null' else None # 12 index because extra column\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tseptics.append(sep)\\n\\t\\t\\ti += 1\\n\\n\\t\\tif database == 'project':\\n\\t\\t\\tdb_lib.bulk_insert(project_base.db, project_parmdb.Septic_sep, septics)\\n\\t\\telse:\\n\\t\\t\\tdb_lib.bulk_insert(datasets_base.db, datasets_parmdb.Septic_sep, septics)\",\n \"def read_database():\\n file = tables.open_file(glob.datafile)\\n table_d = file.root.VelibData.dynamic\\n table_s = file.root.VelibData.static\\n n_rows = len(table_d)\\n print \\\"Nrows in dynamic table:\\\", n_rows\\n print \\\"N stations:\\\", len(table_d[0][\\\"last_update\\\"])\\n print \\\"Time of most recent sampling:\\\", \\\\\\n time.asctime(time.localtime(recover_time(table_d[-1][\\\"sample_time\\\"])))\\n print \\\"Nbikes available at most recent sampling:\\\", \\\\\\n table_d[n_rows-1][\\\"available_bikes\\\"]\\n print \\\"Time of last_update at most recent sampling:\\\", \\\\\\n time.asctime(\\n time.localtime(recover_time(table_d[n_rows-1][\\\"last_update\\\"][0])))\\n print \\\"Number arr\\\", table_s[0][\\\"number\\\"]\\n file.close()\",\n \"def read_relations(db, openfile):\\n pass\",\n \"def readVCTPINPUTS(self): \\n #fname= os.environ['VMECFDIR'] +\\\"/CFG/ctp/DB/VALID.CTPINPUTS\\\"\\n fname= os.environ['VMECFDIR'] +\\\"/CFG/ctp/DB/ctpinputs.cfg\\\"\\n try:\\n database=open(fname,\\\"r\\\") \\n except IOError:\\n print \\\"Cannot open \\\",fname\\n return None\\n else:\\n print \\\"File \\\",fname,\\\" open successfuly.\\\"\\n #print \\\"database= \\\",database\\n lines=database.readlines()\\n database.close() \\n #print lines,len(lines) \\n dbinputs=[]\\n count=0\\n #print \\\"look for me if you want different inputs range...\\\"\\n for i in lines:\\n if(i[0] == 'l' and i[1] == '0'): continue\\n if i == \\\"\\\\n\\\": continue\\n if(i[0] != '#'):\\n items=string.split(i)\\n #print 'items= ',items,len(items)\\n if(len(items)<6):\\n print \\\"Error parsing database, not enough items in line:\\\"\\n print items\\n continue\\n #return None\\n if items[3] == 'M': continue\\n count=count+1\\n #if count<6 or count>11 : continue\\n #if count>10 and count<24 : continue\\n #if count<16: continue\\n #if count > 4 and count < 15: continue\\n #if items[3] != '1': continue\\n #if items[2] != \\\"EMCAL\\\": continue\\n #if (items[2] != \\\"SPD\\\") and (items[2] != \\\"T0\\\"): continue\\n flag=1\\n for i in self.detectors:\\n if items[2].find(i)>=0 or i.find(\\\"ALL\\\")>=0:\\n flag=0;\\n break\\n if flag: continue\\n # input not connected\\n if items[7] == '0' and items[3] == '0': continue\\n db={}\\n db['name']=items[0]\\n db['detector']=items[2]\\n db['level']='L'+items[3]\\n db['signature']=items[4]\\n #db['number']=items[5]\\n db['number']=items[7]\\n db['numberDIM']=items[6]\\n db['ctpnum']=items[5]\\n db['Edge'] = items[8]\\n db['Delay'] = items[9]\\n dbinputs.append(db)\\n #print \\\"Adding: \\\", db\\n return dbinputs\",\n \"def ReadPDB (self, pdb_path, db_path):\\n\\n ReadPDBFile (pdb_path, db_path)\\t#\",\n \"def read_file(self):\\n colspecs = [[0, 7]] # for the id\\n names = ['id']\\n for question in self.question_list:\\n colspecs.extend(question.get_column_range())\\n names.extend(question.get_column_names())\\n\\n self.data = pd.read_fwf(self.file, colspecs=colspecs, encoding=self.encoding, names=names, header=None)\\n self.data.fillna(0, inplace=True)\\n self.data = self.data.astype(int)\\n return self.data\",\n \"def _read_input_file(self):\\n pass\",\n \"def readdatabase2(self):\\n fname=\\\"/home/alice/rl/v/vme/ADCI/DB/INPUTS.txt\\\"\\n try:\\n database=open(fname,\\\"r\\\") \\n except IOError:\\n print \\\"Cannot open \\\",fname\\n return None\\n else:\\n print \\\"File \\\",fname,\\\" open successfuly.\\\"\\n #print \\\"database= \\\",database\\n lines=database.readlines()\\n database.close() \\n #print lines,len(lines) \\n dbinputs=[]\\n for i in lines:\\n if(i[0] != '#'):\\n items=string.split(i)\\n #print 'items= ',items,len(items)\\n if(len(items)<6):\\n print \\\"Error parsing database, not enough items in line:\\\"\\n print items\\n return None\\n db={}\\n db['number']=items[0]\\n db['numberDIM']=items[1]\\n db['level']=items[2]\\n db['name']=items[3]\\n db['detector']=items[4]\\n db['signature']=items[5]\\n dbinputs.append(db)\\n return dbinputs\",\n \"def read_database(db_path, db_file, *args):\\n\\n db_filepath = os.path.join(db_path, db_file)\\n\\n # list to store loaded data\\n data_imported = []\\n conn = sqlite3.connect(db_filepath)\\n\\n for data_name in args:\\n\\n\\n info = f'Reading {data_name} from database................'\\n print(info, end=\\\"\\\")\\n data_name_in_db = conn.execute(\\n f\\\"\\\"\\\"SELECT name FROM sqlite_master WHERE type='table' \\n AND name='{data_name}'; \\\"\\\"\\\").fetchall()\\n if data_name_in_db:\\n df = pd.read_sql(f\\\"select * from {data_name}\\\", con=conn)\\n substitute_names(df)\\n # revert single column DataFrame to Series\\n if 'index' in df.columns:\\n df.set_index('index', inplace=True)\\n df = df.squeeze('columns')\\n data_imported.append(df)\\n print('ok')\\n else:\\n data_imported.append(None)\\n print('no data')\\n conn.close()\\n return data_imported #if len(data_imported)>1 else data_imported[0]\",\n \"def loadSQL_beddays(filepath='O:\\\\Administration\\\\\\\\02 - Økonomi og PDK\\\\Medarbejdermapper\\\\Kasper\\\\Focus1 - Ad hoc opgaver\\\\Lungemed sengedage og visitationer\\\\Lungemed.sql'):\\n content = open(filepath, 'r').read()\\n return content\",\n \"def read():\\n with open(DBNAME) as f:\\n foo = pickle.loads(f.read())\\n print foo\",\n \"def loadDatabase ():\\n database = []\\n # Open a file\\n path = \\\"lyd/\\\"\\n dirs = os.listdir( path )\\n \\n # This prints all of the files and directories\\n for file in dirs:\\n if file == \\\".DS_Store\\\": #Mac file\\n continue\\n songdict = {}\\n print (file)\\n Zxx = STFTsignal.getSTFTofFile(path + file) #STFT of the file\\n #mean, eigen and weights are stored in dictionary songdict\\n songdict[\\\"mean\\\"], songdict[\\\"eigen\\\"], songdict[\\\"weights\\\"] = PCA(Zxx)\\n songdict[\\\"name\\\"] = file\\n database.append (songdict) \\n return database\",\n \"def readFromFile(self, inp):\\n f = open(inp, \\\"r\\\")\\n line = f.readline()\\n line = line.strip().split(sep=\\\" \\\", maxsplit=3)\\n self.columns, self.chars, self.pwdLength, _ = line\\n self.columns = int(self.columns)\\n self.pwdLength = int(self.pwdLength)\\n self.func = lmdes\\n line = f.readline()\\n while line != '':\\n pwd, hashV = line.strip().split(sep=\\\" \\\", maxsplit=1)\\n self.table.insert(hashV, pwd)\\n line = f.readline()\\n f.close()\",\n \"def _load_ludb(self, path):\\n signal, info = wfdb.rdsamp(path)\\n self.fs = 500\\n self.lead_match = ['I', 'II', 'III', 'aVR', 'aVL', 'aVF', 'V1', 'V2', 'V3', 'V4', 'V5', 'V6']\\n self.raw_data = np.transpose(np.array([signal]), (2, 0, 1))\\n self.symbol = []\\n self.coords = []\\n for lead in ['i', 'ii', 'iii', 'avr', 'avl', 'avf', 'v1', 'v2', 'v3', 'v4', 'v5', 'v6']:\\n ann_ii = wfdb.rdann(path, extension='atr_{}'.format(lead))\\n symbol_1 = ann_ii.symbol\\n coords_1 = ann_ii.sample\\n if list(np.unique(np.array(symbol_1))) != ['(', ')', 'N', 'p', 't'] and list(np.unique(np.array(symbol_1))) != ['(', ')', 'N', 'p', 't', 'u']:\\n print(\\\"Invalid symbols in ECG annotations.\\\")\\n raise ValueError\\n self.symbol.append(symbol_1)\\n self.coords.append(coords_1)\\n self.label_name = ['(', 'p', ')', '(', 'N', ')', '(', 't', ')']\\n self._generate_beatlabel_from_label()\",\n \"def loadDB(self,dbfilename):\\n \\n db=[]\\n with open(dbfilename,'r',encoding='ISO-8859-1') as dbfilename:\\n dbreader= csv.reader(dbfilename,delimiter=self.sDelimiter )\\n for lFields in dbreader:\\n db.append(lFields)\\n\\n return db\",\n \"def _read_pkl(self, input_file):\\n data = pickle.load(open(input_file, 'rb'))\\n return data\",\n \"def read_data(cls, input_file,quotechar = None):\\n if 'pkl' in str(input_file):\\n lines = load_pickle(input_file)\\n else:\\n lines = input_file\\n return lines\",\n \"def read(filename: str) -> orm.Data:\\n return from_bands_inspect(load(hdf5_file=filename))\",\n \"def read_pfeatures(namefile):\\n db = shelve.open(namefile)\\n hashes = db['hashes']\\n nif = db['nif']\\n year = db['year']\\n pfeatures = db['pfeatures']\\n methodvalues = db['methodvalues']\\n db.close()\\n return hashes, nif, year, pfeatures, methodvalues\",\n \"def _load_file(self):\\n getLogger(__name__).debug(\\\"Loading {} in {} mode.\\\".format(self.filename, self.mode))\\n try:\\n kwargs = {'driver': 'H5FD_CORE'} if self.in_memory else {}\\n self.file = tables.open_file(self.filename, mode='a' if self.mode == 'write' else 'r', **kwargs)\\n except (IOError, OSError):\\n raise\\n\\n # get important cal params\\n self.nominal_wavelength_bins = self.nyquist_wavelengths()\\n\\n # get the beam image\\n self.beamImage = self.file.get_node('/beammap/map').read()\\n self._flagArray = self.file.get_node('/beammap/flag') # The absence of .read() here is correct\\n self.nXPix, self.nYPix = self.beamImage.shape\\n\\n # get the photontable\\n self.photonTable = self.file.get_node('/photons/photontable')\",\n \"def read_opsim_db(opsim_db_path='/global/projecta/projectdirs/lsst/groups/SSim/DC2/minion_1016_desc_dithered_v4.db'):\\n conn = sqlite3.connect(opsim_db_path)\\n # Check the table names\\n cursor = conn.cursor()\\n cursor.execute(\\\"SELECT name FROM sqlite_master WHERE type='table';\\\")\\n table_names = cursor.fetchall()\\n print(table_names)\\n # Turn table into Pandas df\\n obs_history = pd.read_sql(sql=\\\"SELECT * from ObsHistory\\\", con=conn, index_col=None)\\n field = pd.read_sql(sql=\\\"SELECT * from Field\\\", con=conn, index_col=None)\\n return obs_history, field\",\n \"def read_ppdb(fname):\\n\\tlst=[]\\n\\twith open(fname) as fp:\\n\\t\\tfor line in fp:\\n\\t\\t\\ttmp1,tmp2,tmp3=line.split('|||')[:3]\\n\\t\\t\\ttmp1=tmp1.strip(' ')\\n\\t\\t\\ttmp2=tmp2.strip(' ')\\n\\t\\t\\ttmp3=tmp3.strip(' ')\\n\\t\\t\\tlst.append([tmp1,tmp2,tmp3])\\n\\t#lst.sort()t\\n\\treturn lst\",\n \"def load_file():\\n global list_of_table, data_base, new_data\\n open_name = askopenfilename()\\n\\n if Path(open_name).suffix == '.db':\\n data_base = open_name\\n data_base = str(data_base)\\n new_data_base = parse(data_base)\\n new_data = update_list_tables(new_data_base)\\n new_data.clear()\\n\\n else:\\n mistake_db_file()\",\n \"def read_database(self):\\n # open the database\\n f = open('KISS_LINES','r')\\n # make a list which will contain lines\\n tlc = []\\n for row in f:\\n tlc.append(f.readline())\\n f.close()\\n\\n return tlc\",\n \"def readLBOMDIN(self):\\n logger = logging.getLogger(__name__)\\n\\n if os.path.exists(\\\"lbomd.IN\\\"):\\n f = open(\\\"lbomd.IN\\\")\\n\\n try:\\n f.readline()\\n f.readline()\\n f.readline()\\n f.readline()\\n\\n line = f.readline().strip()\\n array = line.split()\\n try:\\n PBC = [0] * 3\\n PBC[0] = int(array[0])\\n PBC[1] = int(array[1])\\n PBC[2] = int(array[2])\\n\\n except IndexError:\\n logger.warning(\\\"Index error 2 (check lbomd.IN format)\\\")\\n\\n except Exception:\\n err = \\\"Read lbomd.IN failed with error:\\\\n\\\\n%s\\\" % \\\"\\\".join(traceback.format_exception(*sys.exc_info()))\\n self.displayError(err)\\n\\n finally:\\n f.close()\",\n \"def Read_Palik_Al2O3_d():\\n fid = open('/Users/simonvassant/TheseSave/PaliK_Opticalconstant/Al2O3_B_Palik.dat','r')\\n L,eps = [],[]\\n while 1: \\n line = fid.readline()\\n if line =='': \\n break \\n else :\\n L.append(float(line[18:25]))\\n eps.append((float(line[74:81])+1j*float(line[82:]))**2)\\n return np.array(L),np.array(eps)\",\n \"def read_input_file(file_name):\\n with open(file_name, 'r') as file_handle:\\n\\n rows, cols, drones, turns, max_payload = map(int, file_handle.readline().strip().split(' '))\\n num_prod_types = int(file_handle.readline())\\n\\n product_weights = map(int, file_handle.readline().strip().split(' '))\\n assert num_prod_types == len(product_weights)\\n\\n num_warehouses = int(file_handle.readline())\\n warehouse_locations = [None] * num_warehouses\\n warehouse_stock = [None] * num_warehouses\\n for w_id in xrange(num_warehouses):\\n warehouse_locations[w_id] = map(int, file_handle.readline().strip().split(' '))\\n warehouse_stock[w_id] = map(int, file_handle.readline().strip().split(' '))\\n\\n if DEBUG:\\n print 'Warehouse locations', warehouse_locations[:2]\\n print 'Warehouse stock', warehouse_stock[:2]\\n\\n num_orders = int(file_handle.readline())\\n order_locations = [None] * num_orders\\n order_items = [None] * num_orders\\n for o_id in xrange(num_orders):\\n order_locations[o_id] = map(int, file_handle.readline().strip().split(' '))\\n order_len = int(file_handle.readline())\\n order_items[o_id] = map(int, file_handle.readline().strip().split(' '))\\n assert order_len == len(order_items[o_id])\\n\\n if DEBUG:\\n print 'Order locations', order_locations[:2]\\n print 'Order items', order_items[:2]\\n\\n file_handle.close()\\n\\n return (rows, cols), \\\\\\n drones, turns, max_payload, \\\\\\n warehouse_locations, warehouse_stock, \\\\\\n order_locations, order_items, product_weights\",\n \"def open_input_files(self):\\n self.dictionaryFile = open(self.dictionaryFile, 'r', encoding=self.encoding)\\n\\n if self.annotationFile :\\n self.annotationFile = open(self.annotationFile, 'r', encoding=self.encoding)\\n elif self.annotationFile is None:\\n try:\\n self.annotationFile = open(os.path.join(self.dictionaryPath, self.dictionaryName + '.ann'), 'r', encoding=self.encoding)\\n except FileNotFoundError:\\n if self.verbose >= 2:\\n sys.stdout.write (\\\"Warning: annotation file is not found.\\\\n\\\")\\n\\n if self.abbreviationsFile :\\n self.abbreviationsFile = open(self.abbreviationsFile, 'r', encoding=self.encoding)\\n elif self.abbreviationsFile is None:\\n try:\\n self.abbreviationsFile = open(os.path.join(self.dictionaryPath, self.dictionaryName + '_abrv.dsl'), 'r', encoding=self.encoding)\\n except FileNotFoundError:\\n if self.verbose >= 2:\\n sys.stdout.write (\\\"Warning: abbreviations file is not found.\\\\n\\\")\",\n \"def read_df_from_binary(file_name_mask):\\n data = read_matrix_from_binary(file_name_mask + '-value.bin')\\n with open(file_name_mask + '-name.txt', 'r') as f:\\n index = f.readline().strip().split('\\\\t')\\n columns = f.readline().strip().split('\\\\t')\\n return pandas.DataFrame(data=data, index=index, columns=columns)\",\n \"def read_db(self):\\n with open(self.filename, 'r') as database:\\n data = json.load(database)\\n self.data = data\",\n \"def readMAXIPOLdataLuis(filename):\\n\\n ia=[]; ja=[]\\n i=[]; j=[]; beam=[]; sig=[]; cts=[]\\n for line in open(filename, \\\"r\\\"):\\n line = line.strip().split()\\n i1, j1, b1, s1, c1 = (int(line[0]), int(line[1]), \\n float(line[2]), float(line[3]), int(line[4]))\\n ia.append(i1); ja.append(j1)\\n if b1 != 0 and s1 !=0:\\n ## only keep pixels with data\\n i.append(i1); j.append(j1); beam.append(b1)\\n sig.append(s1); cts.append(c1)\\n\\n beam = asarray(beam, float64)\\n sig = asarray(sig, float64)\\n ## map i and j (before deletion) onto (-1,1)\\n x = array([2*(ii-min(ia))/(max(ia)-min(ia))-1 for ii in i], float64)\\n y = array([2*(jj-min(ja))/(max(ja)-min(ja))-1 for jj in j], float64)\\n\\n return BeamData(x, y, beam, sig, cts=cts)\",\n \"def readDataFromFile(self):\\n #import pdb; pdb.set_trace()\\n if self.wantAnyDbm:\\n try:\\n if os.path.exists(self.filepath):\\n self.data = anydbm.open(self.filepath,'w')\\n self.notify.debug('Opening existing anydbm database at: %s.' % \\\\\\n (self.filepath,))\\n else:\\n self.data = anydbm.open(self.filepath,'c')\\n self.notify.debug('Creating new anydbm database at: %s.' % \\\\\\n (self.filepath,))\\n except anydbm.error:\\n self.notify.warning('Cannot open anydbm database at: %s.' % \\\\\\n (self.filepath,))\\n \\n else:\\n try:\\n # Try to open the backup file:\\n file = open(self.filepath + '.bu', 'r')\\n self.notify.debug('Opening backup pickle data file at %s.' % \\\\\\n (self.filepath+'.bu',))\\n # Remove the (assumed) broken file:\\n if os.path.exists(self.filepath):\\n os.remove(self.filepath)\\n except IOError:\\n # OK, there's no backup file, good.\\n try:\\n # Open the real file:\\n file = open(self.filepath, 'r')\\n self.notify.debug('Opening old pickle data file at %s..' % \\\\\\n (self.filepath,))\\n except IOError:\\n # OK, there's no file.\\n file = None\\n self.notify.debug('New pickle data file will be written to %s.' % \\\\\\n (self.filepath,))\\n if file:\\n data = cPickle.load(file)\\n file.close()\\n self.data = data\\n else:\\n self.data = {}\",\n \"def load(self, input):\",\n \"def testReadDataFile(self):\\n try:\\n blockNameList = []\\n myReader = ParseCifSimple(self.__pathPdbxDataFile, False, 0, 255, \\\"?\\\", self.__logFileName)\\n blockNameList = myReader.GetBlockNames(blockNameList)\\n #\\n for blockName in blockNameList:\\n block = myReader.GetBlock(blockName)\\n tableNameList = []\\n tableNameList = block.GetTableNames(tableNameList)\\n for tableName in tableNameList:\\n table = block.GetTable(tableName)\\n columnNameList = table.GetColumnNames()\\n logger.debug(\\\"Table %s colunms %r\\\", tableName, columnNameList)\\n numRows = table.GetNumRows()\\n rowList = []\\n for iRow in range(0, numRows):\\n row = table.GetRow(iRow)\\n rowList.append(row)\\n logger.debug(\\\"table %s row length %d\\\", tableName, len(rowList))\\n except Exception as e:\\n logger.exception(\\\"Failing with %s\\\", str(e))\\n self.fail()\",\n \"def Read_Al_Palik():\\n fid = open('/Volumes/Stock/PostDoc_Erlangen/DocMatos/Materials_Data_Base/Al_from_Palik.dat','r')\\n L,eps = [],[]\\n while 1: \\n line = fid.readline()\\n if line =='': \\n break \\n else :\\n L.append(float(line[:25]))\\n eps.append(float(line[27:54])+1j*float(line[55:-2]))\\n return np.array(L),np.array(eps)\",\n \"def _read_data(self) -> MMD:\\n\\t\\tif self.config.source_type == SourceType.LOCAL_FILE:\\n\\t\\t\\treturn self._read_files()\\n\\t\\telif self.config.source_type == SourceType.HDFS:\\n\\t\\t\\treturn self._read_hdfs()\\n\\t\\telif self.config.source_type == SourceType.NEO4J:\\n\\t\\t\\treturn self._read_neo4j(self.config.graph_db)\\n\\n\\t\\telse:\\n\\t\\t\\traise NotImplementedError(\\\"The source type {} has not been implemented yet.\\\".format(loader_config.source_type))\",\n \"def loadDb(self,dbContent,base):\\n \\n db = utilities.db2bitarray(dbContent,self.dbSize,1,1,base)\\n db = np.array(db).reshape(self.dbSize,-1)\\n # track the size of each file\\n fileSize = db.shape[-1]\\n \\n return (db,fileSize)\",\n \"def input_data(self):\\n return read_file(self.file_path)\",\n \"def Read_Palik_Al2O3_b():\\n fid = open('/Users/simonvassant/TheseSave/PaliK_Opticalconstant/Al2O3_B_Palik.dat','r')\\n L,eps = [],[]\\n while 1: \\n line = fid.readline()\\n if line =='': \\n break \\n else :\\n L.append(float(line[18:25]))\\n eps.append((float(line[59:65])+1j*float(line[66:73]))**2)\\n return np.array(L),np.array(eps)\",\n \"def readFastaFile(filename):\",\n \"def readInput(in_file_name):\\n in_file = open(in_file_name, 'r')\\n positions = []\\n samples = []\\n M = []; P = [];\\n MC = []; PC = [];\\n while True:\\n line = in_file.readline()\\n if not line: break\\n if line[0] == '#': continue #skip comment\\n line = line.rstrip('\\\\n').split('\\\\t')\\n \\n #genomic positions and allele support in plasma samples\\n positions.append(int(line[0]))\\n samples.append(tuple(map(int, line[1:5])))\\n \\n #maternal and paternal alleles\\n M.append(tuple(line[5:7]))\\n MC.append(tuple(map(float, line[7:9])))\\n \\n P.append(tuple(line[9:11]))\\n PC.append(tuple(map(float, line[11:13]))) \\n \\n in_file.close()\\n return positions, samples, M, P, MC, PC\",\n \"def update_db(db_name=_db_indicators, start=1950, end=dt.datetime.now().year, write_db=True):\\n def read_indicators(pdfI=None, coutries=[], ctry_chunksize=50, write_db=True):\\n print('UPDATE IMF: Start reading {0} indicators'.format(pdfI.shape[0]))\\n #dct_not_data=dict()\\n lst_ret=[]\\n for k, v in pdfI.iterrows():\\n\\n lst_pdf=list()\\n lst_not_country=list()\\n tbl_name=k #'{0}_{1}'.format(k, freq)\\n print('UPDATE IMF ({2}-{3}): reading {0}, tDS={1}\\\\t'.format(k, v['Dataset'], start, end), end='... ')\\n for cs in cmm.iterate_group(coutries, ctry_chunksize):\\n\\n try:\\n pdf = pds.read_imf(strDataSetID=v['Dataset'], indiID=k, countryCode=cs,\\n frequency=v['Freq'], startDate=start, endDate=end)\\n\\n lst_pdf.append(pdf)\\n lst_not_country+=pdf.not_country\\n #print(pdf.name, pdf.shape, len(pdf.not_country))\\n except ValueError as e:\\n lst_not_country += cs\\n\\n #print(e, k, 0, 50)\\n try:\\n pdfC=pds.DataFrameDATA(pd.concat([ppdf for ppdf in lst_pdf if not ppdf.empty]))\\n pdfC.name=tbl_name\\n #dct_not_data.update({'IND_NOT':tbl_name, 'NOT_DATA':lst_not_country})\\n print('read {name},\\\\tlen {len_df},\\\\tnot data countries - {nc}'.format(name=pdfC.name,\\n len_df=pdfC.shape[0],\\n nc=len(lst_not_country)), end='... ')\\n if write_db:\\n print('write to DB...', end='')\\n\\n lstWrite=[c for c in pdfC.columns.tolist() if c !='mult']\\n\\n pdfC[lstWrite].to_sql(pdfC.name, coni, if_exists='upsert')\\n cmm.write_status(db_name, k, pdfC.shape[0], mult=pdfC['mult'].unique()[0])\\n\\n print('done', end='\\\\n')\\n pdfC['INDI']=k\\n lst_ret.append(pdfC)\\n #print(dct_not_data)\\n except ValueError as e:\\n print(e, 'not data for ', k, v['Dataset'], len(cs))\\n\\n return pd.concat(lst_ret)\\n\\n coni = sa.create_engine('sqlite+pysqlite:///{db_name}'.format(db_name=db_name))\\n # pdfIndi=pd.read_sql('select * from INDICATORS where LastUpdateDateA is NULL', coni, index_col='Code')\\n pdfIndi = pd.read_sql('select * from {INDI_NAME}'.format(INDI_NAME=cmm.strINDI_db_name), coni, index_col='Code')#.iloc[:40]\\n pdfCountry = pd.read_sql('select * from {COUNTRY_NAME}'.format(COUNTRY_NAME=cmm.strCOUNTRY_db_name), coni, index_col='id')\\n country_list = pdfCountry.index.tolist()\\n print('UPDATE IMF: reading {0} countries'.format(len(country_list)))\\n\\n pdfQ=read_indicators(pdfI=pdfIndi.sort_index(), coutries=country_list, write_db=write_db)\\n print('=' * 50)\\n\\n print('UPDATE IMF: all done')\\n return pdfQ\",\n \"def read_data(cls, input_file, quotechar=None):\\r\\n if 'pkl' in str(input_file):\\r\\n lines = load_pickle(input_file)\\r\\n else:\\r\\n lines = input_file\\r\\n return lines\",\n \"def read_syn_data():\\n dipy_home = pjoin(os.path.expanduser('~'), '.dipy')\\n folder = pjoin(dipy_home, 'syn_test')\\n t1_name = pjoin(folder, 't1.nii.gz')\\n b0_name = pjoin(folder, 'b0.nii.gz')\\n\\n md5_dict = {'t1': '701bda02bb769655c7d4a9b1df2b73a6',\\n 'b0': 'e4b741f0c77b6039e67abb2885c97a78'}\\n\\n check_md5(t1_name, md5_dict['t1'])\\n check_md5(b0_name, md5_dict['b0'])\\n\\n t1 = nib.load(t1_name)\\n b0 = nib.load(b0_name)\\n return t1, b0\",\n \"def _read(self):\\n # initializng data dictionary\\n self.data={}\\n\\n f = FortranFile(self.filename)\\n # Default omnivor binary header\\n self.data['MK'] = f.readInts('i')\\n self.data['itime'] = f.readInts('i')\\n self.data['version'] = f.readString()\\n self.data['file_id'] = f.readInts('i')\\n self.data['sversion'] = f.readString()\\n # Velocity field\\n self.data['stype'] = f.readString()\\n self.data['is_grid'] = f.readInts('i')\\n nCPs = f.readInts('i')\\n self.data['nCPs'] = nCPs\\n if self.data['MK'] == 8:\\n real_char='d'\\n else:\\n real_char='f'\\n if self.data['is_grid']:\\n #print('File is a velocity grid file')\\n n1 = f.readInts('i')\\n n2 = f.readInts('i')\\n n3 = f.readInts('i')\\n self.data['n1'] = n1\\n self.data['n2'] = n2\\n self.data['n3'] = n3\\n self.data['is_straight'] = f.readInts('i')\\n self.data['v1'] = f.readReals(real_char)\\n self.data['v2'] = f.readReals(real_char)\\n self.data['v3'] = f.readReals(real_char)\\n\\n CPs_raw = f.readReals(real_char)\\n Utot_raw = f.readReals(real_char)\\n CPs = np.reshape(CPs_raw,(3,nCPs),order = 'F')\\n Utot = np.reshape(Utot_raw,(3,nCPs),order = 'F')\\n\\n acc=-1\\n CPsTab = np.zeros((3, n1,n2,n3))\\n UtotTab = np.zeros((3, n1,n2,n3))\\n # Reshaping the nasty way (this is natural order). \\n for i in range(0,n1):\\n for j in range(0,n2):\\n for k in range(0,n3):\\n acc=acc+1\\n CPsTab[0:3,i,j,k] = CPs[0:3,acc]\\n UtotTab[0:3,i,j,k] = Utot[0:3,acc]\\n\\n self.data['CPs'] = CPs\\n self.data['CPsTab'] = CPsTab\\n self.data['Utot'] = Utot\\n self.data['UtotTab'] = UtotTab\",\n \"def read():\\n # TODO\",\n \"def _read_dataset(self):\\n import pandas as pd\\n\\n freesolv_path = get_data_file_path(FREESOLV_PATH)\\n\\n freesolv_db = pd.read_csv(freesolv_path, delimiter=';',\\n skipinitialspace=True,\\n skiprows=[0, 1, 2], header=0,\\n names=['compound id', 'SMILES',\\n 'iupac name',\\n 'experimental value',\\n 'experimental uncertainty',\\n 'calculated value (GAFF)',\\n 'calculated uncertainty',\\n 'experimental reference',\\n 'calculated reference',\\n 'notes'])\\n\\n compound_ids = freesolv_db['compound id'].to_list()\\n smiles_tags = freesolv_db['SMILES'].to_list()\\n experimental_v = freesolv_db['experimental value'].to_list()\\n return compound_ids, smiles_tags, experimental_v\",\n \"def read_pdb_into_database_flat(self, filePath, specific_chain=False, read_header=False, header_only=False, ):\\n if filePath == \\\"PDB\\\":\\n print \\\"Fetching \\\"+self.pdbID+\\\" from the PDB\\\"\\n FILE = urllib2.urlopen(self.pdb_url+'/'+self.pdbID.lower()+'.pdb')\\n else:\\n FILE = open(filePath)\\n line_num = 1\\n with self.db:\\n cur = self.db.cursor()\\n\\n l = 1\\n if read_header:\\n cur.execute(\\\"CREATE TABLE IF NOT EXISTS header(id integer PRIMARY KEY, pdbID TEXT, modelID TEXT, method TEXT, resolution REAL, species TEXT, engineered TEXT, protein TEXT)\\\")\\n if not header_only:\\n cur.execute(\\\"CREATE TABLE IF NOT EXISTS pdb(l integer PRIMARY KEY, pdbID TEXT, modelID TEXT, strucID INT, type TEXT, atomNum INT, atomName TEXT, altLoc TEXT, residue TEXT, chain TEXT, resNum INT, icode TEXT, x REAL, y REAL, z REAL, occupancy REAL, bfactor REAL)\\\")\\n print \\\"Tables created. Loading \\\"+self.pdbID+\\\" data into table.\\\"\\n for line in FILE:\\n line = line.strip()\\n lineSP = line.split()\\n if not header_only:\\n if (lineSP[0]==\\\"ATOM\\\" or lineSP[0]==\\\"HETATM\\\"):\\n\\n #Only copy a specific chain into the database.\\n if not specific_chain:\\n pass\\n else:\\n if specific_chain != line[21].strip():\\n continue\\n\\n\\n cur.execute(\\\"INSERT INTO pdb VALUES(NULL, ?, ?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)\\\", \\\\\\n (self.pdbID, self.modelID, self.structID, lineSP[0], \\\\\\n\\n\\n #atomNum INT atomName TEXT altLoc TEXT residue TEXT\\n line[6:11].strip(), line[12:16], line[16], line[17:21].strip(), \\\\\\n #chain TEXT resNum INT icode TEXT x REAL\\n line[21].strip(), line[22:26].strip(), line[26], line[27:38].strip(), \\\\\\n #y REAL z REAL occupancy REAL bfactor REAL\\n line[38:46].strip(), line[46:54].strip(), line[54:60].strip(), line[60:66].strip()))\\n l+=1\\n\\n\\n\\n #self.stripped_pdb[line_num][\\\"element\\\"]=line[66:78].strip(); self.stripped_pdb[line_num][\\\"charge\\\"]=line[78:79].strip())\",\n \"def schema_load(filename):\\n print(uc.schema_load(filename))\",\n \"def __init__(self):\\n f = open(configuration.dataDirectory+'Muon_ID_iso_Efficiencies_Run_2012ABCD_53X.pkl', 'r')\\n if f :\\n self._map = pickle.load(f)\\n self._range = ''\\n else :\\n print 'ERROR: Input file for muon SF not existing!'\",\n \"def read_all_odbsql_stn_withfeedback(dataset, odbfile):\\n columns, kinds, tdict = make_odb_header(odbfile, dataset) \\n try: \\n t=time.time() \\n try:\\n f=gzip.open(odbfile) \\n except:\\n print(odbfile, 'The zipped ODB file was not found !')\\n return\\n \\n #d=['date@hdr','time@hdr','statid@hdr','vertco_reference_1@body','varno@body','reportype','andate','antime',\\n # 'obsvalue@body','fg_depar@body','an_depar@body','biascorr@body','sonde_type@conv','collection_identifier@conv','source@hdr']\\n \\n # had to remove 'collection_identifier@conv' to make it work with 1, 3188, 1759, 1761 \\n \\n tdict['sensor@hdr']=numpy.float32\\n tdict['ppcode@conv_body']=numpy.float32\\n \\n '''\\n d=['date@hdr','time@hdr','statid@hdr','vertco_reference_1@body','varno@body','lon@hdr','lat@hdr','seqno@hdr',\\n 'obsvalue@body','source@hdr' , 'vertco_type@body']\\n \\n if 'fg_depar@body' in columns: # creating the colkumns for era5fb \\n d=d+['fg_depar@body','an_depar@body','biascorr@body','sonde_type@conv','reportype','andate','antime']\\n '''\\n \\n# restrict feedback to certain columns \\n #for c in columns:\\n # if c not in d:\\n # del tdict[c]\\n \\n #columns=d.copy()\\n \\n alldict=pd.read_csv(f,delimiter='\\\\t', usecols=columns, quoting=3,comment='#', skipinitialspace=True, dtype=tdict) #nrows=1000000)\\n \\n \\\"\\\"\\\" Case where erafb is not available \\\"\\\"\\\"\\n if 'fg_depar@body' not in columns:\\n alldict['fg_depar@body']=numpy.float32(numpy.NaN)\\n alldict['an_depar@body']=numpy.float32(numpy.NaN)\\n alldict['biascorr@body']=numpy.float32(numpy.NaN)\\n alldict['sondetype@conv']=numpy.int32(-2147483648)\\n alldict['reportype']=numpy.int32(-2147483648)\\n \\n #print(time.time()-t,sys.getsizeof(alldict)//1024//1024)\\n idx=numpy.where(numpy.logical_or(alldict.reportype.values==16045,alldict.reportype.values==16068))[0]\\n if len(idx)>0:\\n \\n #alldict.drop(index=alldict.index[idx],inplace=True)\\n y=numpy.int64(alldict['date@hdr'].values)*1000000+alldict['time@hdr'].values\\n x=numpy.unique(y)\\n dropindex=[]\\n for i in range(1,x.shape[0]):\\n if x[i]-x[i-1]<60:\\n idx=numpy.where(y==x[i-1])[0]\\n if idx.shape[0]>0:\\n dropindex.append(idx)\\n else:\\n print('empty index')\\n if dropindex: \\n dropindex = numpy.concatenate(dropindex).ravel()\\n alldict.drop(index=alldict.index[dropindex],inplace=True)\\n \\n #print(time.time()-t) #,sys.getsizeof(alldict)//1024//1024)\\n \\n #idx=numpy.where(alldict.reportype.values==16045)[0]\\n #if idx.shape[0]>0:\\n #idy=numpy.where(numpy.logical_and(alldict.reportype.values!=16045,alldict.reportype.values!=16068))[0]\\n #if idy.shape[0]>0:\\n #idz=numpy.isin(alldict.andate.values[idy],alldict.andate.values[idx])\\n #if numpy.sum(idz)>0:\\n #alldict.drop(index=alldict.index[idy[idz]],inplace=True)\\n \\n #idx=numpy.where(alldict.reportype.values==16068)[0]\\n #if idx.shape[0]>0:\\n #idy=numpy.where(numpy.logical_and(alldict.reportype.values!=16045,alldict.reportype.values!=16068))[0]\\n #if idy.shape[0]>0:\\n #idz=numpy.isin(alldict.andate.values[idy],alldict.andate.values[idx])\\n #if numpy.sum(idz)>0:\\n #alldict.drop(index=alldict.index[idy[idz]],inplace=True)\\n \\n \\n #print(time.time()-t,sys.getsizeof(alldict)//1024//1024)\\n \\n alldict['source_id'] = dataset.rjust(10)\\n\\n for c in alldict.columns:\\n \\n if type(alldict[c].iloc[0]) in [str,bytes]:\\n l=alldict[c].shape[0]\\n slen=len(alldict[c].values[0])\\n alldict[c]=numpy.array(alldict.pop(c).values,dtype='S{}'.format(slen))\\n #alldict[c]=numpy.string_(alldict[c])\\n \\n if type(alldict[c].iloc[0]) is numpy.int64:\\n alldict[c]=numpy.int32(alldict[c])\\n \\n if type(alldict[c].iloc[0]) is numpy.float64:\\n alldict[c]=numpy.float32(alldict[c])\\n \\n #print('after odb:',time.time()-t)\\n \\n except MemoryError:\\n print('Reading ODB failed ! ' + odbfile)\\n return alldict\\n \\n #print(odbfile,time.time()-t)#, sys.getsizeof(alldict))\\n\\n \\n return alldict\",\n \"def read_file(path_to_file):\\n 8\",\n \"def load_inputs():\\n\\n print \\\"Daily inputs\\\"\\n\\n Daily_Input.query.delete()\\n\\n\\n for row in open(\\\"seed_data/u.input.txt\\\"):\\n row = row.rstrip()\\n input_id, date, user_id, sleep, exercise, screen_time, well_being_rating = row.split(\\\"|\\\")\\n\\n date = datetime.strptime(date, \\\"%m-%d-%y\\\")\\n \\n daily_input = Daily_Input(input_id=input_id, date=date, user_id=user_id, sleep=sleep, exercise=exercise, screen_time=screen_time, well_being_rating=well_being_rating)\\n db.session.add(daily_input)\\n\\n db.session.commit()\",\n \"def _read_data(self):\",\n \"def import_db(import_file):\\n import_data(import_file)\",\n \"def db(filename = 'P51-11'):\\n import pdb\\n sys.argv[1:] = ['-v', filename]\\n pdb.run('extract.main()')\",\n \"def test_readfile(self):\\n fname = os.path.join(self.datadir, 'monol_testA_E3-50_rebin4_gti') + \\\\\\n HEN_FILE_EXTENSION\\n command = \\\"{0}\\\".format(fname)\\n\\n hen.io.main(command.split())\",\n \"def read_db():\\n\\n # Look for database in the same folder as this script\\n script_dir = os.path.dirname(os.path.realpath(__file__))\\n db_filepath = os.path.join(script_dir, 'cn_loads_database.dat')\\n\\n db = None\\n if os.path.isfile(db_filepath):\\n with open(db_filepath, 'r') as f:\\n db = yaml.load(f.read())\\n if db == None:\\n db = dict()\\n else:\\n db = dict()\\n\\n return db\",\n \"def Read_Palik_Al2O3_a():\\n fid = open('/Users/simonvassant/TheseSave/PaliK_Opticalconstant/Al2O3_B_Palik.dat','r')\\n L,eps = [],[]\\n while 1: \\n line = fid.readline()\\n if line =='': \\n break \\n else :\\n L.append(float(line[18:25]))\\n eps.append((float(line[26:34])+1j*float(line[35:40]))**2)\\n return np.array(L),np.array(eps)\",\n \"def read_data(feature_file, label_file):\",\n \"def get_demand_data():\\r\\n with open(\\\"{}DEMAND.txt\\\".format(db_folder_path), \\\"r\\\", encoding=\\\"utf8\\\") as demand_file:\\r\\n return eval(demand_file.read(), {'__builtins__':None}, {})\",\n \"def read_password_db(fname='input.txt'):\\n with open(fname) as fp:\\n matches = [regex.match(line) for line in fp.readlines()]\\n \\n passwords = [{\\n 'num_1': int(m.group(1)),\\n 'num_2': int(m.group(2)),\\n 'character': m.group(3),\\n 'password': m.group(4)\\n } for m in matches]\\n \\n return passwords\",\n \"def open_input(self):\\n gdal.SetConfigOption(\\\"GDAL_PAM_ENABLED\\\", \\\"YES\\\")\\n gdal.AllRegister()\\n # self.options.verbose=True\\n if self.options.tms_osm:\\n self.s_y_type=\\\"osm\\\"\\n else:\\n self.s_y_type=\\\"tms\\\"\\n if self.options.verbose:\\n print \\\"open_input :\\\", self.input,\\\" osm[\\\",self.options.tms_osm,\\\",\\\",self.s_y_type,\\\"] mbtiles[\\\",self.options.mbtiles,\\\"] mbtiles_todisk[\\\",self.options.mbtiles_todisk,\\\"] mbtiles_fromdisk[\\\",self.options.mbtiles_fromdisk,\\\"]\\\";\\n # Open the input file\\n if self.input:\\n self.in_ds = gdal.Open(self.input, gdal.GA_ReadOnly)\\n else:\\n raise Exception(\\\"No input file was specified\\\")\\n\\n if self.options.verbose:\\n print \\\"Input file:\\\", \\\"( %sP x %sL - %s bands)\\\" % (self.in_ds.RasterXSize, self.in_ds.RasterYSize, self.in_ds.RasterCount)\\n\\n if not self.in_ds:\\n # Note: GDAL prints the ERROR message too\\n self.error(\\\"It is not possible to open the input file '%s'.\\\" % self.input )\\n\\n # Read metadata from the input file\\n if self.in_ds.RasterCount == 0:\\n self.error( \\\"Input file '%s' has no raster band\\\" % self.input )\\n\\n if self.in_ds.GetRasterBand(1).GetRasterColorTable():\\n # TODO: Process directly paletted dataset by generating VRT in memory\\n self.error( \\\"Please convert this file to RGB/RGBA and run gdal2mbtiles on the result.\\\",\\n \\\"\\\"\\\"From paletted file you can create RGBA file (temp.vrt) by:\\ngdal_translate -of vrt -expand rgba %s temp.vrt\\nthen run:\\ngdal2mbtiles temp.vrt\\\"\\\"\\\" % self.input )\\n\\n # Get NODATA value\\n # User supplied values overwrite everything else.\\n if self.options.srcnodata is not None:\\n nds = map(float, self.options.srcnodata.split(','))\\n if len(nds) < self.in_ds.RasterCount:\\n self.in_nodata = (nds * self.in_ds.RasterCount)[:self.in_ds.RasterCount]\\n else:\\n self.in_nodata = nds\\n else:\\n # If the source dataset has NODATA, use it.\\n self.in_nodata = []\\n for i in range(1, self.in_ds.RasterCount+1):\\n if self.in_ds.GetRasterBand(i).GetNoDataValue() != None:\\n self.in_nodata.append( self.in_ds.GetRasterBand(i).GetNoDataValue() )\\n\\n if self.options.verbose:\\n print \\\"NODATA: %s\\\" % self.in_nodata\\n\\n # INIT DEST\\n if self.options.init_dest is not None:\\n if self.options.tile_format == \\\"jpeg\\\":\\n if self.in_ds.RasterCount == 4:\\n nbands = 3\\n else:\\n nbands = self.in_ds.RasterCount\\n\\n nds = map(float, self.options.init_dest.split(','))\\n\\n if len(nds) == 1:\\n init_dest = nds * nbands\\n elif len(nds) == nbands:\\n init_dest = nds\\n else:\\n print \\\"WARNING: you suplied %d '--init-dest' values but the dataset has %d data bands\\\" % (len(nds), nbands)\\n init_dest = None\\n else:\\n init_dest = None\\n print \\\"WARNING: --init-dest can be used only with 'jpeg' tile format\\\"\\n else:\\n if self.options.tile_format == \\\"jpeg\\\":\\n init_dest = [255,255,255]\\n else:\\n init_dest = None\\n\\n #\\n # Here we should have RGBA input dataset opened in self.in_ds\\n #\\n\\n if self.options.verbose:\\n print \\\"Preprocessed file:\\\", \\\"( %sP x %sL - %s bands)\\\" % (self.in_ds.RasterXSize, self.in_ds.RasterYSize, self.in_ds.RasterCount)\\n\\n # Spatial Reference System of the input raster\\n\\n\\n self.in_srs = None\\n\\n if self.options.s_srs:\\n self.in_srs = osr.SpatialReference()\\n self.in_srs.SetFromUserInput(self.options.s_srs)\\n self.in_srs_wkt = self.in_srs.ExportToWkt()\\n else:\\n self.in_srs_wkt = self.in_ds.GetProjection()\\n if not self.in_srs_wkt and self.in_ds.GetGCPCount() != 0:\\n self.in_srs_wkt = self.in_ds.GetGCPProjection()\\n if self.in_srs_wkt:\\n self.in_srs = osr.SpatialReference()\\n self.in_srs.ImportFromWkt(self.in_srs_wkt)\\n #elif self.options.profile != 'raster':\\n # self.error(\\\"There is no spatial reference system info included in the input file.\\\",\\\"You should run gdal2mbtiles with --s_srs EPSG:XXXX or similar.\\\")\\n\\n # Spatial Reference System of tiles\\n\\n self.out_srs = osr.SpatialReference()\\n\\n if self.options.profile == 'mercator':\\n self.out_srs.ImportFromEPSG(900913)\\n elif self.options.profile in ('geodetic', 'gearth', 'garmin'):\\n self.out_srs.ImportFromEPSG(4326)\\n else:\\n self.out_srs = self.in_srs\\n\\n # Are the reference systems the same? Reproject if necessary.\\n\\n self.out_ds = None\\n\\n if self.options.profile in ('mercator', 'geodetic', 'gearth', 'garmin'):\\n\\n if (self.in_ds.GetGeoTransform() == (0.0, 1.0, 0.0, 0.0, 0.0, 1.0)) and (self.in_ds.GetGCPCount() == 0):\\n self.error(\\\"There is no georeference - neither affine transformation (worldfile) nor GCPs. You can generate only 'raster' profile tiles.\\\",\\n \\\"Either gdal2mbtiles with parameter -p 'raster' or use another GIS software for georeference e.g. gdal_transform -gcp / -a_ullr / -a_srs\\\")\\n\\n if self.in_srs:\\n\\n if (self.in_srs.ExportToProj4() != self.out_srs.ExportToProj4()) or (self.in_ds.GetGCPCount() != 0):\\n\\n # Generation of VRT dataset in tile projection, default 'nearest neighbour' warping\\n self.out_ds = gdal.AutoCreateWarpedVRT( self.in_ds, self.in_srs_wkt, self.out_srs.ExportToWkt() )\\n\\n # TODO: HIGH PRIORITY: Correction of AutoCreateWarpedVRT according the max zoomlevel for correct direct warping!!!\\n\\n if self.options.verbose:\\n print \\\"Warping of the raster by AutoCreateWarpedVRT (result saved into 'tiles.vrt')\\\"\\n self.out_ds.GetDriver().CreateCopy(\\\"tiles.vrt\\\", self.out_ds)\\n\\n # Note: self.in_srs and self.in_srs_wkt contain still the non-warped reference system!!!\\n\\n # Correction of AutoCreateWarpedVRT for NODATA values\\n if self.in_nodata != []:\\n import tempfile\\n tempfilename = tempfile.mktemp('-gdal2mbtiles.vrt')\\n self.out_ds.GetDriver().CreateCopy(tempfilename, self.out_ds)\\n # open as a text file\\n s = open(tempfilename).read()\\n # Add the warping options\\n s = s.replace(\\\"\\\"\\\"<GDALWarpOptions>\\\"\\\"\\\",\\\"\\\"\\\"<GDALWarpOptions>\\n <Option name=\\\"UNIFIED_SRC_NODATA\\\">YES</Option>\\n <Option name=\\\"INIT_DEST\\\">NO_DATA</Option>\\\"\\\"\\\")\\n # replace BandMapping tag for NODATA bands....\\n if init_dest is None:\\n dstnodata = self.in_nodata\\n else:\\n dstnodata = init_dest\\n for i in range(len(self.in_nodata)):\\n s = s.replace(\\\"\\\"\\\"<BandMapping src=\\\"%i\\\" dst=\\\"%i\\\"/>\\\"\\\"\\\" % ((i+1),(i+1)),\\\"\\\"\\\"<BandMapping src=\\\"%i\\\" dst=\\\"%i\\\">\\n <SrcNoDataReal>%i</SrcNoDataReal>\\n <SrcNoDataImag>0</SrcNoDataImag>\\n <DstNoDataReal>%i</DstNoDataReal>\\n <DstNoDataImag>0</DstNoDataImag>\\n </BandMapping>\\\"\\\"\\\" % ((i+1), (i+1), self.in_nodata[i], dstnodata[i]))\\n # save the corrected VRT\\n open(tempfilename,\\\"w\\\").write(s)\\n # open by GDAL as self.out_ds\\n self.out_ds = gdal.Open(tempfilename) #, gdal.GA_ReadOnly)\\n # delete the temporary file\\n os.unlink(tempfilename)\\n\\n # set NODATA_VALUE metadata\\n self.out_ds.SetMetadataItem('NODATA_VALUES','%s' % \\\" \\\".join(str(int(f)) for f in self.in_nodata))\\n\\n if self.options.verbose:\\n print \\\"Modified warping result saved into 'tiles1.vrt'\\\"\\n open(\\\"tiles1.vrt\\\",\\\"w\\\").write(s)\\n\\n # -----------------------------------\\n # Correction of AutoCreateWarpedVRT for Mono (1 band) and RGB (3 bands) files without NODATA:\\n # equivalent of gdalwarp -dstalpha\\n elif self.in_nodata == [] and self.out_ds.RasterCount in (1,3):\\n import tempfile\\n tempfilename = tempfile.mktemp('-gdal2mbtiles.vrt')\\n self.out_ds.GetDriver().CreateCopy(tempfilename, self.out_ds)\\n # open as a text file\\n s = open(tempfilename).read()\\n # Add the warping options\\n s = s.replace(\\\"\\\"\\\"<BlockXSize>\\\"\\\"\\\",\\\"\\\"\\\"<VRTRasterBand dataType=\\\"Byte\\\" band=\\\"%i\\\" subClass=\\\"VRTWarpedRasterBand\\\">\\n <ColorInterp>Alpha</ColorInterp>\\n </VRTRasterBand>\\n <BlockXSize>\\\"\\\"\\\" % (self.out_ds.RasterCount + 1))\\n s = s.replace(\\\"\\\"\\\"</GDALWarpOptions>\\\"\\\"\\\", \\\"\\\"\\\"<DstAlphaBand>%i</DstAlphaBand>\\n </GDALWarpOptions>\\\"\\\"\\\" % (self.out_ds.RasterCount + 1))\\n if init_dest is None:\\n init_dest_str = \\\"0\\\"\\n else:\\n init_dest_str = \\\",\\\".join(str(f) for f in init_dest)\\n s = s.replace(\\\"\\\"\\\"</WorkingDataType>\\\"\\\"\\\", \\\"\\\"\\\"</WorkingDataType>\\n <Option name=\\\"INIT_DEST\\\">%s</Option>\\\"\\\"\\\" % init_dest_str)\\n # save the corrected VRT\\n open(tempfilename,\\\"w\\\").write(s)\\n # open by GDAL as self.out_ds\\n self.out_ds = gdal.Open(tempfilename) #, gdal.GA_ReadOnly)\\n # delete the temporary file\\n os.unlink(tempfilename)\\n\\n if self.options.verbose:\\n print \\\"Modified -dstalpha warping result saved into 'tiles1.vrt'\\\"\\n open(\\\"tiles1.vrt\\\",\\\"w\\\").write(s)\\n\\n elif init_dest is not None:\\n import tempfile\\n tempfilename = tempfile.mktemp('-gdal2mbtiles.vrt')\\n self.out_ds.GetDriver().CreateCopy(tempfilename, self.out_ds)\\n # open as a text file\\n s = open(tempfilename).read()\\n # Add the warping options\\n s = s.replace(\\\"\\\"\\\"</WorkingDataType>\\\"\\\"\\\", \\\"\\\"\\\"</WorkingDataType>\\n <Option name=\\\"INIT_DEST\\\">%s</Option>\\\"\\\"\\\" % \\\",\\\".join(str(f) for f in init_dest))\\n # save the corrected VRT\\n open(tempfilename,\\\"w\\\").write(s)\\n # open by GDAL as self.out_ds\\n self.out_ds = gdal.Open(tempfilename) #, gdal.GA_ReadOnly)\\n # delete the temporary file\\n os.unlink(tempfilename)\\n\\n if self.options.verbose:\\n print \\\"Modified warping result saved into 'tiles1.vrt'\\\"\\n open(\\\"tiles1.vrt\\\",\\\"w\\\").write(s)\\n\\n # For raster with 4-bands: 4th unknown band set to alpha\\n if (self.out_ds.RasterCount == 4\\n and self.out_ds.GetRasterBand(4).GetRasterColorInterpretation() == gdal.GCI_Undefined):\\n self.out_ds.GetRasterBand(4).SetRasterColorInterpretation(gdal.GCI_AlphaBand)\\n\\n s = '''\\n '''\\n\\n else:\\n self.error(\\\"Input file has unknown SRS.\\\", \\\"Use --s_srs ESPG:xyz (or similar) to provide source reference system.\\\" )\\n\\n if self.out_ds and self.options.verbose:\\n print \\\"Projected file:\\\", \\\"tiles.vrt\\\", \\\"( %sP x %sL - %s bands)\\\" % (self.out_ds.RasterXSize, self.out_ds.RasterYSize, self.out_ds.RasterCount)\\n\\n if not self.out_ds:\\n self.out_ds = self.in_ds\\n\\n #\\n # Here we should have a raster (out_ds) in the correct Spatial Reference system\\n #\\n\\n # KML test\\n self.isepsg4326 = False\\n srs4326 = osr.SpatialReference()\\n srs4326.ImportFromEPSG(4326)\\n if self.out_srs and srs4326.ExportToProj4() == self.out_srs.ExportToProj4():\\n self.kml = True\\n self.isepsg4326 = True\\n if self.options.verbose:\\n print \\\"KML autotest OK!\\\"\\n\\n # Read the georeference\\n\\n self.out_gt = self.out_ds.GetGeoTransform()\\n\\n #originX, originY = self.out_gt[0], self.out_gt[3]\\n #pixelSize = self.out_gt[1] # = self.out_gt[5]\\n\\n # Test the size of the pixel\\n\\n # MAPTILER - COMMENTED\\n #if self.out_gt[1] != (-1 * self.out_gt[5]) and self.options.profile != 'raster':\\n # TODO: Process corectly coordinates with are have swichted Y axis (display in OpenLayers too)\\n #self.error(\\\"Size of the pixel in the output differ for X and Y axes.\\\")\\n\\n # Report error in case rotation/skew is in geotransform (possible only in 'raster' profile)\\n if (self.out_gt[2], self.out_gt[4]) != (0,0):\\n self.error(\\\"Georeference of the raster contains rotation or skew. Such raster is not supported. Please use gdalwarp first.\\\")\\n # TODO: Do the warping in this case automaticaly\\n\\n #\\n # Here we expect: pixel is square, no rotation on the raster\\n #\\n\\n # Output Bounds - coordinates in the output SRS\\n self.ominx = self.out_gt[0]\\n self.omaxx = self.out_gt[0]+self.out_ds.RasterXSize*self.out_gt[1]\\n self.omaxy = self.out_gt[3]\\n self.ominy = self.out_gt[3]-self.out_ds.RasterYSize*self.out_gt[1]\\n # Note: maybe round(x, 14) to avoid the gdal_translate behaviour, when 0 becomes -1e-15\\n # user defined bounds to extract - coordinates in the output SRS\\n if self.options.te_bounds != '':\\n if self.te_minx >= self.ominx and self.te_minx <= self.omaxx:\\n if self.te_maxx >= self.ominx and self.te_maxx <= self.omaxx:\\n if self.te_miny >= self.ominy and self.te_miny <= self.omaxy:\\n if self.te_maxy >= self.ominy and self.te_maxy <= self.omaxy:\\n # replace only if inside the read bounds\\n self.ominx = self.te_minx\\n self.omaxx = self.te_maxx\\n self.ominy = self.te_miny\\n self.omaxy = self.te_maxy\\n if self.options.verbose:\\n print \\\"User defined Bounds (output srs) have been set:\\\", round(self.ominx, 13), self.ominy, self.omaxx, self.omaxy\\n\\n if self.options.verbose:\\n print \\\"Bounds (output srs):\\\", round(self.ominx, 13), self.ominy, self.omaxx, self.omaxy\\n\\n if self.options.mbtiles:\\n self.options.profile = 'mercator'\\n if self.options.profile == 'mercator':\\n self.mercator = GlobalMercator(self.options.tms_osm) # from globalmaptiles.py\\n\\n #\\n # Calculating ranges for tiles in different zoom levels\\n #\\n\\n # Function which generates SWNE in LatLong for given tile\\n self.tileswne = self.mercator.TileLatLonBounds\\n\\n # Generate table with min max tile coordinates for all zoomlevels\\n self.tminmax = range(0,32)\\n for tz in range(0, 32):\\n tminx, tminy = self.mercator.MetersToTile( self.ominx, self.ominy, tz )\\n tmaxx, tmaxy = self.mercator.MetersToTile( self.omaxx, self.omaxy, tz )\\n # crop tiles extending world limits (+-180,+-90)\\n tminx, tminy = max(0, tminx), max(0, tminy)\\n tmaxx, tmaxy = min(2**tz-1, tmaxx), min(2**tz-1, tmaxy)\\n self.tminmax[tz] = (tminx, tminy, tmaxx, tmaxy)\\n\\n # TODO: Maps crossing 180E (Alaska?)\\n\\n # Get the minimal zoom level (map covers area equivalent to one tile)\\n if self.tminz == None:\\n self.tminz = self.mercator.ZoomForPixelSize( self.out_gt[1] * max( self.out_ds.RasterXSize, self.out_ds.RasterYSize) / float(self.tilesize) )\\n\\n # Get the maximal zoom level (closest possible zoom level up on the resolution of raster)\\n if self.tmaxz == None:\\n self.tmaxz = self.mercator.ZoomForPixelSize( self.out_gt[1] )\\n\\n if self.options.verbose:\\n print \\\"Bounds (latlong):\\\", self.mercator.MetersToLatLon( self.ominx, self.ominy), self.mercator.MetersToLatLon( self.omaxx, self.omaxy)\\n print 'MinZoomLevel:', self.tminz\\n print \\\"MaxZoomLevel:\\\", self.tmaxz, \\\"(\\\", self.mercator.Resolution( self.tmaxz ),\\\")\\\"\\n\\n # this must be call befor ImageOutput is called (self.output may be changed)\\n if self.options.mbtiles:\\n if not self.mbtiles_db:\\n self.mbtiles_setup(1);\\n\\n # Instantiate image output.\\n self.image_output = ImageOutput(self.options.tile_format, self.out_ds, self.tilesize,\\n self.options.resampling, init_dest, self.output,\\n self.options.verbose,self.options.mbtiles)\\n if self.options.profile == 'geodetic':\\n\\n self.geodetic = GlobalGeodetic() # from globalmaptiles.py\\n\\n # Function which generates SWNE in LatLong for given tile\\n self.tileswne = self.geodetic.TileLatLonBounds\\n\\n # Generate table with min max tile coordinates for all zoomlevels\\n self.tminmax = range(0,32)\\n for tz in range(0, 32):\\n tminx, tminy = self.geodetic.LatLonToTile( self.ominx, self.ominy, tz )\\n tmaxx, tmaxy = self.geodetic.LatLonToTile( self.omaxx, self.omaxy, tz )\\n # crop tiles extending world limits (+-180,+-90)\\n tminx, tminy = max(0, tminx), max(0, tminy)\\n tmaxx, tmaxy = min(2**(tz+1)-1, tmaxx), min(2**tz-1, tmaxy)\\n self.tminmax[tz] = (tminx, tminy, tmaxx, tmaxy)\\n\\n # TODO: Maps crossing 180E (Alaska?)\\n\\n # Get the maximal zoom level (closest possible zoom level up on the resolution of raster)\\n if self.tminz == None:\\n self.tminz = self.geodetic.ZoomForPixelSize( self.out_gt[1] * max( self.out_ds.RasterXSize, self.out_ds.RasterYSize) / float(self.tilesize) )\\n\\n # Get the maximal zoom level (closest possible zoom level up on the resolution of raster)\\n if self.tmaxz == None:\\n self.tmaxz = self.geodetic.ZoomForPixelSize( self.out_gt[1] )\\n\\n if self.options.verbose:\\n print \\\"Bounds (latlong):\\\", self.ominx, self.ominy, self.omaxx, self.omaxy\\n\\n if self.options.profile in ('raster', 'gearth', 'garmin'):\\n\\n log2 = lambda x: math.log10(x) / math.log10(2) # log2 (base 2 logarithm)\\n\\n self.nativezoom = int(max( math.ceil(log2(self.out_ds.RasterXSize/float(self.tilesize))),\\n math.ceil(log2(self.out_ds.RasterYSize/float(self.tilesize)))))\\n\\n if self.options.verbose:\\n print \\\"Native zoom of the raster:\\\", self.nativezoom\\n\\n # Get the minimal zoom level (whole raster in one tile)\\n if self.tminz == None:\\n self.tminz = 0\\n\\n # Get the maximal zoom level (native resolution of the raster)\\n if self.tmaxz == None:\\n self.tmaxz = self.nativezoom\\n\\n # Garmin has maximally 100 tiles - lower the tmaxz if necessary\\n if self.options.profile == 'garmin':\\n tno = math.ceil(self.out_ds.RasterXSize / self.tilesize) * math.ceil(self.out_ds.RasterYSize / self.tilesize)\\n for tz in range(self.tmaxz, 1, -1):\\n if tno > 100:\\n tno /= 4\\n self.tmaxz -= 1\\n print \\\"Warning: GARMIN has a limit 100 tiles per device: lowering the max zoom level to:\\\", self.tmaxz\\n else:\\n continue\\n\\n # Force only one zoom level for the 'garmin' tile profile\\n if self.options.profile == 'garmin':\\n self.tminz = self.tmaxz\\n\\n # Generate table with min max tile coordinates for all zoomlevels\\n self.tminmax = range(0, self.tmaxz+1)\\n self.tsize = range(0, self.tmaxz+1)\\n for tz in range(0, self.tmaxz+1):\\n tsize = 2.0**(self.nativezoom-tz)*self.tilesize\\n tminx, tminy = 0, 0\\n tmaxx = int(math.ceil( self.out_ds.RasterXSize / tsize )) - 1\\n tmaxy = int(math.ceil( self.out_ds.RasterYSize / tsize )) - 1\\n self.tsize[tz] = math.ceil(tsize)\\n self.tminmax[tz] = (tminx, tminy, tmaxx, tmaxy)\\n\\n # Function which generates SWNE in LatLong for given tile\\n if self.kml and self.in_srs_wkt:\\n self.ct = osr.CoordinateTransformation(self.in_srs, srs4326)\\n def rastertileswne(x,y,z):\\n pixelsizex = (2**(self.nativezoom-z) * self.out_gt[1]) # X-pixel size in level\\n pixelsizey = (2**(self.nativezoom-z) * self.out_gt[5]) # Y-pixel size in level (usually -1*pixelsizex)\\n west = self.out_gt[0] + x*self.tilesize*pixelsizex\\n east = west + self.tilesize*pixelsizex\\n south = self.ominy + y*self.tilesize*pixelsizex\\n north = south + self.tilesize*pixelsizex\\n if not self.isepsg4326:\\n # Transformation to EPSG:4326 (WGS84 datum)\\n west, south = self.ct.TransformPoint(west, south)[:2]\\n east, north = self.ct.TransformPoint(east, north)[:2]\\n return south, west, north, east\\n\\n self.tileswne = rastertileswne\\n else:\\n self.tileswne = lambda x, y, z: (0,0,0,0)\",\n \"def read_results():\\r\\n with open(\\\"packing.nfo\\\", \\\"r\\\") as fin:\\r\\n fin.readline()\\r\\n fin.readline()\\r\\n por_theory = float(fin.readline().split()[2])\\r\\n por_final = float(fin.readline().split()[2])\\r\\n print('Theoretical porosity:', por_theory)\\r\\n print('Final porosity:', por_final)\\r\\n with open(\\\"packing.xyzd\\\", \\\"rb\\\") as fin:\\r\\n btxt = fin.read()\\r\\n txt = list(struct.unpack(\\\"<\\\" + \\\"d\\\" * (len(btxt) // 8), btxt))\\r\\n data = array(zip(*[iter(txt)] * 4))\\r\\n data[:, 3] = data[:, 3] * \\\\\\r\\n ((1 - por_final) / (1 - por_theory))**(1 / 3)\\r\\n return data\",\n \"def read_db():\\n with open(\\\"config.json\\\") as f:\\n config = json.load(f)\\n \\n conn = psycopg2.connect(dbname='cage_sc_db', user='cage_db_user', \\n password='legend', host='10.66.193.71')\\n cursor = conn.cursor()\\n\\n # cmd = \\\"SELECT value_raw, timestamp FROM numeric_data WHERE endpoint_name='krstc_baseline' AND timestamp>'2019-09-27T00:00';\\\"\\n \\n # cmd = \\\"SELECT * FROM endpoint_id_map;\\\"\\n \\n # cmd = \\\"SELECT value_cal, timestamp FROM numeric_data WHERE endpoint_name='cage_coldPlate_temp' AND timestamp>'2019-09-03T00:02';\\\"\\n \\n # cmd = \\\"SELECT value_cal, timestamp FROM numeric_data WHERE endpoint_name='cage_pressure' AND timestamp>'2019-09-27T00:00';\\\"\\n \\n cmd = \\\"SELECT value_cal, timestamp FROM numeric_data WHERE endpoint_name='cage_ln_level' AND timestamp>'2019-09-27T00:00';\\\"\\n \\n # cmd = \\\"SELECT value_raw, timestamp FROM string_data WHERE endpoint_name='krstc_hv_status' AND timestamp>'2019-08-01';\\\"\\n \\n cursor.execute(cmd)\\n\\n # retrieve data. returns a list of tuples.\\n record = cursor.fetchall()\\n \\n # print(type(record[0]))\\n \\n # dt = record[0][1]\\n \\n # print(dt)\\n \\n for rec in record:\\n print(rec)\",\n \"def load_raw_aflw(sqlite_path, image_dir):\\n print('Load raw AFLW dataset from \\\"{}\\\"'.format(sqlite_path))\\n\\n # Temporary dataset variables\\n dataset_dict = dict()\\n\\n # Open sqlite file\\n conn = sqlite3.connect(sqlite_path)\\n cursor = conn.cursor()\\n\\n # Basic property\\n select_str = \\\"faces.face_id, imgs.filepath, \\\" \\\\\\n \\\"rect.x, rect.y, rect.w, rect.h, \\\" \\\\\\n \\\"pose.roll, pose.pitch, pose.yaw, metadata.sex\\\"\\n from_str = \\\"faces, faceimages imgs, facerect rect, facepose pose, \\\" \\\\\\n \\\"facemetadata metadata\\\"\\n where_str = \\\"faces.file_id = imgs.file_id and \\\" \\\\\\n \\\"faces.face_id = rect.face_id and \\\" \\\\\\n \\\"faces.face_id = pose.face_id and \\\" \\\\\\n \\\"faces.face_id = metadata.face_id\\\"\\n query_res = exec_sqlite_query(cursor, select_str, from_str, where_str)\\n # Register to dataset_dict\\n for face_id, path, rectx, recty, rectw, recth, roll, pitch, yaw, gender in query_res:\\n # Data creation or conversion\\n img_path = os.path.join(image_dir, path) if image_dir else path\\n landmark = np.zeros((N_LANDMARK, 2), dtype=np.float32)\\n landmark_visib = np.zeros(N_LANDMARK, dtype=np.float32)\\n pose = np.array([roll, pitch, yaw], dtype=np.float32)\\n gender = np.array([1, 0] if gender == 'm' else [0, 1], dtype=np.int32)\\n others_landmark_pts = list()\\n # Register\\n data = {'face_id': face_id,\\n 'img_path': img_path,\\n 'face_rect': (rectx, recty, rectw, recth),\\n 'landmark': landmark,\\n 'landmark_visib': landmark_visib,\\n 'pose': pose,\\n 'gender': gender,\\n 'others_landmark_pts': others_landmark_pts}\\n dataset_dict[face_id] = data\\n\\n # Landmark property\\n # (Visibility is expressed by lack of the coordinate's row.)\\n select_str = \\\"faces.face_id, coords.feature_id, \\\" \\\\\\n \\\"coords.x, coords.y\\\"\\n from_str = \\\"faces, featurecoords coords\\\"\\n where_str = \\\"faces.face_id = coords.face_id\\\"\\n query_res = exec_sqlite_query(cursor, select_str, from_str, where_str)\\n # Register to dataset_dict\\n invalid_face_ids = list()\\n for face_id, feature_id, x, y in query_res:\\n assert (1 <= feature_id <= N_LANDMARK)\\n if face_id in dataset_dict:\\n idx = feature_id - 1\\n dataset_dict[face_id]['landmark'][idx][0] = x\\n dataset_dict[face_id]['landmark'][idx][1] = y\\n dataset_dict[face_id]['landmark_visib'][idx] = 1\\n elif face_id not in invalid_face_ids:\\n print('Invalid face id ({}) in AFLW'.format(face_id))\\n invalid_face_ids.append(face_id)\\n\\n # Landmarks of other faces, file_id could have more than one face_id, thats why !=\\n select_str = \\\"a.face_id, coords.x, coords.y\\\"\\n from_str = \\\"faces a, faces b, featurecoords coords\\\"\\n where_str = \\\"a.face_id != b.face_id and a.file_id = b.file_id and \\\" \\\\\\n \\\"b.face_id = coords.face_id\\\"\\n query_res = exec_sqlite_query(cursor, select_str, from_str, where_str)\\n # Register to dataset_dict\\n for face_id, others_x, others_y in query_res:\\n if face_id in dataset_dict:\\n other_coord = [others_x, others_y]\\n dataset_dict[face_id]['others_landmark_pts'].append(other_coord)\\n else:\\n assert (face_id in invalid_face_ids)\\n # Convert list to np.ndarray\\n for data in dataset_dict.values():\\n pts = np.array(data['others_landmark_pts'], dtype=np.float32)\\n data['others_landmark_pts'] = pts\\n\\n # Exit sqlite\\n cursor.close()\\n\\n # Return dataset_dict's value (list)\\n return list(dataset_dict.values())\",\n \"def readDriverFile(self, input_file):\\n\\n\\n fid = open(self.basePath + input_file,'r')\\n\\n # Line 1\\n line = fid.readline()\\n l_input = line.split('!')\\n mshfile = l_input[0].rstrip()\\n\\n # Line 2\\n line = fid.readline()\\n l_input = line.split('!')\\n obsfile = l_input[0].rstrip()\\n\\n # Line 3\\n line = fid.readline()\\n l_input = re.split('[!\\\\s]',line)\\n if l_input=='null':\\n topofile = []\\n\\n else:\\n topofile = l_input[0].rstrip()\\n\\n\\n # Line 4\\n line = fid.readline()\\n l_input = re.split('[!\\\\s]',line)\\n if l_input[0]=='VALUE':\\n mstart = float(l_input[1])\\n\\n else:\\n mstart = l_input[0].rstrip()\\n\\n # Line 5\\n line = fid.readline()\\n l_input = re.split('[!\\\\s]',line)\\n if l_input[0]=='VALUE':\\n mref = float(l_input[1])\\n\\n else:\\n mref = l_input[0].rstrip()\\n\\n # Line 6\\n line = fid.readline()\\n l_input = re.split('[!\\\\s]',line)\\n if l_input[0]=='VALUE':\\n staticInput = float(l_input[1])\\n\\n elif l_input[0]=='DEFAULT':\\n staticInput = None\\n\\n else:\\n staticInput = l_input[0].rstrip()\\n\\n\\n # Line 7\\n line = fid.readline()\\n l_input = re.split('[!\\\\s]',line)\\n if l_input=='DEFAULT':\\n magfile = []\\n\\n else:\\n magfile = l_input[0].rstrip()\\n\\n # Line 8\\n line = fid.readline()\\n l_input = re.split('[!\\\\s]',line)\\n if l_input=='DEFAULT':\\n wgtfile = []\\n\\n else:\\n wgtfile = l_input[0].rstrip()\\n\\n # Line 9\\n line = fid.readline()\\n l_input = re.split('[!\\\\s]',line)\\n chi = float(l_input[0])\\n\\n # Line 10\\n line = fid.readline()\\n l_input = re.split('[!\\\\s]',line)\\n val = np.array(l_input[0:4])\\n alphas = val.astype(np.float)\\n\\n # Line 11\\n line = fid.readline()\\n l_input = re.split('[!\\\\s]',line)\\n if l_input[0]=='VALUE':\\n val = np.array(l_input[1:3])\\n bounds = val.astype(np.float)\\n\\n else:\\n bounds = l_input[0].rstrip()\\n\\n # Line 12\\n line = fid.readline()\\n l_input = re.split('[!\\\\s]',line)\\n if l_input[0]=='VALUE':\\n val = np.array(l_input[1:6])\\n lpnorms = val.astype(np.float)\\n\\n else:\\n lpnorms = l_input[0].rstrip()\\n\\n # Line 13\\n line = fid.readline()\\n l_input = re.split('[!\\\\s]',line)\\n if l_input[0]=='VALUE':\\n val = np.array(l_input[1:3])\\n eps = val.astype(np.float)\\n\\n else:\\n eps = [None,None]\\n\\n self.mshfile = mshfile\\n self.obsfile = obsfile\\n self.topofile = topofile\\n self.mstart = mstart\\n self._mrefInput = mref\\n self._staticInput = staticInput\\n self.magfile = magfile\\n self.wgtfile = wgtfile\\n self.chi = chi\\n self.alphas = alphas\\n self.bounds = bounds\\n self.lpnorms = lpnorms\\n self.eps = eps\",\n \"def read_data_set():\\n # shapes of datasets -- [] means expanded form:\\n # - X: J\\n # - net.R: J [x J x 1]\\n # - F_DIST: J x J x num_features\\n # - F_DIST_w1: J x J x num_features\\n # - w['except_first'][-1]: (last weights) J x num_features [x 1]\\n # - w['except_first'][1:-1]: (second to last weights) J x J x num_features\\n # - first weights **were** also J x J x num_features\\n # - w['first_for_r']: J x 1 x num_features\\n\\n read_X()\\n read_weights(read_FDIST())\",\n \"def read(self) :\\n # Open the file.\\n f = open(self.output, 'r')\\n lines = f.readlines()\\n \\n # Find the eigenvalue.\\n count = 0\\n while True :\\n words = lines[count].split()\\n if len(words) == 5 :\\n if words[0] == \\\"*\\\" and words[1] == \\\"K-EFF\\\":\\n self.keff = float(words[3])\\n break\\n count += 1\\n \\n # Find the peaking.\\n a = 0 # Assembly index\\n \\n while True :\\n words = lines[count].split()\\n if len(words) == 8 :\\n if words[0] == \\\"NODE\\\" and words[1] == \\\"AVERAGE\\\" and words[2] == \\\"POWERS\\\" :\\n count += 5 # Powers start 5 lines below title\\n for row in range(0, self.dimension) :\\n words = lines[count].split()\\n assert(len(words) >= self.dimension)\\n for col in range(0, self.dimension) :\\n self.peaking_map[row, col] = float(words[col+1])\\n if self.core.stencil[row, col] > 0:\\n #print \\\" a=\\\", a, \\\" row=\\\", row, \\\" col=\\\", col, len(self.peaking)\\n self.peaking[a] = self.peaking_map[row, col]\\n a += 1\\n count += 1\\n break\\n count += 1 \\n # Maximum peaking.\\n self.maxpeak = np.max(self.peaking)\",\n \"def read_fatlasa_results(filename):\\n\\n pass\",\n \"def read(self):\",\n \"def load_data(database_filepath):\\n\\n # create engine to get connection\\n engine = create_engine(\\\"sqlite:///{}\\\".format(database_filepath))\\n with engine.connect() as connection:\\n df = pd.read_sql_table(\\\"appen\\\", connection)\\n # define the features and output of the model\\n X = df[\\\"message\\\"]\\n Y = df.drop([\\\"message\\\", \\\"id\\\", \\\"original\\\", \\\"genre\\\"], axis=1)\\n category_names = list(Y.columns)\\n\\n return X, Y, category_names\",\n \"def read_data(filename):\\n data=''\\n with zipfile.ZipFile(filename) as f:\\n \\n for file in f.namelist():\\n subdata = tf.compat.as_str(f.read(file))\\n data+=subdata\\n return nlp(data)\",\n \"def Read_Palik():\\n fid = open('/Users/simonvassant/TheseSave/Matlab_RMCA/RMCA_Fab_CuN17_Champ/Au_Palik.dat','r')\\n L,eps = [],[]\\n while 1: \\n line = fid.readline()\\n if line =='': \\n break \\n else :\\n L.append(float(line[:25]))\\n eps.append(float(line[27:54])+1j*float(line[55:-2]))\\n return np.array(L),np.array(eps)\",\n \"def _read_query(self):\\n try:\\n # Open Google Drive and read the sql file\\n self.query = GDrive().read_drive_file(self.input_source_id)\\n except Exception as e:\\n raise e\",\n \"def read_sql(name=\\\"total_trips.sql\\\"):\\n template = pkg_resources.resource_filename(\\\"gojek\\\", join(\\\"sql\\\", name))\\n with open(template, 'r') as myfile:\\n query = myfile.read()\\n return query\",\n \"def load_data(self, filename):\\r\\n #sqlcontext = SQLContext(self.sc)\\r\\n #df = sqlcontext.read.format('com.databricks.spark.csv').options(header='false', inferschema='true').load(filename)\\r\\n #df = sc.textFile(r\\\"C:\\\\Users\\\\mohan\\\\Downloads\\\\patches.csv\\\").map(lambda line: line.split(\\\",\\\"))\\r\\n #print (df.count())\\r\\n df = self.sc.textFile(filename).map(lambda line: line.split(\\\",\\\"))\\r\\n l = df.map(lambda w: [int(float(c)) for c in w]).zipWithIndex()\\r\\n return l\\r\\n raise NotImplementedError\",\n \"def readfields(self, dbname, line1, nlines, startdate): \\n\\n conn=sqlite3.connect(dbname)\\n c=conn.cursor()\\n self.obsHistID=np.zeros(nlines)\\n self.fieldMJD=np.zeros(nlines)\\n self.fieldRA=np.zeros(nlines)\\n self.fieldDec=np.zeros(nlines)\\n self.rotSkyPos=np.zeros(nlines)\\n self.filter=np.zeros(nlines, dtype=str)\\n self.fiveSigmaDepth=np.zeros(nlines)\\n self.seeingFwhmEff=np.zeros(nlines)\\n\\n count=0\\n# exec_str='SELECT obsHistID,expMJD,fieldRA,fieldDec,rotSkyPos FROM Summary order by expMJD limit %d,%d' %(line1-1,nlines)\\n exec_str='SELECT observationId,observationStartMJD,FieldRA,FieldDec,rotSkyPos,filter,fiveSigmaDepth,seeingFwhmEff FROM SummaryAllProps order by observationStartMJD limit %d,%d' %(line1-1,nlines)\\n for row in c.execute(exec_str):\\n self.obsHistID[count] = row[0]\\n self.fieldMJD[count] = row[1]\\n self.fieldRA[count] = np.deg2rad(row[2])\\n self.fieldDec[count] = np.deg2rad(row[3])\\n self.rotSkyPos[count] = np.deg2rad(row[4])\\n self.filter[count] = row[5]\\n self.fiveSigmaDepth[count] = row[6]\\n self.seeingFwhmEff[count] = row[7]\\n count +=1\\n\\n # startdate is 0 if not provided by user. In this case use the default MJDs.\\n if (startdate > 1):\\n self.fieldMJD=self.fieldMJD+(int(startdate)-int(self.fieldMJD[0]))\",\n \"def read_input(inputfile):\\n print(ColorText('\\\\nReading input file ...').bold())\\n # read in datatable\\n df = pd.read_table(inputfile, sep='\\\\t')\\n\\n # set df index\\n locuscol = 'unstitched_locus' if 'unstitched_locus' in df.columns else 'locus'\\n if locuscol not in df:\\n print(ColorText('\\\\nFAIL: There must be a column for locus IDs - either \\\"unstitched_locus\\\" or \\\"locus\\\"').fail())\\n print(ColorText('FAIL: The column is the hyphen-separated CHROM and POS.').fail())\\n print(ColorText('exiting cmh_test.py').fail())\\n exit()\\n df.index = df[locuscol].tolist()\\n\\n return df\",\n \"def dbRead(dbPoint):\\n raise NotImplementedError('dbRead in simu mode')\",\n \"def ReadIndex_binary(indexfile, isPrintWarning = False):#{{{\\n# return (indexList, headerinfo, dbfileindexList)\\n indexList = []\\n indexFileHeaderText = []\\n size_indexfile = os.path.getsize(indexfile)\\n cntReadByte = 0\\n try:\\n fpin=open(indexfile, \\\"rb\\\")\\n vI = array('I')\\n vI.fromfile(fpin,1)\\n cntReadByte += vI.itemsize\\n dumpedtext = fpin.read(vI[0])\\n cntReadByte += vI[0]\\n\\n strs = dumpedtext.split(\\\"\\\\n\\\")\\n origdbname = \\\"\\\"\\n origversion = \\\"\\\"\\n origext = \\\"\\\"\\n origprefix = \\\"\\\"\\n for line in strs:\\n if not line or line[0] == \\\"#\\\":\\n continue\\n ss=line.split()\\n if ss[0] == \\\"DEF_DBNAME\\\":\\n if len(ss)>=2:\\n origdbname=ss[1]\\n elif ss[0] == \\\"DEF_VERSION\\\":\\n if len(ss)>=2:\\n origversion=ss[1]\\n elif ss[0] == \\\"DEF_EXTENSION\\\":\\n if len(ss)>=2:\\n origext=ss[1]\\n elif ss[0] == \\\"DEF_PREFIX\\\":\\n if len(ss)>=2:\\n origprefix=ss[1]\\n if isPrintWarning:\\n if origversion == \\\"\\\": \\n msg = \\\"{}: Warning! No version info in the index file {}\\\"\\n print(msg.format(sys.argv[0],indexfile), file=sys.stderr)\\n elif origversion != version:\\n msg = \\\"{}: Warning! Version conflicts. \\\"\\\\\\n \\\"Version of the index file {} ({}) \\\"\\\\\\n \\\"!= version of the program ({})\\\"\\n print(msg.format(sys.argv[0], indexfile,\\n origversion, version), file=sys.stderr)\\n\\n headerinfo = (origdbname, origversion, origext, origprefix)\\n #read in other information\\n vI = array('I')\\n vI.fromfile(fpin,1)\\n cntReadByte += vI.itemsize\\n\\n dumpedidlist=fpin.read(vI[0])\\n cntReadByte += vI[0]\\n\\n idlist = dumpedidlist.split(\\\"\\\\n\\\")\\n vI=array('I')\\n vI.fromfile(fpin,1)\\n cntReadByte += vI.itemsize\\n\\n numRecord = vI[0]\\n if numRecord != len(idlist):\\n msg = \\\"{}: numID ({}) != numRecord ({}) for indexfile {} \\\"\\n print(msg.format(sys.argv[0], len(idlist),\\n numRecord, indexfile), file=sys.stderr)\\n\\n sizeRecord_I = (array('B').itemsize + array('I').itemsize +\\n array('I').itemsize)\\n sizeRecord_L = (array('B').itemsize + array('L').itemsize +\\n array('I').itemsize)\\n sizeRecord = int(mybase.FloatDivision(size_indexfile - cntReadByte, numRecord))\\n if abs(sizeRecord - sizeRecord_I) < abs(sizeRecord - sizeRecord_L):\\n vIarray=[array('B'), array('I'), array('I')]\\n else:\\n vIarray=[array('B'), array('L'), array('I')]\\n for i in range(3):\\n vIarray[i].fromfile(fpin,numRecord)\\n\\n lastDBFileIndex = vIarray[0][numRecord-1]\\n dbfileindexList = list(range(lastDBFileIndex+1))\\n\\n indexList.append(idlist)\\n for i in range(3):\\n indexList.append(vIarray[i])\\n fpin.close()\\n return (indexList, headerinfo, dbfileindexList)\\n except IOError:\\n msg = \\\"Failed to read index file {} in function {}\\\"\\n print(msg.format(indexfile, sys._getframe().f_code.co_name), file=sys.stderr)\\n return (None, None, None)\",\n \"def load_data(database_filepath):\\n\\n logging.info(\\\"run load_data\\\")\\n\\n # create engine and connect to file based-database\\n engine = create_engine(f\\\"sqlite:///{database_filepath}\\\")\\n\\n # load data in dataframe\\n df = pd.read_sql_table('data', engine)\\n logging.info(f\\\"data retrieved from db file: {database_filepath}\\\")\\n\\n # shuffle data\\n df = df.sample(frac=1, random_state=42)\\n\\n # split data between input and outputs\\n X = df['message']\\n Y = df.drop(['id', 'message', 'original', 'genre'], axis=1)\\n\\n return X, Y, Y.columns\",\n \"def get_raw_data():\\n data_files = []\\n for i, f in enumerate(os.listdir(config.RAW_DATA_DIR)):\\n data_files.append(f)\\n print i, \\\": \\\", f\\n while True:\\n try:\\n index = int(raw_input(\\\"Type the index of the data file you'd like to import: \\\"))\\n fn_raw_data = data_files[int(index)]\\n break\\n except ValueError:\\n print(\\\"Not a valid index. Try again.\\\")\\n except IndexError:\\n print(\\\"Not a valid index. Try again.\\\")\\n print \\\"Importing %s...\\\" % fn_raw_data\\n with open(config.RAW_DATA_DIR + fn_raw_data) as infile:\\n next(infile)\\n raw_data = list(csv.DictReader(infile))\\n return (fn_raw_data, raw_data)\",\n \"def wellBoreDataRead(fileName = None, onePhase = None):\\n materialIndex = 1\\n wellBoreDataDict = {}\\n if onePhase == None:\\n onePhase = True\\n pass\\n if fileName == None:\\n if onePhase == True:\\n fileName = environ[\\\"PWD\\\"]+\\\"/Data/wellbore.dat\\\"\\n pass\\n else:\\n fileName = environ[\\\"PWD\\\"]+\\\"/Data/twophasewellbore.dat\\\"\\n pass\\n try:\\n dataFile = open(fileName,\\\"r\\\")\\n except:\\n input(\\\" Necessary data have been read from\\\\n\\\"+\\\\\\n \\\" the generic wellbore data file: $WRAPPER/Data/Wellbore/wellbore.dat\\\\n\\\"+\\\\\\n \\\" A copy of that file is now in your reference directory as $PWD/Data/wellbore.dat.\\\\n\\\"+\\n \\\" Modify it now to your own specific wellbore data.\\\\n\\\"+\\\\\\n \\\" Now, enter any ascii key to continue the simulation\\\")\\n if (onePhase == True):\\n system(\\\"mkdir -p $PWD/Data;cp -p $WRAPPER/Data/Wellbore/wellbore.dat ./Data;chmod u+w $PWD/Data/wellbore.dat\\\")\\n pass\\n else:\\n system(\\\"mkdir -p $PWD/Data;cp -p $WRAPPER/Data/Wellbore/twophasewellbore.dat ./Data;chmod u+w $PWD/Data/twophasewellbore.dat\\\")\\n pass\\n dataFile = open(fileName,\\\"r\\\")\\n line = dataFile.readline()\\n #print(\\\"first line\\\", line)\\n \\n while \\\"Transient terms\\\" not in line:\\n line = dataFile.readline()\\n if \\\"material\\\" in line.lower():\\n wellBoreDataDict[\\\"Material\\\"+str(materialIndex)] = {}\\n wellBoreDataDict1 = wellBoreDataDict[\\\"Material\\\"+str(materialIndex)]\\n wellBoreDataDict[line.lower().replace(\\\"material\\\",\\\"\\\").replace(\\\"!\\\",\\\"\\\").replace(\\\"\\\\n\\\",\\\"\\\").replace(\\\" \\\",\\\"\\\")] = \\\"Material\\\"+str(materialIndex)\\n materialIndex+=1\\n elif (\\\"=\\\" in line) and (\\\"True\\\" in line):\\n var, varType, varValue = wellBoreDataLineAnalysis(line)\\n wellBoreDataDict1[var] = {varType:[varValue]}\\n elif \\\"=\\\" in line:\\n #print \\\"debug1 \\\",line\\n pythonString, var, varValue, varType, unit = wellBoreDataLineAnalysis(line)\\n if varType == \\\"Real\\\" or varType == \\\"Int\\\":\\n wellBoreDataDict1[var] = {varType:[varValue,unit]}\\n else:\\n line = dataFile.readline().replace(\\\"\\\\n\\\",\\\"\\\")\\n wellBoreDataDict1[var] = {varType:[line,unit]} # the type is implicitely variable due to the fact we have\\n # to deal with a formula,\\n # the variation is over the coordinate\\n wellBoreDataDict1[var] = {varType:[line,unit]}\\n #print(wellBoreDataDict); raw_input(\\\"wellBoreDataDict:\\\"+\\\"Material\\\"+str(materialIndex))\\n return wellBoreDataDict\",\n \"def Read_Palik_Al2O3_c():\\n fid = open('/Users/simonvassant/TheseSave/PaliK_Opticalconstant/Al2O3_B_Palik.dat','r')\\n L,eps = [],[]\\n while 1: \\n line = fid.readline()\\n if line =='': \\n break \\n else :\\n L.append(float(line[18:25]))\\n eps.append((float(line[42:49])+1j*float(line[50:57]))**2)\\n return np.array(L),np.array(eps)\",\n \"def read(self, filename):\\n pass\",\n \"def read(self, filename):\\n pass\",\n \"def read (self, path):\\n\\n\\t\\tself.data = []\\n\\t\\t# print \\\"*** path: %s***\\\" % path\\n\\t\\tdir, filename = os.path.split (path)\\n\\t\\troot, ext = os.path.splitext (filename)\\n\\t\\t# encoding = 'ISO-8859-1' # utf-8\\n\\t\\ts = codecs.open(path,'r', self.encoding).read()\\n\\t\\t## s = unicode(f.read(),'utf-8')\\n\\t\\ts = self.preprocess (s)\\n\\t\\tlines = split (s, self.linesep)\\n\\t\\tschema = self.splitline(lines[0])\\n\\n\\t\\t## print \\\"** %s **\\\" % os.path.splitext(filename)[0]\\n\\t\\tif self.verbose:\\n\\t\\t\\tprint \\\"read %d lines from %s\\\" % (len(lines), path)\\n\\n\\t\\tfor i in range(1,len(lines)):\\n\\t\\t\\tif not lines[i].strip(): \\n\\t\\t\\t\\t# print 'skipping line (%d)' % i\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\tfields = self.splitline(lines[i])\\n\\t\\t\\titem = self.entry_class (fields, schema)\\n\\t\\t\\tif self.accept (item):\\n\\t\\t\\t\\tself.add (item)\\n\\n\\t\\tself.schema = schema\\n\\t\\t# self.data.sort (lastNameCmp)\",\n \"def read_input_data(input_f, features_file, output):\\n\\n print('\\\\n Reading input...')\\n log_write(output['log'], 'Input file: %s\\\\n' % input_f, 'w+')\\n\\n # Read input data\\n df = pd.read_csv(input_f, low_memory=False)\\n df = df.astype({'Column': int,\\n 'Row': int,\\n 'ImageNumber': int,\\n 'ObjectNumber': int\\n })\\n\\n # Data features\\n if features_file:\\n data_features = [l.rstrip() for l in open(features_file).readlines()]\\n else:\\n data_features = [c for c in df.columns.values if 'PC' in c]\\n\\n return df, wt_strains(df), data_features\",\n \"def readFromFile(filename):\\n raise NotImplementedError\",\n \"def read_model(self):\\n filename = self.name + '_words'\\n f = open(filename, 'r') \\n d_str = f.read() \\n f.close()\\n d = dict(eval(d_str))\\n self.words = d\\n \\n filename2 = self.name + '_word_lengths'\\n f = open(filename2, 'r') \\n d2_str = f.read() \\n f.close()\\n d2 = dict(eval(d2_str))\\n self.word_lengths = d2\\n \\n filename3 = self.name + '_stems'\\n f = open(filename3, 'r') \\n d3_str = f.read() \\n f.close()\\n d3 = dict(eval(d3_str))\\n self.stems = d3\\n \\n filename4 = self.name + '_sentence_lengths'\\n f = open(filename4, 'r') \\n d4_str = f.read() \\n f.close()\\n d4 = dict(eval(d4_str))\\n self.sentence_lengths = d4\\n \\n filename5 = self.name + '_punctuation'\\n f = open(filename5, 'r') \\n d5_str = f.read() \\n f.close()\\n d5 = dict(eval(d5_str))\\n self.punctuation = d5\",\n \"def produce_database(database_name, is_debug):\\n\\t\\n\\t# read files from a01-a35, every file including whole ecg data and the corresponding annotation\\n\\tdata_annotations_set = get_ecg_data_annotations(database_name, is_debug)\\n\\t# divide ECG data to minute-by-minute ECG segments\\n\\t_ = process_ecg_data_segments(database_name, data_annotations_set, is_debug)\",\n \"def read_old(lookup_cnfg, lookup_qn, diagram, T, directory, verbose=0):\\n\\n data = []\\n\\n for cnfg in lookup_cnfg:\\n # filename and path\\n filename = directory + '/' + diagram + '_cnfg%i' % cnfg + '.h5'\\n # open file\\n try:\\n fh = h5py.File(filename, \\\"r\\\")\\n except IOError:\\n print 'file %s not found' % filename\\n raise\\n\\n # to achieve hirarchical indexing for quantum numbers build DataFrame for\\n # each loop seperately\\n # TODO: is it necessary to build that completely or can that be \\n # constructed by successively storing each operator with pd.HDFStore()?\\n data_qn = pd.DataFrame()\\n# print DataFrame(lookup_p)\\n# print DataFrame(lookup_g)\\n ndata = 0\\n nfailed = 0\\n\\n for op in lookup_qn.index:\\n ndata += 1\\n # generate operator name\\n p = lookup_qn.ix[op, ['p_{so}', 'p_{si}']]\\n g = lookup_qn.ix[op, ['\\\\gamma_{so}', '\\\\gamma_{si}']]\\n groupname = set_groupname(diagram, p, g)\\n\\n # read operator from file and store in data frame\\n try:\\n tmp = np.asarray(fh[groupname])\\n except KeyError:\\n #if diagram == 'C4+C' and cnfg == 714:\\n # print(\\\"could not read %s for config %d\\\" % (groupname, cnfg))\\n nfailed += 1\\n continue\\n data_qn[op] = pd.DataFrame(tmp, columns=['re/im'])\\n if nfailed > 0 and verbose > 0:\\n print(\\\"could not read %d of %d data\\\" % (nfailed, ndata))\\n\\n # append all data for one config and close the file\\n data.append(data_qn)\\n fh.close()\\n # generate data frame containing all operators for all configs\\n data = pd.concat(data, keys=lookup_cnfg, axis=0, names=['cnfg', 'T'])\\n\\n if verbose:\\n print '\\\\tfinished reading'\\n\\n return data.sort_index(level=[0,1])\\n ##############################################################################\",\n \"def read_data(db_name, query_file):\\r\\n con = sqlite3.connect(db_name)\\r\\n cursor = con.cursor()\\r\\n\\r\\n sql = open(query_file,'r')\\r\\n query = sql.read()\\r\\n sql.close()\\r\\n\\r\\n data = pd.read_sql_query(query, con=con)\\r\\n data.drop_duplicates(subset=['Title'], inplace=True)\\r\\n data = data[data['Type']=='movie']\\r\\n data.set_index('imdbID', inplace=True)\\r\\n\\r\\n con.commit()\\r\\n con.close()\\r\\n\\r\\n return data\",\n \"def loadDatabase(database):\\n for file_name in os.listdir(\\\"Users\\\"):\\n chemin = os.path.join(\\\"Users\\\", file_name)\\n key = file_name.lower()\\n database[key]=pickle.load(open(chemin,\\\"rb\\\"))\",\n \"def _read_dataset(a_files):\\n return [(list(ifields[TXT_IDX]), ifields[GLD_IDX])\\n for ifile in a_files for ifields in iterlines(ifile)]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62682515","0.6117073","0.6082425","0.5962235","0.59511","0.59221077","0.5916219","0.5915477","0.5911701","0.58680457","0.58508563","0.5843291","0.5842207","0.58020455","0.57885134","0.5770027","0.5762379","0.5760551","0.5756577","0.5716415","0.5681463","0.567404","0.56690615","0.56613797","0.56455076","0.5630983","0.56181264","0.55933505","0.55674374","0.5556608","0.5539424","0.5533233","0.55289453","0.55148315","0.55087626","0.5506252","0.54865974","0.54657555","0.5455528","0.54549235","0.5454466","0.5451042","0.544568","0.54216504","0.5418819","0.53914416","0.53898317","0.5388068","0.5383854","0.53558296","0.53539723","0.53454703","0.53425294","0.5340319","0.5338544","0.5335514","0.53258824","0.53253925","0.5322827","0.5315669","0.5313657","0.53131086","0.5301529","0.5299453","0.52967954","0.52925813","0.5291367","0.52912927","0.5288075","0.5284953","0.5283139","0.52817535","0.52800566","0.5279793","0.5270069","0.52637684","0.52597827","0.5258948","0.52583027","0.52582216","0.52566373","0.52562743","0.5255183","0.5252182","0.52497387","0.52448314","0.52436525","0.5242556","0.5235913","0.5226677","0.522578","0.522578","0.52198195","0.52179754","0.52168167","0.5207204","0.51986265","0.5198541","0.5193343","0.51851285","0.5173255"],"string":"[\n \"0.62682515\",\n \"0.6117073\",\n \"0.6082425\",\n \"0.5962235\",\n \"0.59511\",\n \"0.59221077\",\n \"0.5916219\",\n \"0.5915477\",\n \"0.5911701\",\n \"0.58680457\",\n \"0.58508563\",\n \"0.5843291\",\n \"0.5842207\",\n \"0.58020455\",\n \"0.57885134\",\n \"0.5770027\",\n \"0.5762379\",\n \"0.5760551\",\n \"0.5756577\",\n \"0.5716415\",\n \"0.5681463\",\n \"0.567404\",\n \"0.56690615\",\n \"0.56613797\",\n \"0.56455076\",\n \"0.5630983\",\n \"0.56181264\",\n \"0.55933505\",\n \"0.55674374\",\n \"0.5556608\",\n \"0.5539424\",\n \"0.5533233\",\n \"0.55289453\",\n \"0.55148315\",\n \"0.55087626\",\n \"0.5506252\",\n \"0.54865974\",\n \"0.54657555\",\n \"0.5455528\",\n \"0.54549235\",\n \"0.5454466\",\n \"0.5451042\",\n \"0.544568\",\n \"0.54216504\",\n \"0.5418819\",\n \"0.53914416\",\n \"0.53898317\",\n \"0.5388068\",\n \"0.5383854\",\n \"0.53558296\",\n \"0.53539723\",\n \"0.53454703\",\n \"0.53425294\",\n \"0.5340319\",\n \"0.5338544\",\n \"0.5335514\",\n \"0.53258824\",\n \"0.53253925\",\n \"0.5322827\",\n \"0.5315669\",\n \"0.5313657\",\n \"0.53131086\",\n \"0.5301529\",\n \"0.5299453\",\n \"0.52967954\",\n \"0.52925813\",\n \"0.5291367\",\n \"0.52912927\",\n \"0.5288075\",\n \"0.5284953\",\n \"0.5283139\",\n \"0.52817535\",\n \"0.52800566\",\n \"0.5279793\",\n \"0.5270069\",\n \"0.52637684\",\n \"0.52597827\",\n \"0.5258948\",\n \"0.52583027\",\n \"0.52582216\",\n \"0.52566373\",\n \"0.52562743\",\n \"0.5255183\",\n \"0.5252182\",\n \"0.52497387\",\n \"0.52448314\",\n \"0.52436525\",\n \"0.5242556\",\n \"0.5235913\",\n \"0.5226677\",\n \"0.522578\",\n \"0.522578\",\n \"0.52198195\",\n \"0.52179754\",\n \"0.52168167\",\n \"0.5207204\",\n \"0.51986265\",\n \"0.5198541\",\n \"0.5193343\",\n \"0.51851285\",\n \"0.5173255\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":21299,"cells":{"query":{"kind":"string","value":"Parse command line arguments."},"document":{"kind":"string","value":"def build_argparser():\n parser = ArgumentParser()\n parser.add_argument(\"-m\", \"--model\", required=True, type=str,\n help=\"Path to an xml file with a trained model.\")\n parser.add_argument(\"-i\", \"--input\", required=True, type=str,\n help=\"Path to image or video file\")\n parser.add_argument(\"-l\", \"--cpu_extension\", required=False, type=str,\n default=None,\n help=\"MKLDNN (CPU)-targeted custom layers.\"\n \"Absolute path to a shared library with the\"\n \"kernels impl.\")\n parser.add_argument(\"-d\", \"--device\", type=str, default=\"CPU\",\n help=\"Specify the target device to infer on: \"\n \"CPU, GPU, FPGA or MYRIAD is acceptable. Sample \"\n \"will look for a suitable plugin for device \"\n \"specified (CPU by default)\")\n parser.add_argument(\"-pt\", \"--prob_threshold\", type=float, default=0.3,\n help=\"Probability threshold for detections filtering\"\n \"(0.3 by default)\")\n return parser"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def parse_arguments(args):","def parse_command_line(self, argv):\n from optparse import OptionParser\n usage = \"usage: %prog [options]\"\n parser = OptionParser(usage)\n\n (options, args) = parser.parse_args(argv)","def parseArguments(self):\n iterator = iter(sys.argv[1:]) # Skip file name\n for argument in iterator:\n if len(argument) < 2 or argument[:2] != '--':\n self.error('syntax error \"{}\"'.format(argument))\n else:\n def getValueOfArgument(): return next(iterator)\n self.parseArgument(argument[2:], getValueOfArgument)","def parse_args():\n parser = argparse.ArgumentParser(\n description=\"Reads datapacket pcds, interpolates quaternions and generates scans from dataset in config file\")\n parser.add_argument(\"--visualization\", \"-v\", action=\"store_true\", help=\"if generated clouds should be visualized\")\n parser.add_argument(\"--directory\", \"-d\",\n help=\"if only specified directory should be interpolated, e.g. 'fragments/fragment0'\")\n args = parser.parse_args()\n return args.visualization, args.directory","def parse_arguments(self):\n \n for arg in sys.argv[1:]:\n (key, sep, value) = arg.partition(\"=\")\n if sep != \"=\":\n raise ProcessorError(\"Illegal argument '%s'\" % arg)\n self.update_data(key, value)","def parse_command_line_arguments():\n\n description, epilog = __doc__.split(\"\\n\\n\", 1)\n\n parser = argparse.ArgumentParser(\n formatter_class=argparse.RawDescriptionHelpFormatter,\n description=description,\n epilog=epilog)\n\n parser.add_argument('-s', '--s', dest='s', action='store', type=float, required=True,\n help='Minimum frequency')\n parser.add_argument('-c', '--credentials', dest='credentials', action='store',\n default=\"./.tpass\",\n help='File with Twitter credentials (username and password, separated by a space)')\n\n args = parser.parse_args()\n \n return args","def parse_command_line_arguments(argv):\n print(\"reading command line arguments in...\")\n\n parser = argparse.ArgumentParser(description='Description of your program')\n parser.add_argument('-i', '--input', help='Location of input csv file', required=True)\n parser.add_argument('-p', '--predicting', help='The column name containing the category to predict', required=True)\n parser.add_argument('-s', '--scoring', help='The scoring type to be used with model evaluation', required=False)\n parser.add_argument('-c', '--scale', help='List of column names to scale values for', nargs='+', required=False)\n args = parser.parse_args()\n\n return args.input, args.predicting, args.scoring, args.scale","def __parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument('-f', '--force', action=\"store_true\", default=False,\n help='overwrite existing database files during import')\n parser.add_argument('-e', '--extension', action=\"store\", default='txt',\n help='specify file extension. default is \"txt\"')\n parser.add_argument('-d', '--delimiter', action=\"store\", default='\\t',\n help='specify column delimiter. default is tab (\\\\t)')\n parser.add_argument('-m', '--mark', action=\"store\", default='.',\n help='specify decimal mark for numeric data. default is'\n ' dot (.)')\n parser.add_argument('-o', '--outformat', action=\"store\", default='npz',\n help='specify output database format. default is \"npz\"'\n ' for numpy database. use \"mat\" for matlab '\n ' database format.')\n parser.add_argument('-r', '--recursive', action=\"store_true\", default=False,\n help='recursively walk through all sub-directories of'\n ' current working directory')\n parser.add_argument('-p', '--pcs', action=\"store_true\", default=True,\n help='indicate if files are pcs files.')\n parser.add_argument('-c', '--colheadlines', action=\"store\", default='1',\n help='number of lines spanned by the column headers')\n args = parser.parse_args()\n return args","def parse_arguments():\n parser = argparse.ArgumentParser()\n parser.add_argument('-u', '--urls_dirpath', type=unicode)\n parser.add_argument('-r', '--resources_dir', type=unicode)\n parser.add_argument('-t', '--total_docs', type=int)\n parser.add_argument('-m', '--mapping', type=unicode,\n help='File with the yago to lkif mapping')\n\n return parser.parse_args()","def __parse_args(self):\n for argument in self.args:\n source_arg = re.match(\"^(--source=(([A-Z]|[a-z]|/|_|[0-9]|.)+))$\", argument)\n input_arg = re.match(\"^(--input=(([A-Z]|[a-z]|/|_|[0-9]|.)+))$\", argument)\n stats_arg = re.match(\"^(--stats=(([A-Z]|[a-z]|/|_|[0-9]|.)+))$\", argument)\n help_arg = re.match(\"^--help$\", argument)\n vars_arg = re.match(\"^--vars$\", argument)\n insts_arg = re.match(\"^--insts$\", argument)\n if source_arg:\n self.sourceFile = source_arg.group(2)\n self.passedArgs.append(\"source\")\n elif input_arg:\n self.inputFile = input_arg.group(2)\n self.passedArgs.append(\"input\")\n elif help_arg:\n print(\"napoveda\")\n sys.exit(0)\n elif stats_arg:\n self.statsFile = stats_arg.group(2)\n self.passedArgs.append(\"stats\")\n elif vars_arg:\n self.passedArgs.append(\"vars\")\n if self.first_stat_arg is None:\n self.first_stat_arg = \"vars\"\n elif insts_arg:\n self.passedArgs.append(\"insts\")\n if self.first_stat_arg is None:\n self.first_stat_arg = \"insts\"\n else:\n raise ArgError(\"Unknown argument or format of the argument! (\" + argument + \")\")","def parse_arguments():\n parser = argparse.ArgumentParser(prog='AdapterRunner', description='Adapter Runner Application')\n parser.add_argument('-a', '--application', action='store', dest='app_name', help='Application Name',\n metavar='<application_name>')\n parser.add_argument('-fi', '--fetch_interval', action='store', dest='fetch_stats_interval', help='Fetch Stats Interval',\n metavar='<fetch_interval in seconds>')\n return parser.parse_args()","def _parse_command_line_arguments():\n parser = ArgumentParser(\n description=(\n 'Command-line tool to generate a list of unique from a TS file from FermiFAST'\n ),\n )\n parser.add_argument(\n 'ts-file',\n type=str,\n help=(\n 'A file containing the TS sky map'\n ),\n )\n parser.add_argument('--skiprows',\n type=int,\n help='number of rows to skip at the top (default 0)',\n required=False)\n parser.set_defaults(skiprows=0)\n arguments = vars(parser.parse_args())\n return arguments","def parse_args():\n parser = argparse.ArgumentParser(description=\"Bandits algorithms on a click-through \"\n \"rate dataset.\")\n parser.add_argument('--plot', action='store_true')\n return parser.parse_args()","def parse_arguments(args=sys.argv[1:]):\n \n parser = argparse.ArgumentParser()\n \n parser.add_argument('-i', '--input',\n help=\"Path of input file to read. Default: {d}\".format(d=INPUT_FILE),\n default=INPUT_FILE)\n \n return parser.parse_args(args)","def parse_args():\n parser = default_argument_parser()\n parser.add_argument(\"--label-map\",\n dest=\"label_map\",\n type=pathlib.Path,\n help=\"Label map in YAML format which maps from category \"\n \"ID to name.\")\n parser.add_argument(\"--train-csv\",\n dest=\"train_csv\",\n required=True,\n type=pathlib.Path,\n help=\"Path to training data CSV file.\")\n parser.add_argument(\"--valid-csv\",\n dest=\"valid_csv\",\n required=False,\n type=pathlib.Path,\n help=\"Optional path to validation data CSV file.\")\n parser.add_argument(\n \"--image-width\",\n type=int,\n help=\"Image width (optional, used to speed up dataset processing).\")\n parser.add_argument(\n \"--image-height\",\n type=int,\n help=\"Image height (optional, used to speed up dataset processing).\")\n return parser.parse_args()","def _parse_args(argv):\n parser = make_parser()\n args = parser.parse_args(argv)\n LOGGER.setLevel(to_log_level(args.loglevel))\n\n if not args.inputs:\n if args.list:\n tlist = \", \".join(API.list_types())\n _exit_with_output(\"Supported config types: \" + tlist)\n elif args.env:\n cnf = os.environ.copy()\n _output_result(cnf, args.output, args.otype or \"json\", None, None)\n sys.exit(0)\n else:\n parser.print_usage()\n sys.exit(1)\n\n if args.validate and args.schema is None:\n _exit_with_output(\"--validate option requires --scheme option\", 1)\n\n return args","def parse_command_line():\r\n\r\n parser = argparse.ArgumentParser(description='User args')\r\n parser.add_argument(\"--action\", choices=['train', 'predict', 'demo', 'test'], required=True, help=\"Choose action.\")\r\n parser.add_argument(\"--model\", choices=['vgg', 'unet', 'fpn'], required=True, help=\"Choose model.\")\r\n parser.add_argument(\"--dataset\", choices=['full', 'small'], required=True, help=\"Choose dataset.\")\r\n\r\n return parser.parse_args()","def parse_command_line():\n parser = argparse.ArgumentParser()\n\n help_str = \\\n 'The collection folder to sort files into. ' \\\n 'If the folder does not exist, it will be created along with the ' \\\n 'necessary contents.'\n parser.add_argument('-c', '--collection', help=help_str)\n\n help_str = \\\n 'The source folder to import files from. Has to exist and ' \\\n 'has to be a folder.'\n parser.add_argument('-s', '--source', help=help_str, required=False)\n\n help_str = \\\n 'View the gallery in random order auto skpping after the' \\\n 'given amount of seconds'\n parser.add_argument('-v', '--view', help=help_str, required=False)\n\n return parser.parse_args()","def parse_command_line_arguments():\n parser = argparse.ArgumentParser()\n\n # Positional args\n parser.add_argument('data_directory', action=\"store\")\n\n # Optional args\n parser.add_argument('--save_dir', action='store',\n dest='save_dir',\n help='Load categories names from given file',\n default=\"checkpoint.pth\")\n\n parser.add_argument('--gpu', action='store_true',\n dest='device',\n help='Device of prediction processing',\n default=False)\n\n parser.add_argument('--arch', action='store',\n dest='arch',\n help='Name of pre-trained network used for training',\n default=\"vgg11\")\n\n parser.add_argument('--learning_rate', action='store',\n dest='learning_rate',\n help='value of training learning rate',\n default=0.001)\n\n parser.add_argument('--hidden_units', action='store',\n dest='hidden_units',\n help='Number of units in the fully-connected hidden '\n 'layer of the neural netwrork',\n default=512)\n\n parser.add_argument('--epochs', action='store',\n dest='epochs',\n help='Number of training epochs',\n default=5)\n\n # Parse all args\n results = parser.parse_args()\n\n return results","def parse_cmd_arguments():\n parser = argparse.ArgumentParser(description='Process some integers.')\n parser.add_argument('-i', '--input', required=True, help='input JSON file')\n parser.add_argument('-o', '--output', required=True,\n help='ouput JSON file')\n parser.add_argument('-d', '--debug', required=False,\n help='log level. Can be 0-3. Defaults to 0')\n\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-t\", \"-threads\", help=\"specifies a thread count for parallel operations\", type=int)\n return parser.parse_args()","def process_command_line_arguments() -> Namespace:\n\n parser = build_parser()\n arguments = parser.parse_args()\n\n return arguments","def parse_arguments():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-e\", \"--events\", type=str,\n help=\"path to events CSV-file\")\n parser.add_argument(\"-d\", \"--data\", type=str,\n help=\"path to data CSV-file\")\n parser.add_argument(\"-l\", \"--limit\", nargs='?', type=int, default=None,\n help=\"max records to be processed\")\n parser.add_argument(\"-t\", \"--timezone\", nargs='?', type=int, default=5,\n help=\"date and time shift\")\n parser.add_argument(\"-o\", \"--optimized\", action='store_true',\n help=\"if specified, then data CSV will be processed\"\n \" by small chunks to escape memory issues\")\n parser.add_argument(\"-v\", \"--verbose\", action='store_true')\n parser.add_argument(\"--output-folder\", nargs='?', type=str,\n default=\"linked\")\n return vars(parser.parse_args())","def parse_args(args=None):\n return AP.parse_args(args=args)","def parse_args():\n\tparser = argparse.ArgumentParser(description='Show video statistics.')\n\tparser.add_argument('--sort', metavar='FIELD', choices=['views', 'likes', 'dislikes'],\n\t default='views',\n\t help='sort by the specified field. Options are views, likes and dislikes.')\n\tparser.add_argument('--max', metavar='MAX', type=int, help='show the top MAX entries only.')\n\tparser.add_argument('--csv', action='store_true', default=False,\n\t help='output the data in CSV format.')\n\tparser.add_argument('--table', action='store_true', default=False,\n\t help='output the data in an ascii table.')\n\tparser.add_argument('--workers', type=int, default=8,\n\t help='number of workers to use, 8 by default.')\n\treturn parser.parse_args()","def parse_args(args=None):\n\t\treturn _get_args_parser().parse_args(args)","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"-d\",\n \"--debug\",\n help=\"Print lots of debugging statements\",\n action=\"store_const\",\n dest=\"loglevel\",\n const=logging.DEBUG,\n default=logging.ERROR,\n )\n parser.add_argument(\n \"-v\",\n \"--verbose\",\n help=\"Be verbose\",\n action=\"store_const\",\n dest=\"loglevel\",\n const=logging.INFO,\n )\n parser.add_argument(\"runscript\", default=None)\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument('n_iter',\n help='number of iteration',\n type=int)\n parser.add_argument('n_processes',\n help='number of processes',\n type=int)\n parser.add_argument('method',\n help='mutual exclusion method')\n parser.add_argument('duration',\n help='Duration of each process',\n type=float)\n return parser.parse_args()","def parse_arguments():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n \"--obs_len\",\n default=20,\n type=int,\n help=\"Directory where the sequences (csv files) are saved\",\n )\n parser.add_argument(\n \"--data_dir\",\n default=\"\",\n type=str,\n help=\"Directory where the sequences (csv files) are saved\",\n )\n parser.add_argument(\n \"--feature_dir\",\n default=\"\",\n type=str,\n help=\"Directory where the computed features are saved\",\n )\n parser.add_argument(\"--mode\",\n required=True,\n type=str,\n help=\"train/val/test/compute_all/lanes_only\")\n parser.add_argument(\n \"--sequence_num\",\n default=-1,\n type=int,\n help=\"Specify a specific sequence to visualize.\",\n )\n parser.add_argument(\n \"--batch_start\",\n default=0,\n type=int,\n help=\"Specify the starting row of features to visualize.\",\n )\n parser.add_argument(\n \"--batch_end\",\n default=-1,\n type=int,\n help=\"Specify the last row to visualize, -1 to visualize till end.\",\n )\n parser.add_argument(\n \"--single_figure\",\n default=False,\n action=\"store_true\",\n help=\"Plot all candidates for a scenein one figure.\",\n )\n return parser.parse_args()","def argumentsParser(args):\n\targuments = []\n\tif args.find('\"') > -1:\n\t\tt_arguments = args.split('\"')\n\t\tfor a in t_arguments:\n\t\t\tif a == '' or a == ' ':\n\t\t\t\tpass\n\t\t\telif a[-1] == ' ':\n\t\t\t\targuments.append(a[:-1])\n\t\t\telse:\n\t\t\t\targuments.append(a)\n\telif args.find(\"'\") > -1:\n\t\tt_arguments = args.split(\"'\")\n\t\tfor a in t_arguments:\n\t\t\tif a == '' or a == ' ':\n\t\t\t\tpass\n\t\t\telif a[-1] == ' ':\n\t\t\t\targuments.append(a[:-1])\n\t\t\telse:\n\t\t\t\targuments.append(a)\n\telif args == ' ':\n\t\tpass\n\telse:\n\t\targuments = args.split(' ')\n\treturn arguments","def parse_args():\n parser = argparse.ArgumentParser(description='Google reminders cli',\n epilog=usage,\n formatter_class=argparse.RawTextHelpFormatter)\n return parser.parse_args()","def parseArgs():\n parser = argparse.ArgumentParser()\n parser.add_argument('--dataset', default='fsod', help='training dataset') # use fsod dataset for default\n parser.add_argument('--cfg', dest='cfg_file', required=True, help='optional config file')\n parser.add_argument('--load_ckpt', help='path to load checkpoint')\n parser.add_argument('--load_detectron', help='path to load detectron weight pickle file')\n parser.add_argument('--output_dir', help='output directory to save the testing results.')\n parser.add_argument('--range', help='[start, end)', type=int, nargs=2)\n parser.add_argument('--visualize', dest='visualize', help='output images of detection', action='store_true')\n return parser.parse_args()","def parse_arguments():\n parser = ArgumentParser()\n\n # For development/testing\n parser.add_argument(\"--dev\", help=\"run the code of the developers tag\")\n\n return parser.parse_args()","def parse_command_line():\n parser = argparse.ArgumentParser()\n\n # All reference encoders\n parser.add_argument(\"--step\", dest=\"step\", default=\"10\", type=int, help=\"step size\")\n parser.add_argument(\"--repeats\", dest=\"repeats\", type=int, default=1, help=\"repeats\")\n\n parser.add_argument(dest=\"image\", default=None,\n help=\"select the test image to run\")\n\n args = parser.parse_args()\n return args","def parse_args():\n parser = argparse.ArgumentParser(\n description=\"Subscription Watch CSV file packaging script\", prog=sys.argv[0])\n\n # required args\n parser.add_argument(\"-f\", \"--filepath\", required=True,\n help=\"path to files to package\")\n parser.add_argument(\n \"-s\",\n \"--max-size\",\n type=int,\n default=DEFAULT_MAX_SIZE,\n help=f\"Maximum size of packages in MiB. (Default: {DEFAULT_MAX_SIZE} MiB)\",\n )\n parser.add_argument(\n \"-o\", \"--overwrite\", action=\"store_true\", default=False, help=\"whether to overwrite existing files.\"\n )\n parser.add_argument(\"--ocp-cluster-id\", required=True,\n help=\"OCP Cluster ID\")\n parser.add_argument(\"-v\", \"--verbosity\", action=\"count\",\n default=0, help=\"increase verbosity (up to -vvv)\")\n return parser.parse_args()","def parseArgs():\n parser = argparse.ArgumentParser(description='Runs RHEAS simulation.')\n parser.add_argument('config', help='configuration file')\n parser.add_argument('-d', metavar='DB', help='name of database to connect')\n parser.add_argument('-u', help='update database', action='store_true')\n args = parser.parse_args()\n return args.config, args.d, args.u","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n '--version',\n metavar=\"<str>\",\n help=\"Input data version number\",\n type=str,\n required=True\n )\n args = parser.parse_args()\n return args","def parse_arguments():\n parser = argparse.ArgumentParser(description=\"\"\"A script to get the kmer frequency\n from csv files with kmer counts from genomes.\"\"\")\n\n parser.add_argument('-sd',\n '--sub_dir',\n type=str,\n dest='sub_dir',\n help='Subdirectory name for output files.') # kmer_count\n\n parser.add_argument('-do',\n '--dir_out',\n type=str,\n dest='dir_out',\n help='directory name for output files.') # Results/kmer_freq\n\n return parser.parse_args()","def parse_args():\n \n parser = argparse.ArgumentParser()\n parser.add_argument(\n 'config',\n help='Config file')\n parser.add_argument(\n '--quiet',\n '-q',\n action='store_true',\n help='do not print to console'\n )\n parser.add_argument(\n '--password',\n '-p',\n action='store_true',\n help='Set password in keyring.'\n )\n parser.add_argument(\n '--update',\n '-u',\n action='store_true',\n help='Only add transactions after last date in database.'\n )\n parser.add_argument(\n '--mark_seen',\n '-m',\n action='store_true',\n help='Mark fetched emails as seen.'\n )\n\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser(\n description=\"CUDAPOA Python API sample program.\")\n parser.add_argument('-m',\n help=\"Run MSA generation. By default consensusis generated.\",\n action='store_true')\n parser.add_argument('-p',\n help=\"Print output MSA or consensus for each POA group.\",\n action='store_true')\n parser.add_argument('-l',\n help=\"Use long or short read sample data.\",\n action='store_true')\n return parser.parse_args()","def parse_args():\n parser = OptionParser()\n parser.add_option('--data-file', '-f', default='train_data.hdf5',\n help=\"The path to the data file\")\n parser.add_option('--runs-per-epoch', '-r', type='int',\n help=\"The number of runs per epoch (train samples count)\")\n parser.add_option('--avg-window-size', '-w', default='1', type='int',\n help=\"The window size for moving average\")\n\n (options, args) = parser.parse_args()\n return options","def parse_args(self, argv=None):\n self.opts, self.args = self.cli_parser.parse_args(argv)\n self._begin_logging()\n if argv is None:\n argv = sys.argv\n logger.info(' '.join(argv))\n self._process_input_files()\n self._construct_links_of_interest()\n self._open_output_files()\n data = self._construct_data_struct()\n return data","def parseArgs(arguments=None):\n\tparser = generateParser(None)\n\treturn parser.parse_known_args(arguments)","def parse_command_line():\n parser = argparse.ArgumentParser()\n\n # Optional Argument\n parser.add_argument('-l', '--length', metavar='length', type=float, default=2, help='length (meter)')\n parser.add_argument('-k', '--conductivity', metavar='conductivity', type=float, default=0.5, help='constant thermal conductivity (W/m.K)')\n parser.add_argument('-q', '--heatgeneration', metavar='heatgeneration', type=float, default=1000, help='uniform heat generation (kW/m^3)')\n parser.add_argument('-TA', '--tempA', metavar='tempA', type=int, default=100, help='temperature at A (Celcius)')\n parser.add_argument('-TB', '--tempB', metavar='tempB', type=int, default=200, help='temperature at A (Celcius)')\n parser.add_argument('-n', '--nodes', metavar='nodes', type=int, default=5, help='nodes (positive integer)')\n parser.add_argument('-A', '--area', metavar='area', type=float, default=1, help='area (m^2)')\n parser.add_argument('-nf', '--nofigure', action='store_true', help='disable figure')\n parser.add_argument('-nd', '--nodetail', action='store_true', help='disable detail')\n return parser.parse_args()","def parse_arguments():\n parser = argparse.ArgumentParser(\n description=\"script for downloading and merging log files from S3 for particular time period\")\n parser.add_argument(\"-s\", \n \"--startdate\", \n help=\"start date in format YYYYMMDD\", \n required=True, \n type=valid_date)\n parser.add_argument(\"-e\", \"--enddate\", \n help=\"end date in format YYYYMMDD\", \n required=True, \n type=valid_date)\n parser.add_argument(\"-f\", \n \"--file\", \n help=\"destination file\", \n required=True)\n parser.add_argument( \"-c\", \"--config\",\n default=\"/Users/samarius/.get_analytics_log.config.json\",\n help=\"configuration file path\")\n\n\n try:\n args = parser.parse_args()\n return args\n except Exception as e:\n print \"can't parse command line args: {}\".format(repr(e))\n raise","def parse_args():\n\n parser = argparse.ArgumentParser(description='Disk metric sender')\n parser.add_argument('-v', '--verbose', action='store_true', default=None, help='Verbose?')\n parser.add_argument('--debug', action='store_true', default=None, help='Debug?')\n\n return parser.parse_args()","def parseArguments():\n parser = argparse.ArgumentParser()\n parser.add_argument('--output_folder',\n help='Path of the folder where output files should be written.')\n parser.add_argument('--partition_id',\n help='ID of the computer partition to collect data from.')\n parser.add_argument('--collector_db',\n help='The path of slapos collect database.')\n\n return parser.parse_args()","def arg_parse():\n\n parser = argparse.ArgumentParser()\n\n parser.add_argument(\n \"-f\",\n \"--fpath\",\n type=str,\n required=True,\n help=\"Path to files to generate test data from e.g. /badc/cmip5/data/cmip5/output1/MOHC/HadGEM2-ES/rcp85/mon/atmos/Amon/r1i1p1/latest/tas\",\n )\n\n parser.add_argument(\n \"-t\",\n \"--time_only\",\n default=False,\n help=\"Only generate one time step of this dataset\",\n action=\"store_true\",\n )\n\n parser.add_argument(\n \"-s\",\n \"--step\",\n type=int,\n default=100,\n help=\"Step to select latitude/longitude by. Only relevant when time_only is False\",\n )\n\n parser.add_argument(\n \"-n\",\n \"--number\",\n type=int,\n default=0,\n help=\"Number of files to generate. Default is all files. Only relevant when time_only is False\",\n )\n\n parser.add_argument(\n \"-l\",\n \"--level\",\n type=int,\n default=-1,\n help=\"Number of levels to extract, starting with index 0.\",\n )\n\n parser.add_argument(\n \"-c\", \"--compress\", help=\"Compress the files.\", action=\"store_true\"\n )\n\n return parser.parse_args()","def parse_args():\n parser = ArgumentParser(\n description=__doc__, formatter_class=ArgumentDefaultsHelpFormatter\n )\n parser.add_argument(\n '-i', '--infile', type=is_valid_file, action=FullPaths,\n metavar='FILE', required=True, help='''Settings file'''\n )\n parser.add_argument(\n '-d', '--ddc_file', type=is_valid_file, action=FullPaths,\n metavar='FILE', default='ddc2_nios2_sw.elf',\n help='''DDC2 download file'''\n )\n parser.add_argument(\n '-t', '--time', type=int, metavar='INT', default=5,\n help='''Number of seconds to run DDC2'''\n )\n parser.add_argument(\n '-o', '--outfile', type=str, default='./data/test/test',\n metavar='FILE', required=False,\n help='''Output location of data (no need to include file extension)'''\n )\n parser.add_argument(\n '--live', action='store_true', default=False,\n help='''Live visualisation'''\n )\n parser.add_argument(\n '-v', '--verbose', action='store_true', default=False,\n help='''Verbose'''\n )\n args = parser.parse_args()\n return args","def parse_args():\n parser = ArgumentParser(\n description=\"This is a script for auto apply ipex optimization.\"\n \"\\n################################# Basic usage ############################# \\n\"\n \"\\n 1. Apply ipex optimization with fp32 data type\\n\"\n \"\\n >>> python -m intel_extension_for_pytorch.cpu.auto_ipex python_script args \\n\"\n \"\\n 2. Apply ipex optimization with bf16 data type\\n\"\n \"\\n >>> python -m intel_extension_for_pytorch.cpu.auto_ipex --dtype bfloat16 python_script args \\n\",\n formatter_class=RawTextHelpFormatter,\n )\n\n add_auto_ipex_params(parser, auto_ipex_default_enabled=True)\n\n # positional\n parser.add_argument(\n \"program\",\n type=str,\n help=\"The full path to the proram/script to be launched. \"\n \"followed by all the arguments for the script\",\n )\n # rest from the training program\n parser.add_argument(\"program_args\", nargs=REMAINDER)\n return parser.parse_args()","def parse_args():\n parser = common_parser()\n parser.description = (\n \"Given a sequence dict, fasta index or a bed file, scatter over the \"\n \"defined contigs/regions. Each contig/region will be split into \"\n \"multiple overlapping regions, which will be written to a new bed \"\n \"file. Each contig will be placed in a new file, unless the length of \"\n \"the contigs/regions doesn't exceed a given number.\")\n\n parser.add_argument(\"-c\", \"--chunk-size\", type=int, default=1e6,\n metavar=\"SIZE\",\n help=\"The size of the chunks. The first chunk in a \"\n \"region or contig will be exactly length SIZE, \"\n \"subsequent chunks will SIZE + OVERLAP and the final \"\n \"chunk may be anywhere from 0.5 to 1.5 times SIZE \"\n \"plus overlap. If a region (or contig) is smaller \"\n \"than SIZE the original regions will be returned. \"\n \"Defaults to 1e6\")\n parser.add_argument(\"-m\", \"--minimum-bp-per-file\", type=int, default=45e6,\n help=\"The minimum number of bases represented within \"\n \"a single output bed file. If an input contig or \"\n \"region is smaller than this MINIMUM_BP_PER_FILE, \"\n \"then the next contigs/regions will be placed in the \"\n \"same file untill this minimum is met. Defaults to \"\n \"45e6.\")\n parser.add_argument(\"-o\", \"--overlap\", type=int, default=150,\n help=\"The number of bases which each chunk should \"\n \"overlap with the preceding one. Defaults to 150.\")\n parser.add_argument(\"-S\", \"--split-contigs\", action=\"store_true\",\n help=\"If set, contigs are allowed to be split up over \"\n \"multiple files.\")\n args = parser.parse_args()\n return args","def parse_arguments():\n # shift away script name\n scriptname=sys.argv[0]\n shift()\n ncl_cmd=list()\n quali_cmd=list()\n id_cmd=list() \n while(len(sys.argv)>0):\n carg = sys.argv[0]\n shift()\n if(carg == \"--nucleotide\"):\n ncl_cmd = mungeArgs(sys.argv)\n elif(carg == \"--quality\"):\n quali_cmd = mungeArgs(sys.argv)\n elif(carg == \"--id\" ):\n id_cmd = mungeArgs(sys.argv)\n elif(carg in [\"-h\", \"--help\"]):\n usage()\n else:\n usage(error=True)\n # Excess arguments which are not processed \n if(len(sys.argv) > 0):\n sys.stdout.write(\"Excess arguments!\\n\")\n sys.stdout.flush()\n usage(error=True)\n\n # external modules rely on non-empty argv array, \n # re-append the script name as first command line argument\n sys.argv.append(scriptname)\n return (id_cmd, ncl_cmd, quali_cmd)","def _parse_args():\n parser = argparse.ArgumentParser(description='main.py')\n \n # General system running and configuration options\n parser.add_argument('--do_nearest_neighbor', dest='do_nearest_neighbor', default=False, action='store_true', help='run the nearest neighbor model')\n\n parser.add_argument('--train_path', type=str, default='data/geo_train.tsv', help='path to train data')\n parser.add_argument('--dev_path', type=str, default='data/geo_dev.tsv', help='path to dev data')\n parser.add_argument('--test_path', type=str, default='data/geo_test.tsv', help='path to blind test data')\n parser.add_argument('--test_output_path', type=str, default='geo_test_output.tsv', help='path to write blind test results')\n parser.add_argument('--domain', type=str, default='geo', help='domain (geo for geoquery)')\n \n # Some common arguments for your convenience\n parser.add_argument('--seed', type=int, default=0, help='RNG seed (default = 0)')\n parser.add_argument('--epochs', type=int, default=100, help='num epochs to train for')\n parser.add_argument('--lr', type=float, default=.001)\n parser.add_argument('--batch_size', type=int, default=2, help='batch size')\n # 65 is all you need for GeoQuery\n parser.add_argument('--decoder_len_limit', type=int, default=65, help='output length limit of the decoder')\n\n # Feel free to add other hyperparameters for your input dimension, etc. to control your network\n # 50-200 might be a good range to start with for embedding and LSTM sizes\n args = parser.parse_args()\n return args","def parse_command_line() -> argparse.Namespace:\n parser = argparse.ArgumentParser()\n parser.add_argument(\n 'pet_database',\n type=str,\n help='path to pet database'\n )\n parser.add_argument(\n '--image_dir',\n default='data/images'\n )\n parser.add_argument(\n '--log',\n default=None,\n help='log file path'\n )\n\n args = parser.parse_args()\n args.pet_database = os.path.abspath(os.path.expanduser(args.pet_database))\n args.image_dir = os.path.abspath(os.path.expanduser(args.image_dir))\n args.log = os.path.abspath(os.path.expanduser(args.log)) if args.log else None\n return args","def parse_args():\n parser = argparse.ArgumentParser(description='Crawl an Android app store for apk files.')\n parser.add_argument('--store', dest='api', choices=['GooglePlay', 'F-Droid'], required=True,\n help='Specifies the store to crawl. At the moment only Google Play is supported.')\n parser.add_argument('--meta', dest='meta', required=False, action='store_const', default=False, const=True,\n help='If set, no apps will be downloaded, but the meta_data will be saved.')\n parser.add_argument('--basedir', dest='base_dir', type=str, default=os.getenv('HOME'),\n required=False, help='Specifies the base path for both logs and apk_downloads.')\n parser.add_argument('--credentials', dest='credentials', type=str, required=False, default=None,\n help='Specifies the path to a credential file in .toml format.')\n parser.add_argument('--limit', dest='limit', type=int, required=False, default=None,\n help='Specifies the maximum number of apks per category to download.')\n return parser.parse_args()","def parse_args():\n from argparse import ArgumentParser\n ap = ArgumentParser(prog=__exe__, description=__purpose__)\n ap.add_argument('session', help='Session Label')\n ap.add_argument('-sd', '--subjects_dir', help='Subjects Dir',\n default='/tmp')\n return ap.parse_args()","def parse_args():\n\n\t# Define the input parser\n\tdesc = \"computes long term temperature anomaly trend for the GHNC dataset\"\n\tepilog = \"\"\"\ndatarange input argument is of the format:\n\t\t YYYY[MM[DD]][:YYYY[MM[DD]]]\nWhere the date before the optional ':'' represents the lower bound of\nthe range and the optional date after the : represents the upper\nbound. The optional elements of the date default to the lowest possible\nvalue for the lower bound and to the maximum possible for the upper\none. For example,\n\t2006 is equivalent to 2006/01/01:2006/12/31\n\t2006/02 is equivalent to 2006/02/01:2006/02/28\n\"\"\"\n\n\tparser = argparse.ArgumentParser(description=desc, epilog=epilog,\n\t\t\t\t\t\tformatter_class=argparse.RawDescriptionHelpFormatter)\n\tparser.add_argument(\"daterange\",\n\t\t\t\t\t\thelp=\"range of dates to make available locally\")\n\tparser.add_argument('-t',\"--timeseries\",nargs=2,metavar=('lon','lat'),type=float,\n\t\t\t\t\t\thelp=\"plot timeseries for the lon lat pair of coordinates\")\n\tparser.add_argument('-r',\"--recompute\",default=False,action='store_true',\n\t\t\t\t\t\thelp=\"force recompute trend\")\n\n\treturn parser.parse_args()","def parse_args():\n parser = ArgumentParser()\n parser.add_argument('-t', '--timer', action='store_true', \\\n help='Time the first random generation')\n parser.add_argument('-i', '--ibmq', default='', help='IBMQ token')\n parser.add_argument('-b', '--backend', default='', help='IBMQ backend')\n return parser.parse_args()","def parseArguments():\n # Create argument parser\n parser = argparse.ArgumentParser()\n\n # Optional arguments\n parser.add_argument(\"-t\", \"--test\", help=\"Optionally test algorithm on subsample of the data. Set to 1 for testing\", type=int, default=0)\n\n parser.add_argument(\"--cores\", help=\"Optimized code for a server with a lot of RAM, set to the number of available cores\", type=int, default=40)\n\n\n # Print version\n parser.add_argument(\"--version\", action=\"version\", version='%(prog)s - Version 2.0') #version 1.0 is for the observations in June 2018\n #version 1.1 contains the optimizations made after the june observations (mainly the switch to stackmags)\n #version 1.2 changed sim class to NOT include the list of failed candidates (not qsos)\n #... copied changes made to crossval version\n #version 1.5 added check for duplicate quasars and remove them\n #version 1.6 new simulated quasars (december)\n ##-------------------\n #version 2.0: combined training of classifier and regressor, streamlined input\n #version 2.1: Tryied to updates excluded area to a little more than stripe 82 but decided not to keep it, so no change\n\n # Parse arguments\n args = parser.parse_args()\n\n return args","def parse_args(args):\n parser = argparse.ArgumentParser(\n description=\"Lookup table generator for Image Comparison\")\n parser.add_argument(\n \"--version\",\n action=\"version\",\n version=\"lookuptable {ver}\".format(ver=__version__))\n parser.add_argument(\n \"-f\",\n \"--folder\",\n dest=\"imagefolder\",\n help=\"path to image folder\",\n type=str,\n metavar=\"STRING\")\n parser.add_argument(\n \"-v\",\n \"--verbose\",\n dest=\"loglevel\",\n help=\"set loglevel to INFO\",\n action=\"store_const\",\n const=logging.INFO)\n parser.add_argument(\n \"-vv\",\n \"--very-verbose\",\n dest=\"loglevel\",\n help=\"set loglevel to DEBUG\",\n action=\"store_const\",\n const=logging.DEBUG)\n return parser.parse_args(args)","def parse_arguments(raw_args=sys.argv[1:]):\n parser = optparse.OptionParser(\n usage=\"usage: %prog [OPTIONS] DOMAIN_NAME DOMAIN_CONFIG_FILE\",\n description=\"A tool for provisioning a Khan Academy CloudSearch \"\n \"domain.\")\n\n parser.add_option(\"-v\", \"--verbose\", action=\"store_true\", default=False,\n help=\"If specified, DEBUG messages will be printed and more \"\n \"information will be printed with each log message.\")\n\n parser.add_option(\"--leave-temp-dir\", action=\"store_true\", default=False,\n help=\"If specified, the created temporary directory will not be \"\n \"deleted when the script exits.\")\n\n parser.add_option(\"-n\", \"--dry-run\", action=\"store_true\", default=False,\n help=\"If specified, no commands will actually be executed.\")\n\n parser.add_option(\"--no-reindex\", action=\"store_true\", default=False,\n help=\"If specified, will only update the config, without reindexing.\")\n\n options, args = parser.parse_args(raw_args)\n\n if len(args) != 2:\n parser.error(\"You must specify the name of the domain and a file \"\n \"containing the domain configuration.\")\n\n return (options, args[0], args[1])","def parse_arguments():\n p = argparse.ArgumentParser(description='Prepare the dataset for use by neural models.')\n p.add_argument(\"json_file\", type=argparse.FileType('r'), help=\"json file with all the data\")\n p.add_argument(\"prefix\", type=str, help=\"prefix for all the generated files\")\n p.add_argument(\"data_type\", type=str, choices=[\"names\", \"comments\", \"nc\"],\n default=\"nc\", help=\"type of the information recorded in the dataset\")\n p.add_argument(\"labels\", type=str, choices=[\"PROG\", \"ALL\", \"TOP\"],\n default=\"PROG\", help=\"method by which to choose the labels for the dataset\")\n p.add_argument(\"-other_label\", type=str, required=False, default=\"\",\n help=\"label to use instead of all infrequent labels. \"\n \"This can be left blank to ignore infrequent labels altogether\")\n p.add_argument(\"-label_num\", type=int, default=100, required=False,\n help=\"Number of most frequent labels to keep. Works with label_choice=TOP\")\n p.add_argument(\"-min_prog_labels\", type=int, default=5, required=False,\n help=\"Minimal number of programs a label has to appear in for it to be included \"\n \"in the dataset. Works with label_choice=PROG\")\n p.add_argument(\"-test_prog_list\", type=argparse.FileType('r'), default=None, required=False,\n help=\"file with the list of programs in the test set (optional)\")\n\n return p.parse_args(sys.argv[1:])","def parseArgs(args):\n parser = argparse.ArgumentParser(description = \"Scrapes baseball-reference.com for player statistics\")\n\n parser.add_argument(\"-d\", \"--domain\", help=\"domain to scrape for statistics. Default is baseball-reference.com\", nargs=1, default=[\"http://www.baseball-reference.com\"])\n parser.add_argument(\"-f\", \"--filename\", help=\"database file to store data in\", required=True, nargs=1, type=argparse.FileType(\"r+\"))\n parser.add_argument(\"-r\", \"--reset\", help=\"removes database before scraping all data from baseball-reference. Conflicts with -u. One of -r and -u must be specified\", action=\"store_true\")\n parser.add_argument(\"-u\", \"--update\", help=\"scrapes baseball-reference and adds all new information to the database. Conflicts with -r. One of -r and -u must be specified\", action=\"store_true\")\n parser.add_argument(\"--verbose\", help=\"enables verbose output\", action=\"store_true\")\n parser.add_argument(\"--version\", help=\"prints out version and exits\", action=\"version\", version=\"%(prog)s ({version})\".format(version=__version__))\n\n parsedArgs = parser.parse_args()\n\n if parsedArgs.reset == parsedArgs.update:\n parser.error(\"-r and -u are conflicting flags. Exactly one must be specified\")\n parser.print_help()\n\n return parsedArgs","def parse_cmdline():\n\tparser = ArgumentParser(prog=\"FastP_QC.py\", description=\"\"\"Script collects stats from fastp jsons.\"\"\")\n\tparser.add_argument(\"-r1\", \"--r1_stats\", dest=\"r1_stats\", action=\"store\", required=True, help=\"Text file with r1 stats, from q30.py script.\")\n\tparser.add_argument(\"-r2\", \"--r2_stats\", dest=\"r2_stats\", action=\"store\", required=True, help=\"Text file with r2 stats, from q30.py script.\")\n\tparser.add_argument(\"-n\", \"--name\", dest=\"name\", action=\"store\", required=True, help=\"Sample name\")\n\targs = parser.parse_args()\n\treturn args","def parse_args():\n parser = argparse.ArgumentParser(\n description='Run the destination IoT program (CTRL-C to exit)')\n\n parser.add_argument('-v',\n '--verbose',\n default=False,\n action='store_true',\n help='Print all debug logs')\n\n parser.add_argument('-p',\n '--port',\n metavar='<port number>',\n default=7777,\n type=int,\n help='Default: 7777')\n\n parser.add_argument('-a',\n '--address',\n metavar='<email_address>',\n nargs='*',\n help='Email address(es) to receive notifications')\n\n args = parser.parse_args()\n return args","def _ParseArgs():\n usage = \"usage: %prog [options]\"\n parser = optparse.OptionParser(usage=usage)\n\n parser.add_option('--width', type='int',\n default=352,\n help=('Width of the YUV file\\'s frames. '\n 'Default: %default'))\n parser.add_option('--height', type='int', default=288,\n help=('Height of the YUV file\\'s frames. '\n 'Default: %default'))\n parser.add_option('--crop_height', type='int', default=32,\n help=('How much of the top of the YUV file to crop. '\n 'Has to be module of 2. Default: %default'))\n parser.add_option('--yuv_file', type='string',\n help=('The YUV file to be cropped.'))\n parser.add_option('--output_file', type='string', default='output.yuv',\n help=('The output YUV file containing the cropped YUV. '\n 'Default: %default'))\n options = parser.parse_args()[0]\n if not options.yuv_file:\n parser.error('yuv_file argument missing. Please specify input YUV file!')\n return options","def parse_args(self, args):\n raise Exception(\"Not implemented\")","def parse_args():\n from argparse import ArgumentParser\n ap = ArgumentParser(prog=__exe__, description=__purpose__)\n ap.add_argument(\n '--host', dest='host', default=None,\n help='Host for XNAT. Default: env XNAT_HOST.')\n ap.add_argument(\n '-u', '--username', dest='username', default=None,\n help='Username for XNAT.')\n ap.add_argument('project', help='Project Label')\n ap.add_argument('session', help='Session Label')\n ap.add_argument(\n 'proc_suffix', help='Proc name suffix', nargs='?', default='')\n ap.add_argument(\n '-sd', '--subjects_dir', dest='subjects_dir',\n help='Subjects Directory',\n default=os.environ.get('SUBJECTS_DIR', '/tmp'))\n return ap.parse_args()","def parse_args():\n help_text = \"\"\"\n Analyzer of the frequency of use of nouns in the headings of posts on hubr.com\n \"\"\"\n parser = argparse.ArgumentParser(\n description=help_text\n )\n parser.add_argument(\n '-p',\n '--pages',\n type=int,\n dest='page_count',\n default=PAGE_COUNT,\n help=f'Number of pages to parse, default is {PAGE_COUNT}.'\n )\n parser.add_argument(\n '-s',\n '--start',\n type=int,\n default=PAGE_START,\n dest='start_page',\n help=f'Start page number, default is {PAGE_START}.',\n )\n parser.add_argument(\n '-t',\n '--top',\n type=int,\n default=TOP_SIZE,\n dest='top_size',\n help=f'The size of the top noun, default is {TOP_SIZE}.',\n )\n\n return parser.parse_args()","def parse_args():\n\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-i\", \"--input_path\", required=True)\n parser.add_argument(\"-c\", \"--config\", required=True)\n return parser.parse_args()","def parse_cmdline(argv):\n if argv is None:\n argv = sys.argv[1:]\n\n # initialize the parser object:\n parser = argparse.ArgumentParser(description='Calculates A and Ea from Gaussian output files using GoodVibes. '\n 'List files to be analyzed, reactant(s) first and ending with the '\n 'transition structure. These can be listed on the command line or in '\n 'a file (each line listing a set of reactant(s) and transition '\n 'structure).')\n parser.add_argument(\"-d\", \"--out_dir\", help=\"A directory where output files should be saved. The default location \"\n \"is the current working directory.\", default=None)\n parser.add_argument(\"-f\", dest=\"freq_cutoff\", help=\"Cut-off frequency for both entropy and enthalpy (wavenumbers) \"\n \"(default = 0)\", default=\"0\")\n parser.add_argument(\"-l\", \"--list\", help=\"The location of the list of Gaussian output files. \"\n \"The default file name.\", default=None)\n parser.add_argument(\"-q\", \"--quasiharmonic\", help=\"Use the '-q' option in GoodVibes, which turns on turns on \"\n \"quasi-harmonic corrections to both entropy and enthalpy in the \"\n \"Gibbs free energy (qh-G(T)) output from GoodVibes. \",\n action='store_true')\n parser.add_argument(\"--temp\", help=\"Temperature in K for calculating \\u0394G. The default is the first \"\n \"temperature in 'temp_range' (if specified). If a value is given, the program \"\n \"will use the temperature closest to it in the temp_range.\", default=None)\n parser.add_argument(\"-ti\", \"--temp_range\", help=\"Initial temp, final temp, (and optionally) step size (K) for \"\n \"thermochemistry calculations. The default range is 300,600,30\",\n default=\"300,600,30\")\n parser.add_argument(\"-v\", \"--vib_scale\", help=\"Scaling factor to be used for vibrational frequencies. If not \"\n \"provided, the GoodVibes default value will be used.\",\n default=None)\n parser.add_argument(\"-p\", \"--plot\", help=\"Make a \\u0394G plot at the specified temp. The default is False.\",\n action='store_true')\n parser.add_argument(\"-pl\", \"--plot_labels\", help=\"Optional labels for \\u0394G plot. Enter as a list.\",\n default=None)\n parser.add_argument(\"-c\", \"--vibes_check\", help=\"In addition to standard checks always run (matching solvent, \"\n \"level of theory, stoichiometry, charge, multiplicity, and \"\n \"Gaussian versions), run files through GoodVibes '--check' before \"\n \"performing calculations. The default is False.\",\n action='store_true')\n parser.add_argument(\"-o\", \"--output_fname\", help=\"The name of the output file to be created. The default is the \"\n \"list name with the extension '.csv', or '{}' if no list name \"\n \"provided.\".format(DEF_OUT_FILE_NAME), default=None)\n\n parser.add_argument(\"-s\", \"--save_vibes\", help=\"Save the output from running GoodVibes in separate files, \"\n \"named with the Gaussian log file prefix and '.dat'. \"\n \"The default is False.\",\n action='store_true')\n parser.add_argument(\"-t\", \"--tog_vibes\", help=\"Save the output from running GoodVibes in one file, \"\n \"renamed with the output file prefix and '.dat'. \"\n \"The default is False.\",\n action='store_true')\n\n args = None\n try:\n args = parser.parse_known_args(argv)\n options = args[0]\n if not options.out_dir:\n options.out_dir = os.getcwd()\n # user can define a new directory as the output directory\n if not os.path.exists(options.out_dir):\n os.makedirs(options.out_dir)\n\n if options.output_fname:\n options.output_fname = os.path.abspath(os.path.join(options.out_dir, options.output_fname))\n elif options.list:\n options.output_fname = create_out_fname(options.list, ext='.csv', base_dir=options.out_dir)\n else:\n options.output_fname = create_out_fname(DEF_OUT_FILE_NAME, ext='.csv', base_dir=options.out_dir)\n\n if options.plot_labels:\n options.plot_labels = options.plot_labels.split(',')\n else:\n options.plot_labels = ['']\n\n if options.vib_scale:\n options.vib_scale = float(options.vib_scale)\n\n except (SystemExit, ValueError) as e:\n if hasattr(e, 'code') and e.code == 0:\n return args, GOOD_RET\n warning(e)\n parser.print_help()\n return args, INPUT_ERROR\n\n return args, GOOD_RET","def parse_args():\n parser = argparse.ArgumentParser(description=__doc__)\n # If user doesn't specify an input file, read from standard input. Since\n # encodings are the worst thing, we're explicitly expecting std\n parser.add_argument('-i', '--infile',\n type=lambda x: open(x, encoding=ENCODE_IN),\n default=io.TextIOWrapper(\n sys.stdin.buffer, encoding=ENCODE_IN)\n )\n # Same thing goes with the output file.\n parser.add_argument('-o', '--outfile',\n type=lambda x: open(x, 'w', encoding=ENCODE_OUT),\n default=io.TextIOWrapper(\n sys.stdout.buffer, encoding=ENCODE_OUT)\n )\n # Set the verbosity level for the logger. The `-v` option will set it to\n # the debug level, while the `-q` will set it to the warning level.\n # Otherwise use the info level.\n verbosity = parser.add_mutually_exclusive_group()\n verbosity.add_argument('-v', '--verbose', action='store_const',\n const=logging.DEBUG, default=logging.INFO)\n verbosity.add_argument('-q', '--quiet', dest='verbose',\n action='store_const', const=logging.WARNING)\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser('Reading Comprehension on BaiduRC dataset')\n parser.add_argument('--prepare', action='store_true',\n help='create the directories, prepare the vocabulary and embeddings')\n parser.add_argument('--train', action='store_true',\n help='train the model')\n parser.add_argument('--generate', action='store_true',\n help='predict the answers for test set with trained model')\n parser.add_argument('--gentest', action='store_true',\n help='predict the answers for test set with trained model')\n parser.add_argument('--gpu', type=str, default='0',\n help='specify gpu device')\n\n train_settings = parser.add_argument_group('train settings')\n train_settings.add_argument('--optim', default='Adam',\n help='optimizer type')\n train_settings.add_argument('--learning_rate', type=float, default=0.001,\n help='learning rate')\n train_settings.add_argument('--weight_decay', type=float, default=0,\n help='weight decay')\n train_settings.add_argument('--dropout', type=float, default=0,\n help='dropout keep rate')\n train_settings.add_argument('--batch_size', type=int, default=128,\n help='train batch size')\n train_settings.add_argument('--epochs', type=int, default=10,\n help='train epochs')\n\n model_settings = parser.add_argument_group('model settings')\n model_settings.add_argument('--embed_size', type=int, default=128,\n help='size of the embeddings')\n model_settings.add_argument('--hidden_size', type=int, default=256,\n help='size of LSTM hidden units')\n model_settings.add_argument('--max_seq_len', type=int, default=50,\n help='max passage num in one sample')\n model_settings.add_argument('--max_gen_len', type=int, default=50,\n help='max length of passage')\n\n path_settings = parser.add_argument_group('path settings')\n path_settings.add_argument('--vocab_dir', default='../data/vocab/',\n help='the dir to save vocabulary')\n path_settings.add_argument('--model_dir', default='../data/models/',\n help='the dir to store models')\n path_settings.add_argument('--result_dir', default='../data/results/',\n help='the dir to output the results')\n path_settings.add_argument('--summary_dir', default='../data/summary/',\n help='the dir to write tensorboard summary')\n path_settings.add_argument('--log_path',\n help='path of the log file. If not set, logs are printed to console')\n return parser.parse_args()","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\n '--zarr_dir',\n type=str,\n help='path to directory of zarr files',\n )\n parser.add_argument(\n '--tiff_dir',\n type=str,\n help='path to directory of tiff files',\n )\n parser.add_argument(\n '--output_dir',\n type=str,\n help='path to directory for writing',\n )\n parser.add_argument(\n '--config_path',\n type=str,\n default=None,\n help='path to yaml preprocess config file',\n )\n \n args = parser.parse_args()\n return args","def ParseArguments():\n\n parser = argparse.ArgumentParser(description=__doc__)\n\n parser.add_argument('-f', '--file', help='Text file to be used (e.g. mem/sample_mem.txt)')\n parser.add_argument('--memsize', help='Memory size of generated memory')\n parser.add_argument('--memrange', help='Max range of memory in generated memory')\n parser.add_argument('--mempattern', help='Generated memory pattern focus (normal, loops, rep, random)')\n parser.add_argument('--cachesize', help='Cache size to be used')\n parser.add_argument('--linesize', help='Cache line size to be used')\n parser.add_argument('--mult', help='Run an entered number of simulations back-to-back')\n parser.add_argument('-t', '--test', help='Run tests to verify the simulator is functioning properly', action=\"store_true\")\n\n return parser.parse_args()","def parse_args():\n p = argparse.ArgumentParser(\n description='Parse system logs, for fun or something')\n p.add_argument('-l', '--log', dest='log_file', help='The log file')\n p.add_argument('-f', '--filter', dest='filter', help='filter by daemon')\n return p.parse_args()","def parse_args():\r\n desc = \"Check for the longest running requests in bookie\"\r\n parser = argparse.ArgumentParser(description=desc)\r\n\r\n parser.add_argument('-l', '--log', dest='log',\r\n action='store',\r\n default=None,\r\n required=True,\r\n help=\"log file we're reading requests from\")\r\n\r\n parser.add_argument('-n', '--number', dest='count',\r\n action='store',\r\n default=10,\r\n type=int,\r\n required=False,\r\n help=\"how many urls do we wish to see, default 10\")\r\n\r\n\r\n args = parser.parse_args()\r\n return args","def parse_arguments():\n parser = argparse.ArgumentParser(description=\"Parse Diff Exp output files\")\n parser.add_argument(\"raw_file\", help=\"DE analysis output file (.tab).\")\n parser.add_argument(\"output_json\", help=\"Output JSON\")\n parser.add_argument(\"output_file\", help=\"Output file\")\n parser.add_argument(\"--gene_id\", help=\"Gene_IDs column name\", type=str)\n parser.add_argument(\"--fdr\", help=\"FDR column name\", type=str)\n parser.add_argument(\"--pvalue\", help=\"Pvalue column name\", type=str)\n parser.add_argument(\"--fwer\", help=\"FWER column name\", type=str)\n parser.add_argument(\"--logodds\", help=\"Log Odds column name\", type=str)\n parser.add_argument(\"--logfc\", help=\"logfc column name\", type=str)\n parser.add_argument(\"--stat\", help=\"Statistics column name\", type=str)\n return parser.parse_args()","def arg_parse():\n p = ap.ArgumentParser()\n p.add_argument('infile',\n help='path to file containing objects')\n p.add_argument('n1',\n help='night 1')\n p.add_argument('n2',\n help='night 2')\n p.add_argument('observatory',\n help='Astropy name of observatory')\n return p.parse_args()","def parse_arguments():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-i\", \"--input\", dest=\"input_file\", help=\"input file or pattern\", default=\"\")\n parser.add_argument(\"-o\", \"--output\", dest=\"output_file\", help=\"output file or pattern\", default=\"\")\n parser.add_argument(\"-d\", \"--debug\", dest=\"debug\", action='store_true')\n parser.add_argument(\"-v\", \"--verbose\", dest=\"verbose\", action='store_true')\n parser.set_defaults(verbose=False)\n parser.set_defaults(debug=False)\n return parser.parse_args()","def parse(self, command_line=sys.argv[1:]):\n return self._parser.parse_args(command_line)","def parse_arguments():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-f\", \"--file\", help=\"file with the cohort you want to check / fix\", type=str, required=True)\n parser.add_argument(\"-o\", \"--outdir\", help=\"where should the files and the result readme be stored?\", type=str, required=True)\n return parser.parse_args()","def parse_args():\n\n parser = argparse.ArgumentParser()\n\n parser.add_argument(\n \"-i\", \"--input\", required=True, action=\"store\", dest=\"f_in\", help=\"input file\"\n )\n parser.add_argument(\n \"-o\",\n \"--output\",\n required=True,\n action=\"store\",\n dest=\"f_out\",\n help=\"stem of output file\",\n )\n\n parser.add_argument(\n \"-d\",\n \"--dir\",\n required=True,\n action=\"store\",\n dest=\"dir\",\n help=\"directory to save output files\",\n )\n\n parser.add_argument(\n \"-t\",\n \"--threshold\",\n required=False,\n action=\"store\",\n dest=\"thres\",\n default=0.85,\n help=\"threshold for the scoring function\",\n )\n\n parser.add_argument(\n \"-l\",\n \"--language\",\n required=True,\n action=\"store\",\n dest=\"lang\",\n help=\"provide language in order to set stop words\",\n )\n\n parser.add_argument(\n \"-min\",\n \"--minimum\",\n required=False,\n action=\"store\",\n dest=\"min\",\n default=100,\n help=\"minimum number of occurrences to be considered as ngram\",\n )\n\n parser.add_argument(\n \"--trigram\",\n required=False,\n action=\"store_true\",\n dest=\"trigram\",\n help=\"extracting trigrams in addition to bigrams\",\n )\n\n return parser.parse_args()","def parse_args():\n global Args\n parser = argparse.ArgumentParser()\n subparsers = parser.add_subparsers()\n pars_simulation(subparsers)\n pars_analyze(subparsers)\n Args = parser.parse_args()","def parse_arguments():\n\n parser = argparse.ArgumentParser(\n description=\"生成用户字符串识别的切分字符串\"\n )\n parser.add_argument(\n \"-o\",\n \"--output_dir\",\n type=str,\n nargs=\"?\",\n help=\"The output directory\",\n default=\"output/\"\n )\n parser.add_argument(\n \"-i\",\n \"--input_file\",\n type=str,\n nargs=\"?\",\n help=\"When set, this argument uses a specified text file as source for the text\",\n default=\"\",\n required=True\n )\n parser.add_argument(\n \"-mi\",\n \"--min_char_count\",\n type=int,\n nargs=\"?\",\n help=\"The minimum number of characters per line, Default is 3.\",\n default=3,\n\n )\n parser.add_argument(\n \"-ma\",\n \"--max_char_count\",\n type=int,\n nargs=\"?\",\n help=\"The maximum number of characters per line, Default is 20.\",\n default=20,\n )\n return parser.parse_args()","def parse_args(args):\n\n parser = argparse.ArgumentParser(\n description=\"\"\"Generates and runs an afni_proc.py script to preprocess resting state fMRI data\"\"\",\n formatter_class=argparse.RawDescriptionHelpFormatter)\n\n # Optional Flags\n parser.add_argument(\"-t\", \"--trs_remove\", action=\"store\", default=5, type=int, metavar='TRs',\n help=\"\"\"number of trs to remove at the beginning of the epi data\n (default = 5 trs)\"\"\")\n parser.add_argument(\"-d\", \"--dim_voxel\", action=\"store\", default=2.0, type=float, metavar='MM',\n help=\"voxel dimensions in mm that processed epi will be resampled to (default = 2.0 mm)\")\n parser.add_argument(\"-b\", \"--bandpass\", action=\"store\", default=[0.01, 0.25], nargs=2, type=float, metavar=\"F\",\n help=\"bandpass frequencies lower and upper limits (default = 0.01 0.25)\")\n parser.add_argument(\"-v\", \"--volumes\", action=\"store\", default=0, type=int, metavar=\"V\",\n help=\"\"\"truncate the epi data to the inputted number of volumes, useful if subjects have data \n with different numbers of volumes (default = no truncation)\"\"\")\n parser.add_argument(\"-f\", \"--fwhm\", action=\"store\", default=5.0, type=float, metavar=\"MM\",\n help=\"the full width half maximum that is used when blurring (default = 5.0 mm)\")\n parser.add_argument(\"-c\", \"--cores\", action=\"store\", default=cpu_count(), type=int, metavar=\"C\",\n help=\"number of cores supplied to 3dDeconvolve (default = all cores)\")\n parser.add_argument(\"-s\", \"--subj_id\", action=\"store\", default=\"sub\", metavar=\"SUB\",\n help=\"text file of subject ids (default = sub)\")\n parser.add_argument(\"-T\", \"--time_step\", action=\"store\", default=0, type=float, metavar=\"TS\",\n help=\"set the time step for bandpassing (default = ts in header info\")\n\n parser.add_argument(\"-g\", \"--global_signal_regression\", action=\"store_false\", default=True,\n help=\"do not perform global signal regression (default = perform gsr)\")\n\n parser.add_argument(\"-r\", \"--rerun\", action=\"store_true\", default=False,\n help=\"\"\"rerun preprocessing, override and delete previous results in \n 'Processed' folder (default = don't override)\"\"\")\n parser.add_argument(\"-m\", \"--motion_param\", action=\"store_true\", default=False,\n help=\"use 12 motion parameters for regression (default = 6 motion parameters)\")\n parser.add_argument(\"-G\", \"--gm_blur\", action=\"store_true\", default=False,\n help=\"blur only in grey matter mask (default = blur in whole brain)\")\n parser.add_argument(\"-n\", \"--nl_reg\", action=\"store_true\", default=False,\n help=\"use non-linear warp between anatomical and MNI template (default = linear warp)\")\n\n # Required Inputs\n required = parser.add_argument_group(\"required arguments\")\n required.add_argument(\"-e\", \"--epi\", action=\"store\", required=True,\n help=\"text file of paths to raw epi data\")\n required.add_argument(\"-a\", \"--anat\", action=\"store\", required=True,\n help=\"text file of paths to raw anatomical data\")\n required.add_argument(\"-o\", \"--out_dir\", action=\"store\", required=True, metavar=\"OUT\",\n help=\"text file of paths to output directory\")\n result = parser.parse_args(args)\n\n # Make sure inputted parameters are legal\n assert (os.path.isfile(result.epi)), \"{} does not exist or is not a file\".format(result.epi)\n assert (os.path.isfile(result.anat)), \"{} does not exist or is not a file\".format(result.ant)\n assert (result.trs_remove >= 0), \"Cannot remove negative trs\"\n assert (result.dim_voxel >= 0), \"Cannot have a negative voxel dimension\"\n assert (np.all(np.array(result.bandpass) > 0)), \"Cannot have a negative frequency limit for bandpassing\"\n assert (result.volumes > -1), \"Number of volumes must be greater than 0\"\n assert (result.cores > 0), \"Number of cores used must be greater than 0\"\n assert (result.time_step > -1), \"Time step must be greater than 0\"\n\n return result","def _parseArgs():\n # HINT: If you consider adding an option,\n # please consider adding a config file option first.\n parser = ArgumentParser(description=STRING_USAGE_DESCRIPTION,\n epilog=STRING_USAGE_EPILOG)\n parser.add_argument('--version', action='version',\n version='%(prog)s (' + VERSIONSTRING + ')')\n parser.add_argument('-c', '--configfile', action='store',\n dest='configfile',\n default=DEFAULT_CONFIGFILE,\n help=STRING_USAGE_CONFIGFILE)\n parser.add_argument('-e', '--editconfig', action='store_true',\n dest='invoke_editconfig',\n default=False,\n help=STRING_USAGE_EDITCONFIG)\n parser.add_argument('--defaultconfig', action='store_true',\n dest='invoke_defaultconfig',\n default=False,\n help=STRING_USAGE_DEFAULTCONFIG)\n parser.add_argument('--printconfig', action='store_true',\n dest='invoke_printconfig',\n default=False,\n help=STRING_USAGE_PRINTCONFIG)\n _addOverwriteBool(parser, 'gui', 'gui', 'enable')\n parser.add_argument('-s', '--sources', section='wesen',\n dest='sources',\n action=_OverwriteConfigAction)\n parser.add_argument('-r', '--resume',\n dest='resume', action='store_true',\n default=False, help=STRING_USAGE_RESUME)\n return parser.parse_known_args()","def parse_arguments():\n #usage = \"usage: %(prog)s [options] <message file>\" + DESCRIPTION\n parser = ArgumentParser()\n parser.add_argument('-v', '--version', action='version', version=VERSION)\n parser.add_argument('source', metavar='source', help='input logfile or directory with logfiles')\n\n \"\"\"\n parser.add_argument('-m', '--mat-id', metavar='string', # or stare_false\n dest=\"id_mat\", default='', # negative store value\n help=\"material id to grep\")\n parser.add_argument('-c', '--count', metavar='N', type=int, # or stare_false\n dest=\"count\", default=0, # negative store value\n help=\"count\")\n parser.add_argument('-p', '--pattern', metavar='string', # or stare_false\n dest=\"pattern\", default='xxx', # negative store value\n help=\"search pattern within logfile\")\n \"\"\"\n return parser.parse_args()","def parse_arguments():\n parser = argparse.ArgumentParser(description='Helps analyze articles.')\n parser.add_argument('--config', default='config.yaml',\n help='Configuration file for the options of this script')\n parser.add_argument('--search', default=None, type=str,\n help='Search for text in the articles')\n parser.add_argument('--case-sensitive', action='store_true',\n help='Makes search case-senstive (only applicatble to --search)')\n parser.add_argument('--list', default=None, type=str,\n help='List [title|authors|date|word-count|author|excerpt|content] of the articles')\n parser.add_argument('--sort', action='store_true',\n help='Sorts output (only applicable to --list).')\n parser.add_argument('--sort-by', default=None, type=str,\n help='Sorts output by another attribute [title|author|date] (only applicable to --list)')\n parser.add_argument('--statistics', action='store_true',\n help='Gives basic statistics about the articles.')\n parser.add_argument('--count-articles', action='store_true',\n help='Counts the total number of articles')\n parser.add_argument('--count-words', action='store_true',\n help='Counts the total number of words')\n parser.add_argument('--count-paragraphs', action='store_true',\n help='Counts the total number of paragraphs')\n parser.add_argument('--count-by-author', action='store_true',\n help='Counts the number of articles by each author')\n parser.add_argument('--count-by-year', action='store_true',\n help='Counts the number of articles bucketed by year')\n parser.add_argument('--count-by-months', default=None, type=int,\n help='Counts the number of articles bucketed by number of months')\n \n return parser, parser.parse_args()","def parse_command_line_arguments():\n parser = argparse.ArgumentParser(\n description=\"Convert dependency files into list of GitHub links.\",\n epilog=\"For help with this program, contact John Speed at jmeyers@iqt.org.\",\n )\n parser.add_argument(\n \"--python\",\n default=False, # default value is False\n help=\"Convert requirements.txt file into GitHub links.\",\n )\n return parser.parse_args()","def parse_arguments():\n parser = argparse.ArgumentParser(description=\"Parse library type information.\")\n parser.add_argument(\"input_file\", help=\"Salmon library type information file.\")\n return parser.parse_args()","def _parse_args():\n parser = argparse.ArgumentParser(description='Pure-python command-line calculator.')\n\n parser.add_argument('EXPRESSION', action=\"store\", type=str, help=\"expression string to evaluate\")\n parser.add_argument('-m', '--use-modules', nargs='+', action=\"store\", dest=\"MODULE\", type=str,\n help=\"additional modules to use\")\n\n return parser.parse_args()","def parse_args():\n if len(sys.argv) < REQUIRED_NUM_ARGS or len(sys.argv) > MAXIMUM_NUM_ARGS:\n error_quit(\"Incorrect number of arguments!\", 400)\n # Set port to DEFAULT if not specified as an arg. Otherwise, port = portarg.\n port = sys.argv[PORT_ARG_NUM] if len(sys.argv) == MAXIMUM_NUM_ARGS else DEFAULT_FTP_PORT\n port = validate_port(port)\n # Get host address and logfile name from args.\n host, log_file = sys.argv[HOST_ARG_NUM], sys.argv[LOG_ARG_NUM]\n return host, log_file, port","def parse_cmdline(argv):\n if argv is None:\n argv = sys.argv[1:]\n\n # initialize the parser object:\n parser = argparse.ArgumentParser(description='For each timestep, gather the energy information output by LAMMPS '\n 'in the log file.')\n parser.add_argument(\"-f\", \"--file\", help=\"The log file to be processed.\",\n default=None)\n parser.add_argument(\"-l\", \"--list_file\", help=\"The a file with a list of log files to be processes.\",\n default=None)\n args = None\n try:\n args = parser.parse_args(argv)\n if args.file is None:\n args.file_list = []\n else:\n if os.path.isfile(args.file):\n args.file_list = [args.file]\n args.source_name = args.file\n else:\n raise IOError(\"Could not find specified log file: {}\".format(args.file))\n if args.list_file is not None:\n args.file_list += file_rows_to_list(args.list_file)\n args.source_name = args.list_file\n if len(args.file_list) < 1:\n raise InvalidDataError(\"Found no log file names to process. Specify one or more files as specified in \"\n \"the help documentation ('-h').\")\n except IOError as e:\n warning(\"Problems reading file:\", e)\n parser.print_help()\n return args, IO_ERROR\n except (KeyError, InvalidDataError, SystemExit) as e:\n if hasattr(e, 'code') and e.code == 0:\n return args, GOOD_RET\n warning(e)\n parser.print_help()\n return args, INPUT_ERROR\n return args, GOOD_RET","def parse_arguments():\n \n parser = argparse.ArgumentParser()\n parser.add_argument(\"postcode\", type=str, help=\"Postcode of current location\")\n parser.add_argument(\"-d\", \"--debug\", \n help=\"Turns on debug mode\", \n action='store_true')\n parser.add_argument(\"-fp\",\"--postcode-file\", \n default=\"postcodes_swift_sample.csv\",\n help=\"Location of Postcode CSV file (default postcodes_swift_sample.csv)\",\n type=str)\n parser.add_argument(\"-fb\",\"--pub-file\", \n default=\"pubnames_swift_sample.csv\",\n help=\"Location of Pub Postcode CSV file (default pubnames_swift_sample.csv)\",\n type=str)\n parser.add_argument(\"-l\",\"--limit\", \n default=10, \n help=\"Limit Number of Results (default 10)\",\n type=int)\n parser.add_argument(\"-m\",\"--max-distance\", \n default=50, \n help=\"Only return results less than this distance (default 50)\",\n type=int)\n return parser","def parse_args():\n\n parser = argparse.ArgumentParser(description='CLI to store Actisense-NGT Gateway values to InfluxDB and publish via MQTT')\n parser.add_argument('--config', '-c', type=str, required=True, help='JSON configuraton file with path')\n return parser.parse_args()","def parse_arguments():\n parser = argparse.ArgumentParser(description=\"Note: Plot depth files.\")\n parser.add_argument(\"-d\", \"--depth_dir\", help='depth file directory')\n parser.add_argument(\"-r\", \"--result_dir\", help='output directory')\n parser.add_argument(\"-f\", \"--ref\", help='one depth file as ref')\n parser.add_argument(\"-w\", \"--window_size\", help='sliding window size')\n\n args = parser.parse_args()\n return args","def parse_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-t\", \"--thoughtspot_host\", required=True,\n help=\"domain or ip. E.g. http://1.1.1.1\")\n parser.add_argument(\"-u\", \"--username\", required=True,\n help=\"username - must have administrative privileges\")\n parser.add_argument(\"-p\", \"--password\", required=True,\n help=\"password - must have administrative privileges\")\n parser.add_argument(\"-d\", \"--delimiter\", default=',',\n help=\"character to seperate values by. Default to comma\")\n parser.add_argument(\"-c\", \"--csv\", action=\"store_true\",\n help=\"create csv file called permissions.csv\")\n parser.add_argument(\"-s\", \"--share\", action=\"store_true\",\n help=\"output usable format for share api\")\n return parser.parse_args()","def _parse_args():\n parser = argparse.ArgumentParser(description=\"\")\n #parser.add_argument(\"args\", metavar=\"N\", type=str, nargs=\"*\", help=\"Positional arguments.\")\n #parser.add_argument(\"\", dest=\"\", type=\"\", default=, help=)\n #parser.add_argument(\"--version\", action=\"version\", version=\"<the version>\")\n\n return parser.parse_args()","def _parse_args():\n usage = \"usage: %prog [options] arg1 arg2\"\n parser = optparse.OptionParser()\n parser.add_option(\n '--platform', dest='platform', default=\"\", type = \"string\",\n help='platform name: UC 360 baidu etc.')\n parser.add_option(\n '--workspace', dest='workspace', default=\"./\", type = \"string\",\n help='project directory.')\n parser.add_option(\n '--project', dest='projectDir', default=\"./destProject\", type = \"string\",\n help='project directory.')\n # parser.add_option(\n # \"-t\", dest=\"test\", action=\"store_const\", const=lambda:_test, default=_test2, help=\"////////////\"\n # )\n options, args = parser.parse_args()\n # positional arguments are ignored\n return options, args","def parse_args():\n parser = MyParser(description='Data processing and analytics library \\\n for OpenStack Browbeat perf data')\n\n parser.add_argument('-s', '--summary', dest=\"days\", type=int, default=-1,\n help='-s N summary of last N days of results')\n\n parser.add_argument('--summary-uuid', dest=\"summary_uuid\", type=str,\n default=None,\n help='--summary-uuid UUID summary of a specific uuid')\n\n parser.add_argument('--short-summary', dest=\"short_days\", type=int,\n default=-1,\n help='--short-summary N gives \\\n summary of last N days of results but uses cockroach \\\n db so only provides with basic summary')\n\n parser.add_argument('--upload-timesummary', dest=\"timeseries_uuid\",\n type=str, default=None,\n help='--upload-timesummary UUID \\\n uploads the features computed from data obtained from\\\n graphite. ')\n\n parser.add_argument('--upload-logsummary', dest=\"loggin_uuid\",\n type=str, default=None,\n help='--upload-logsummary UUID \\\n uploads the log summary to crdb \\\n currently just summarizes over entire timeperiod. ')\n\n parser.add_argument('-u', '--update-db', dest='update', type=bool,\n default=False,\n help='-u True pushes data to cockroach db')\n\n parser.add_argument('--update-clf', dest=\"clf_days\", type=int,\n default=-1,\n help='--update-clf 60 will update all classifiers \\\n listed in config file under classifier_lists \\\n using data from last 60 days')\n\n parser.add_argument('--test-clf', dest=\"test_days\", type=int,\n default=-1,\n help='--test-clf 60 will train all classifiers \\\n listed in config file under classifier_lists \\\n using data from last 60 days and then test it \\\n and display metrics')\n\n parser.add_argument('-v', '--osp-version', dest='version', type=str,\n default=None,\n help='-v 11-tripleo only returns hits for that \\\n OpenStack version, \\\n only supported by summary right now')\n\n parser.add_argument('-c', '--config', dest='config', type=str,\n default=pkg_resources.resource_filename('bml',\n \"config.yml\"),\n help='-c <config file path> use custom config file')\n\n args = parser.parse_args()\n return args"],"string":"[\n \"def parse_arguments(args):\",\n \"def parse_command_line(self, argv):\\n from optparse import OptionParser\\n usage = \\\"usage: %prog [options]\\\"\\n parser = OptionParser(usage)\\n\\n (options, args) = parser.parse_args(argv)\",\n \"def parseArguments(self):\\n iterator = iter(sys.argv[1:]) # Skip file name\\n for argument in iterator:\\n if len(argument) < 2 or argument[:2] != '--':\\n self.error('syntax error \\\"{}\\\"'.format(argument))\\n else:\\n def getValueOfArgument(): return next(iterator)\\n self.parseArgument(argument[2:], getValueOfArgument)\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"Reads datapacket pcds, interpolates quaternions and generates scans from dataset in config file\\\")\\n parser.add_argument(\\\"--visualization\\\", \\\"-v\\\", action=\\\"store_true\\\", help=\\\"if generated clouds should be visualized\\\")\\n parser.add_argument(\\\"--directory\\\", \\\"-d\\\",\\n help=\\\"if only specified directory should be interpolated, e.g. 'fragments/fragment0'\\\")\\n args = parser.parse_args()\\n return args.visualization, args.directory\",\n \"def parse_arguments(self):\\n \\n for arg in sys.argv[1:]:\\n (key, sep, value) = arg.partition(\\\"=\\\")\\n if sep != \\\"=\\\":\\n raise ProcessorError(\\\"Illegal argument '%s'\\\" % arg)\\n self.update_data(key, value)\",\n \"def parse_command_line_arguments():\\n\\n description, epilog = __doc__.split(\\\"\\\\n\\\\n\\\", 1)\\n\\n parser = argparse.ArgumentParser(\\n formatter_class=argparse.RawDescriptionHelpFormatter,\\n description=description,\\n epilog=epilog)\\n\\n parser.add_argument('-s', '--s', dest='s', action='store', type=float, required=True,\\n help='Minimum frequency')\\n parser.add_argument('-c', '--credentials', dest='credentials', action='store',\\n default=\\\"./.tpass\\\",\\n help='File with Twitter credentials (username and password, separated by a space)')\\n\\n args = parser.parse_args()\\n \\n return args\",\n \"def parse_command_line_arguments(argv):\\n print(\\\"reading command line arguments in...\\\")\\n\\n parser = argparse.ArgumentParser(description='Description of your program')\\n parser.add_argument('-i', '--input', help='Location of input csv file', required=True)\\n parser.add_argument('-p', '--predicting', help='The column name containing the category to predict', required=True)\\n parser.add_argument('-s', '--scoring', help='The scoring type to be used with model evaluation', required=False)\\n parser.add_argument('-c', '--scale', help='List of column names to scale values for', nargs='+', required=False)\\n args = parser.parse_args()\\n\\n return args.input, args.predicting, args.scoring, args.scale\",\n \"def __parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('-f', '--force', action=\\\"store_true\\\", default=False,\\n help='overwrite existing database files during import')\\n parser.add_argument('-e', '--extension', action=\\\"store\\\", default='txt',\\n help='specify file extension. default is \\\"txt\\\"')\\n parser.add_argument('-d', '--delimiter', action=\\\"store\\\", default='\\\\t',\\n help='specify column delimiter. default is tab (\\\\\\\\t)')\\n parser.add_argument('-m', '--mark', action=\\\"store\\\", default='.',\\n help='specify decimal mark for numeric data. default is'\\n ' dot (.)')\\n parser.add_argument('-o', '--outformat', action=\\\"store\\\", default='npz',\\n help='specify output database format. default is \\\"npz\\\"'\\n ' for numpy database. use \\\"mat\\\" for matlab '\\n ' database format.')\\n parser.add_argument('-r', '--recursive', action=\\\"store_true\\\", default=False,\\n help='recursively walk through all sub-directories of'\\n ' current working directory')\\n parser.add_argument('-p', '--pcs', action=\\\"store_true\\\", default=True,\\n help='indicate if files are pcs files.')\\n parser.add_argument('-c', '--colheadlines', action=\\\"store\\\", default='1',\\n help='number of lines spanned by the column headers')\\n args = parser.parse_args()\\n return args\",\n \"def parse_arguments():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('-u', '--urls_dirpath', type=unicode)\\n parser.add_argument('-r', '--resources_dir', type=unicode)\\n parser.add_argument('-t', '--total_docs', type=int)\\n parser.add_argument('-m', '--mapping', type=unicode,\\n help='File with the yago to lkif mapping')\\n\\n return parser.parse_args()\",\n \"def __parse_args(self):\\n for argument in self.args:\\n source_arg = re.match(\\\"^(--source=(([A-Z]|[a-z]|/|_|[0-9]|.)+))$\\\", argument)\\n input_arg = re.match(\\\"^(--input=(([A-Z]|[a-z]|/|_|[0-9]|.)+))$\\\", argument)\\n stats_arg = re.match(\\\"^(--stats=(([A-Z]|[a-z]|/|_|[0-9]|.)+))$\\\", argument)\\n help_arg = re.match(\\\"^--help$\\\", argument)\\n vars_arg = re.match(\\\"^--vars$\\\", argument)\\n insts_arg = re.match(\\\"^--insts$\\\", argument)\\n if source_arg:\\n self.sourceFile = source_arg.group(2)\\n self.passedArgs.append(\\\"source\\\")\\n elif input_arg:\\n self.inputFile = input_arg.group(2)\\n self.passedArgs.append(\\\"input\\\")\\n elif help_arg:\\n print(\\\"napoveda\\\")\\n sys.exit(0)\\n elif stats_arg:\\n self.statsFile = stats_arg.group(2)\\n self.passedArgs.append(\\\"stats\\\")\\n elif vars_arg:\\n self.passedArgs.append(\\\"vars\\\")\\n if self.first_stat_arg is None:\\n self.first_stat_arg = \\\"vars\\\"\\n elif insts_arg:\\n self.passedArgs.append(\\\"insts\\\")\\n if self.first_stat_arg is None:\\n self.first_stat_arg = \\\"insts\\\"\\n else:\\n raise ArgError(\\\"Unknown argument or format of the argument! (\\\" + argument + \\\")\\\")\",\n \"def parse_arguments():\\n parser = argparse.ArgumentParser(prog='AdapterRunner', description='Adapter Runner Application')\\n parser.add_argument('-a', '--application', action='store', dest='app_name', help='Application Name',\\n metavar='<application_name>')\\n parser.add_argument('-fi', '--fetch_interval', action='store', dest='fetch_stats_interval', help='Fetch Stats Interval',\\n metavar='<fetch_interval in seconds>')\\n return parser.parse_args()\",\n \"def _parse_command_line_arguments():\\n parser = ArgumentParser(\\n description=(\\n 'Command-line tool to generate a list of unique from a TS file from FermiFAST'\\n ),\\n )\\n parser.add_argument(\\n 'ts-file',\\n type=str,\\n help=(\\n 'A file containing the TS sky map'\\n ),\\n )\\n parser.add_argument('--skiprows',\\n type=int,\\n help='number of rows to skip at the top (default 0)',\\n required=False)\\n parser.set_defaults(skiprows=0)\\n arguments = vars(parser.parse_args())\\n return arguments\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=\\\"Bandits algorithms on a click-through \\\"\\n \\\"rate dataset.\\\")\\n parser.add_argument('--plot', action='store_true')\\n return parser.parse_args()\",\n \"def parse_arguments(args=sys.argv[1:]):\\n \\n parser = argparse.ArgumentParser()\\n \\n parser.add_argument('-i', '--input',\\n help=\\\"Path of input file to read. Default: {d}\\\".format(d=INPUT_FILE),\\n default=INPUT_FILE)\\n \\n return parser.parse_args(args)\",\n \"def parse_args():\\n parser = default_argument_parser()\\n parser.add_argument(\\\"--label-map\\\",\\n dest=\\\"label_map\\\",\\n type=pathlib.Path,\\n help=\\\"Label map in YAML format which maps from category \\\"\\n \\\"ID to name.\\\")\\n parser.add_argument(\\\"--train-csv\\\",\\n dest=\\\"train_csv\\\",\\n required=True,\\n type=pathlib.Path,\\n help=\\\"Path to training data CSV file.\\\")\\n parser.add_argument(\\\"--valid-csv\\\",\\n dest=\\\"valid_csv\\\",\\n required=False,\\n type=pathlib.Path,\\n help=\\\"Optional path to validation data CSV file.\\\")\\n parser.add_argument(\\n \\\"--image-width\\\",\\n type=int,\\n help=\\\"Image width (optional, used to speed up dataset processing).\\\")\\n parser.add_argument(\\n \\\"--image-height\\\",\\n type=int,\\n help=\\\"Image height (optional, used to speed up dataset processing).\\\")\\n return parser.parse_args()\",\n \"def _parse_args(argv):\\n parser = make_parser()\\n args = parser.parse_args(argv)\\n LOGGER.setLevel(to_log_level(args.loglevel))\\n\\n if not args.inputs:\\n if args.list:\\n tlist = \\\", \\\".join(API.list_types())\\n _exit_with_output(\\\"Supported config types: \\\" + tlist)\\n elif args.env:\\n cnf = os.environ.copy()\\n _output_result(cnf, args.output, args.otype or \\\"json\\\", None, None)\\n sys.exit(0)\\n else:\\n parser.print_usage()\\n sys.exit(1)\\n\\n if args.validate and args.schema is None:\\n _exit_with_output(\\\"--validate option requires --scheme option\\\", 1)\\n\\n return args\",\n \"def parse_command_line():\\r\\n\\r\\n parser = argparse.ArgumentParser(description='User args')\\r\\n parser.add_argument(\\\"--action\\\", choices=['train', 'predict', 'demo', 'test'], required=True, help=\\\"Choose action.\\\")\\r\\n parser.add_argument(\\\"--model\\\", choices=['vgg', 'unet', 'fpn'], required=True, help=\\\"Choose model.\\\")\\r\\n parser.add_argument(\\\"--dataset\\\", choices=['full', 'small'], required=True, help=\\\"Choose dataset.\\\")\\r\\n\\r\\n return parser.parse_args()\",\n \"def parse_command_line():\\n parser = argparse.ArgumentParser()\\n\\n help_str = \\\\\\n 'The collection folder to sort files into. ' \\\\\\n 'If the folder does not exist, it will be created along with the ' \\\\\\n 'necessary contents.'\\n parser.add_argument('-c', '--collection', help=help_str)\\n\\n help_str = \\\\\\n 'The source folder to import files from. Has to exist and ' \\\\\\n 'has to be a folder.'\\n parser.add_argument('-s', '--source', help=help_str, required=False)\\n\\n help_str = \\\\\\n 'View the gallery in random order auto skpping after the' \\\\\\n 'given amount of seconds'\\n parser.add_argument('-v', '--view', help=help_str, required=False)\\n\\n return parser.parse_args()\",\n \"def parse_command_line_arguments():\\n parser = argparse.ArgumentParser()\\n\\n # Positional args\\n parser.add_argument('data_directory', action=\\\"store\\\")\\n\\n # Optional args\\n parser.add_argument('--save_dir', action='store',\\n dest='save_dir',\\n help='Load categories names from given file',\\n default=\\\"checkpoint.pth\\\")\\n\\n parser.add_argument('--gpu', action='store_true',\\n dest='device',\\n help='Device of prediction processing',\\n default=False)\\n\\n parser.add_argument('--arch', action='store',\\n dest='arch',\\n help='Name of pre-trained network used for training',\\n default=\\\"vgg11\\\")\\n\\n parser.add_argument('--learning_rate', action='store',\\n dest='learning_rate',\\n help='value of training learning rate',\\n default=0.001)\\n\\n parser.add_argument('--hidden_units', action='store',\\n dest='hidden_units',\\n help='Number of units in the fully-connected hidden '\\n 'layer of the neural netwrork',\\n default=512)\\n\\n parser.add_argument('--epochs', action='store',\\n dest='epochs',\\n help='Number of training epochs',\\n default=5)\\n\\n # Parse all args\\n results = parser.parse_args()\\n\\n return results\",\n \"def parse_cmd_arguments():\\n parser = argparse.ArgumentParser(description='Process some integers.')\\n parser.add_argument('-i', '--input', required=True, help='input JSON file')\\n parser.add_argument('-o', '--output', required=True,\\n help='ouput JSON file')\\n parser.add_argument('-d', '--debug', required=False,\\n help='log level. Can be 0-3. Defaults to 0')\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"-t\\\", \\\"-threads\\\", help=\\\"specifies a thread count for parallel operations\\\", type=int)\\n return parser.parse_args()\",\n \"def process_command_line_arguments() -> Namespace:\\n\\n parser = build_parser()\\n arguments = parser.parse_args()\\n\\n return arguments\",\n \"def parse_arguments():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"-e\\\", \\\"--events\\\", type=str,\\n help=\\\"path to events CSV-file\\\")\\n parser.add_argument(\\\"-d\\\", \\\"--data\\\", type=str,\\n help=\\\"path to data CSV-file\\\")\\n parser.add_argument(\\\"-l\\\", \\\"--limit\\\", nargs='?', type=int, default=None,\\n help=\\\"max records to be processed\\\")\\n parser.add_argument(\\\"-t\\\", \\\"--timezone\\\", nargs='?', type=int, default=5,\\n help=\\\"date and time shift\\\")\\n parser.add_argument(\\\"-o\\\", \\\"--optimized\\\", action='store_true',\\n help=\\\"if specified, then data CSV will be processed\\\"\\n \\\" by small chunks to escape memory issues\\\")\\n parser.add_argument(\\\"-v\\\", \\\"--verbose\\\", action='store_true')\\n parser.add_argument(\\\"--output-folder\\\", nargs='?', type=str,\\n default=\\\"linked\\\")\\n return vars(parser.parse_args())\",\n \"def parse_args(args=None):\\n return AP.parse_args(args=args)\",\n \"def parse_args():\\n\\tparser = argparse.ArgumentParser(description='Show video statistics.')\\n\\tparser.add_argument('--sort', metavar='FIELD', choices=['views', 'likes', 'dislikes'],\\n\\t default='views',\\n\\t help='sort by the specified field. Options are views, likes and dislikes.')\\n\\tparser.add_argument('--max', metavar='MAX', type=int, help='show the top MAX entries only.')\\n\\tparser.add_argument('--csv', action='store_true', default=False,\\n\\t help='output the data in CSV format.')\\n\\tparser.add_argument('--table', action='store_true', default=False,\\n\\t help='output the data in an ascii table.')\\n\\tparser.add_argument('--workers', type=int, default=8,\\n\\t help='number of workers to use, 8 by default.')\\n\\treturn parser.parse_args()\",\n \"def parse_args(args=None):\\n\\t\\treturn _get_args_parser().parse_args(args)\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n \\\"-d\\\",\\n \\\"--debug\\\",\\n help=\\\"Print lots of debugging statements\\\",\\n action=\\\"store_const\\\",\\n dest=\\\"loglevel\\\",\\n const=logging.DEBUG,\\n default=logging.ERROR,\\n )\\n parser.add_argument(\\n \\\"-v\\\",\\n \\\"--verbose\\\",\\n help=\\\"Be verbose\\\",\\n action=\\\"store_const\\\",\\n dest=\\\"loglevel\\\",\\n const=logging.INFO,\\n )\\n parser.add_argument(\\\"runscript\\\", default=None)\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('n_iter',\\n help='number of iteration',\\n type=int)\\n parser.add_argument('n_processes',\\n help='number of processes',\\n type=int)\\n parser.add_argument('method',\\n help='mutual exclusion method')\\n parser.add_argument('duration',\\n help='Duration of each process',\\n type=float)\\n return parser.parse_args()\",\n \"def parse_arguments():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n \\\"--obs_len\\\",\\n default=20,\\n type=int,\\n help=\\\"Directory where the sequences (csv files) are saved\\\",\\n )\\n parser.add_argument(\\n \\\"--data_dir\\\",\\n default=\\\"\\\",\\n type=str,\\n help=\\\"Directory where the sequences (csv files) are saved\\\",\\n )\\n parser.add_argument(\\n \\\"--feature_dir\\\",\\n default=\\\"\\\",\\n type=str,\\n help=\\\"Directory where the computed features are saved\\\",\\n )\\n parser.add_argument(\\\"--mode\\\",\\n required=True,\\n type=str,\\n help=\\\"train/val/test/compute_all/lanes_only\\\")\\n parser.add_argument(\\n \\\"--sequence_num\\\",\\n default=-1,\\n type=int,\\n help=\\\"Specify a specific sequence to visualize.\\\",\\n )\\n parser.add_argument(\\n \\\"--batch_start\\\",\\n default=0,\\n type=int,\\n help=\\\"Specify the starting row of features to visualize.\\\",\\n )\\n parser.add_argument(\\n \\\"--batch_end\\\",\\n default=-1,\\n type=int,\\n help=\\\"Specify the last row to visualize, -1 to visualize till end.\\\",\\n )\\n parser.add_argument(\\n \\\"--single_figure\\\",\\n default=False,\\n action=\\\"store_true\\\",\\n help=\\\"Plot all candidates for a scenein one figure.\\\",\\n )\\n return parser.parse_args()\",\n \"def argumentsParser(args):\\n\\targuments = []\\n\\tif args.find('\\\"') > -1:\\n\\t\\tt_arguments = args.split('\\\"')\\n\\t\\tfor a in t_arguments:\\n\\t\\t\\tif a == '' or a == ' ':\\n\\t\\t\\t\\tpass\\n\\t\\t\\telif a[-1] == ' ':\\n\\t\\t\\t\\targuments.append(a[:-1])\\n\\t\\t\\telse:\\n\\t\\t\\t\\targuments.append(a)\\n\\telif args.find(\\\"'\\\") > -1:\\n\\t\\tt_arguments = args.split(\\\"'\\\")\\n\\t\\tfor a in t_arguments:\\n\\t\\t\\tif a == '' or a == ' ':\\n\\t\\t\\t\\tpass\\n\\t\\t\\telif a[-1] == ' ':\\n\\t\\t\\t\\targuments.append(a[:-1])\\n\\t\\t\\telse:\\n\\t\\t\\t\\targuments.append(a)\\n\\telif args == ' ':\\n\\t\\tpass\\n\\telse:\\n\\t\\targuments = args.split(' ')\\n\\treturn arguments\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description='Google reminders cli',\\n epilog=usage,\\n formatter_class=argparse.RawTextHelpFormatter)\\n return parser.parse_args()\",\n \"def parseArgs():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('--dataset', default='fsod', help='training dataset') # use fsod dataset for default\\n parser.add_argument('--cfg', dest='cfg_file', required=True, help='optional config file')\\n parser.add_argument('--load_ckpt', help='path to load checkpoint')\\n parser.add_argument('--load_detectron', help='path to load detectron weight pickle file')\\n parser.add_argument('--output_dir', help='output directory to save the testing results.')\\n parser.add_argument('--range', help='[start, end)', type=int, nargs=2)\\n parser.add_argument('--visualize', dest='visualize', help='output images of detection', action='store_true')\\n return parser.parse_args()\",\n \"def parse_arguments():\\n parser = ArgumentParser()\\n\\n # For development/testing\\n parser.add_argument(\\\"--dev\\\", help=\\\"run the code of the developers tag\\\")\\n\\n return parser.parse_args()\",\n \"def parse_command_line():\\n parser = argparse.ArgumentParser()\\n\\n # All reference encoders\\n parser.add_argument(\\\"--step\\\", dest=\\\"step\\\", default=\\\"10\\\", type=int, help=\\\"step size\\\")\\n parser.add_argument(\\\"--repeats\\\", dest=\\\"repeats\\\", type=int, default=1, help=\\\"repeats\\\")\\n\\n parser.add_argument(dest=\\\"image\\\", default=None,\\n help=\\\"select the test image to run\\\")\\n\\n args = parser.parse_args()\\n return args\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"Subscription Watch CSV file packaging script\\\", prog=sys.argv[0])\\n\\n # required args\\n parser.add_argument(\\\"-f\\\", \\\"--filepath\\\", required=True,\\n help=\\\"path to files to package\\\")\\n parser.add_argument(\\n \\\"-s\\\",\\n \\\"--max-size\\\",\\n type=int,\\n default=DEFAULT_MAX_SIZE,\\n help=f\\\"Maximum size of packages in MiB. (Default: {DEFAULT_MAX_SIZE} MiB)\\\",\\n )\\n parser.add_argument(\\n \\\"-o\\\", \\\"--overwrite\\\", action=\\\"store_true\\\", default=False, help=\\\"whether to overwrite existing files.\\\"\\n )\\n parser.add_argument(\\\"--ocp-cluster-id\\\", required=True,\\n help=\\\"OCP Cluster ID\\\")\\n parser.add_argument(\\\"-v\\\", \\\"--verbosity\\\", action=\\\"count\\\",\\n default=0, help=\\\"increase verbosity (up to -vvv)\\\")\\n return parser.parse_args()\",\n \"def parseArgs():\\n parser = argparse.ArgumentParser(description='Runs RHEAS simulation.')\\n parser.add_argument('config', help='configuration file')\\n parser.add_argument('-d', metavar='DB', help='name of database to connect')\\n parser.add_argument('-u', help='update database', action='store_true')\\n args = parser.parse_args()\\n return args.config, args.d, args.u\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n '--version',\\n metavar=\\\"<str>\\\",\\n help=\\\"Input data version number\\\",\\n type=str,\\n required=True\\n )\\n args = parser.parse_args()\\n return args\",\n \"def parse_arguments():\\n parser = argparse.ArgumentParser(description=\\\"\\\"\\\"A script to get the kmer frequency\\n from csv files with kmer counts from genomes.\\\"\\\"\\\")\\n\\n parser.add_argument('-sd',\\n '--sub_dir',\\n type=str,\\n dest='sub_dir',\\n help='Subdirectory name for output files.') # kmer_count\\n\\n parser.add_argument('-do',\\n '--dir_out',\\n type=str,\\n dest='dir_out',\\n help='directory name for output files.') # Results/kmer_freq\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n \\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n 'config',\\n help='Config file')\\n parser.add_argument(\\n '--quiet',\\n '-q',\\n action='store_true',\\n help='do not print to console'\\n )\\n parser.add_argument(\\n '--password',\\n '-p',\\n action='store_true',\\n help='Set password in keyring.'\\n )\\n parser.add_argument(\\n '--update',\\n '-u',\\n action='store_true',\\n help='Only add transactions after last date in database.'\\n )\\n parser.add_argument(\\n '--mark_seen',\\n '-m',\\n action='store_true',\\n help='Mark fetched emails as seen.'\\n )\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"CUDAPOA Python API sample program.\\\")\\n parser.add_argument('-m',\\n help=\\\"Run MSA generation. By default consensusis generated.\\\",\\n action='store_true')\\n parser.add_argument('-p',\\n help=\\\"Print output MSA or consensus for each POA group.\\\",\\n action='store_true')\\n parser.add_argument('-l',\\n help=\\\"Use long or short read sample data.\\\",\\n action='store_true')\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = OptionParser()\\n parser.add_option('--data-file', '-f', default='train_data.hdf5',\\n help=\\\"The path to the data file\\\")\\n parser.add_option('--runs-per-epoch', '-r', type='int',\\n help=\\\"The number of runs per epoch (train samples count)\\\")\\n parser.add_option('--avg-window-size', '-w', default='1', type='int',\\n help=\\\"The window size for moving average\\\")\\n\\n (options, args) = parser.parse_args()\\n return options\",\n \"def parse_args(self, argv=None):\\n self.opts, self.args = self.cli_parser.parse_args(argv)\\n self._begin_logging()\\n if argv is None:\\n argv = sys.argv\\n logger.info(' '.join(argv))\\n self._process_input_files()\\n self._construct_links_of_interest()\\n self._open_output_files()\\n data = self._construct_data_struct()\\n return data\",\n \"def parseArgs(arguments=None):\\n\\tparser = generateParser(None)\\n\\treturn parser.parse_known_args(arguments)\",\n \"def parse_command_line():\\n parser = argparse.ArgumentParser()\\n\\n # Optional Argument\\n parser.add_argument('-l', '--length', metavar='length', type=float, default=2, help='length (meter)')\\n parser.add_argument('-k', '--conductivity', metavar='conductivity', type=float, default=0.5, help='constant thermal conductivity (W/m.K)')\\n parser.add_argument('-q', '--heatgeneration', metavar='heatgeneration', type=float, default=1000, help='uniform heat generation (kW/m^3)')\\n parser.add_argument('-TA', '--tempA', metavar='tempA', type=int, default=100, help='temperature at A (Celcius)')\\n parser.add_argument('-TB', '--tempB', metavar='tempB', type=int, default=200, help='temperature at A (Celcius)')\\n parser.add_argument('-n', '--nodes', metavar='nodes', type=int, default=5, help='nodes (positive integer)')\\n parser.add_argument('-A', '--area', metavar='area', type=float, default=1, help='area (m^2)')\\n parser.add_argument('-nf', '--nofigure', action='store_true', help='disable figure')\\n parser.add_argument('-nd', '--nodetail', action='store_true', help='disable detail')\\n return parser.parse_args()\",\n \"def parse_arguments():\\n parser = argparse.ArgumentParser(\\n description=\\\"script for downloading and merging log files from S3 for particular time period\\\")\\n parser.add_argument(\\\"-s\\\", \\n \\\"--startdate\\\", \\n help=\\\"start date in format YYYYMMDD\\\", \\n required=True, \\n type=valid_date)\\n parser.add_argument(\\\"-e\\\", \\\"--enddate\\\", \\n help=\\\"end date in format YYYYMMDD\\\", \\n required=True, \\n type=valid_date)\\n parser.add_argument(\\\"-f\\\", \\n \\\"--file\\\", \\n help=\\\"destination file\\\", \\n required=True)\\n parser.add_argument( \\\"-c\\\", \\\"--config\\\",\\n default=\\\"/Users/samarius/.get_analytics_log.config.json\\\",\\n help=\\\"configuration file path\\\")\\n\\n\\n try:\\n args = parser.parse_args()\\n return args\\n except Exception as e:\\n print \\\"can't parse command line args: {}\\\".format(repr(e))\\n raise\",\n \"def parse_args():\\n\\n parser = argparse.ArgumentParser(description='Disk metric sender')\\n parser.add_argument('-v', '--verbose', action='store_true', default=None, help='Verbose?')\\n parser.add_argument('--debug', action='store_true', default=None, help='Debug?')\\n\\n return parser.parse_args()\",\n \"def parseArguments():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('--output_folder',\\n help='Path of the folder where output files should be written.')\\n parser.add_argument('--partition_id',\\n help='ID of the computer partition to collect data from.')\\n parser.add_argument('--collector_db',\\n help='The path of slapos collect database.')\\n\\n return parser.parse_args()\",\n \"def arg_parse():\\n\\n parser = argparse.ArgumentParser()\\n\\n parser.add_argument(\\n \\\"-f\\\",\\n \\\"--fpath\\\",\\n type=str,\\n required=True,\\n help=\\\"Path to files to generate test data from e.g. /badc/cmip5/data/cmip5/output1/MOHC/HadGEM2-ES/rcp85/mon/atmos/Amon/r1i1p1/latest/tas\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-t\\\",\\n \\\"--time_only\\\",\\n default=False,\\n help=\\\"Only generate one time step of this dataset\\\",\\n action=\\\"store_true\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-s\\\",\\n \\\"--step\\\",\\n type=int,\\n default=100,\\n help=\\\"Step to select latitude/longitude by. Only relevant when time_only is False\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-n\\\",\\n \\\"--number\\\",\\n type=int,\\n default=0,\\n help=\\\"Number of files to generate. Default is all files. Only relevant when time_only is False\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-l\\\",\\n \\\"--level\\\",\\n type=int,\\n default=-1,\\n help=\\\"Number of levels to extract, starting with index 0.\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-c\\\", \\\"--compress\\\", help=\\\"Compress the files.\\\", action=\\\"store_true\\\"\\n )\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = ArgumentParser(\\n description=__doc__, formatter_class=ArgumentDefaultsHelpFormatter\\n )\\n parser.add_argument(\\n '-i', '--infile', type=is_valid_file, action=FullPaths,\\n metavar='FILE', required=True, help='''Settings file'''\\n )\\n parser.add_argument(\\n '-d', '--ddc_file', type=is_valid_file, action=FullPaths,\\n metavar='FILE', default='ddc2_nios2_sw.elf',\\n help='''DDC2 download file'''\\n )\\n parser.add_argument(\\n '-t', '--time', type=int, metavar='INT', default=5,\\n help='''Number of seconds to run DDC2'''\\n )\\n parser.add_argument(\\n '-o', '--outfile', type=str, default='./data/test/test',\\n metavar='FILE', required=False,\\n help='''Output location of data (no need to include file extension)'''\\n )\\n parser.add_argument(\\n '--live', action='store_true', default=False,\\n help='''Live visualisation'''\\n )\\n parser.add_argument(\\n '-v', '--verbose', action='store_true', default=False,\\n help='''Verbose'''\\n )\\n args = parser.parse_args()\\n return args\",\n \"def parse_args():\\n parser = ArgumentParser(\\n description=\\\"This is a script for auto apply ipex optimization.\\\"\\n \\\"\\\\n################################# Basic usage ############################# \\\\n\\\"\\n \\\"\\\\n 1. Apply ipex optimization with fp32 data type\\\\n\\\"\\n \\\"\\\\n >>> python -m intel_extension_for_pytorch.cpu.auto_ipex python_script args \\\\n\\\"\\n \\\"\\\\n 2. Apply ipex optimization with bf16 data type\\\\n\\\"\\n \\\"\\\\n >>> python -m intel_extension_for_pytorch.cpu.auto_ipex --dtype bfloat16 python_script args \\\\n\\\",\\n formatter_class=RawTextHelpFormatter,\\n )\\n\\n add_auto_ipex_params(parser, auto_ipex_default_enabled=True)\\n\\n # positional\\n parser.add_argument(\\n \\\"program\\\",\\n type=str,\\n help=\\\"The full path to the proram/script to be launched. \\\"\\n \\\"followed by all the arguments for the script\\\",\\n )\\n # rest from the training program\\n parser.add_argument(\\\"program_args\\\", nargs=REMAINDER)\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = common_parser()\\n parser.description = (\\n \\\"Given a sequence dict, fasta index or a bed file, scatter over the \\\"\\n \\\"defined contigs/regions. Each contig/region will be split into \\\"\\n \\\"multiple overlapping regions, which will be written to a new bed \\\"\\n \\\"file. Each contig will be placed in a new file, unless the length of \\\"\\n \\\"the contigs/regions doesn't exceed a given number.\\\")\\n\\n parser.add_argument(\\\"-c\\\", \\\"--chunk-size\\\", type=int, default=1e6,\\n metavar=\\\"SIZE\\\",\\n help=\\\"The size of the chunks. The first chunk in a \\\"\\n \\\"region or contig will be exactly length SIZE, \\\"\\n \\\"subsequent chunks will SIZE + OVERLAP and the final \\\"\\n \\\"chunk may be anywhere from 0.5 to 1.5 times SIZE \\\"\\n \\\"plus overlap. If a region (or contig) is smaller \\\"\\n \\\"than SIZE the original regions will be returned. \\\"\\n \\\"Defaults to 1e6\\\")\\n parser.add_argument(\\\"-m\\\", \\\"--minimum-bp-per-file\\\", type=int, default=45e6,\\n help=\\\"The minimum number of bases represented within \\\"\\n \\\"a single output bed file. If an input contig or \\\"\\n \\\"region is smaller than this MINIMUM_BP_PER_FILE, \\\"\\n \\\"then the next contigs/regions will be placed in the \\\"\\n \\\"same file untill this minimum is met. Defaults to \\\"\\n \\\"45e6.\\\")\\n parser.add_argument(\\\"-o\\\", \\\"--overlap\\\", type=int, default=150,\\n help=\\\"The number of bases which each chunk should \\\"\\n \\\"overlap with the preceding one. Defaults to 150.\\\")\\n parser.add_argument(\\\"-S\\\", \\\"--split-contigs\\\", action=\\\"store_true\\\",\\n help=\\\"If set, contigs are allowed to be split up over \\\"\\n \\\"multiple files.\\\")\\n args = parser.parse_args()\\n return args\",\n \"def parse_arguments():\\n # shift away script name\\n scriptname=sys.argv[0]\\n shift()\\n ncl_cmd=list()\\n quali_cmd=list()\\n id_cmd=list() \\n while(len(sys.argv)>0):\\n carg = sys.argv[0]\\n shift()\\n if(carg == \\\"--nucleotide\\\"):\\n ncl_cmd = mungeArgs(sys.argv)\\n elif(carg == \\\"--quality\\\"):\\n quali_cmd = mungeArgs(sys.argv)\\n elif(carg == \\\"--id\\\" ):\\n id_cmd = mungeArgs(sys.argv)\\n elif(carg in [\\\"-h\\\", \\\"--help\\\"]):\\n usage()\\n else:\\n usage(error=True)\\n # Excess arguments which are not processed \\n if(len(sys.argv) > 0):\\n sys.stdout.write(\\\"Excess arguments!\\\\n\\\")\\n sys.stdout.flush()\\n usage(error=True)\\n\\n # external modules rely on non-empty argv array, \\n # re-append the script name as first command line argument\\n sys.argv.append(scriptname)\\n return (id_cmd, ncl_cmd, quali_cmd)\",\n \"def _parse_args():\\n parser = argparse.ArgumentParser(description='main.py')\\n \\n # General system running and configuration options\\n parser.add_argument('--do_nearest_neighbor', dest='do_nearest_neighbor', default=False, action='store_true', help='run the nearest neighbor model')\\n\\n parser.add_argument('--train_path', type=str, default='data/geo_train.tsv', help='path to train data')\\n parser.add_argument('--dev_path', type=str, default='data/geo_dev.tsv', help='path to dev data')\\n parser.add_argument('--test_path', type=str, default='data/geo_test.tsv', help='path to blind test data')\\n parser.add_argument('--test_output_path', type=str, default='geo_test_output.tsv', help='path to write blind test results')\\n parser.add_argument('--domain', type=str, default='geo', help='domain (geo for geoquery)')\\n \\n # Some common arguments for your convenience\\n parser.add_argument('--seed', type=int, default=0, help='RNG seed (default = 0)')\\n parser.add_argument('--epochs', type=int, default=100, help='num epochs to train for')\\n parser.add_argument('--lr', type=float, default=.001)\\n parser.add_argument('--batch_size', type=int, default=2, help='batch size')\\n # 65 is all you need for GeoQuery\\n parser.add_argument('--decoder_len_limit', type=int, default=65, help='output length limit of the decoder')\\n\\n # Feel free to add other hyperparameters for your input dimension, etc. to control your network\\n # 50-200 might be a good range to start with for embedding and LSTM sizes\\n args = parser.parse_args()\\n return args\",\n \"def parse_command_line() -> argparse.Namespace:\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n 'pet_database',\\n type=str,\\n help='path to pet database'\\n )\\n parser.add_argument(\\n '--image_dir',\\n default='data/images'\\n )\\n parser.add_argument(\\n '--log',\\n default=None,\\n help='log file path'\\n )\\n\\n args = parser.parse_args()\\n args.pet_database = os.path.abspath(os.path.expanduser(args.pet_database))\\n args.image_dir = os.path.abspath(os.path.expanduser(args.image_dir))\\n args.log = os.path.abspath(os.path.expanduser(args.log)) if args.log else None\\n return args\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description='Crawl an Android app store for apk files.')\\n parser.add_argument('--store', dest='api', choices=['GooglePlay', 'F-Droid'], required=True,\\n help='Specifies the store to crawl. At the moment only Google Play is supported.')\\n parser.add_argument('--meta', dest='meta', required=False, action='store_const', default=False, const=True,\\n help='If set, no apps will be downloaded, but the meta_data will be saved.')\\n parser.add_argument('--basedir', dest='base_dir', type=str, default=os.getenv('HOME'),\\n required=False, help='Specifies the base path for both logs and apk_downloads.')\\n parser.add_argument('--credentials', dest='credentials', type=str, required=False, default=None,\\n help='Specifies the path to a credential file in .toml format.')\\n parser.add_argument('--limit', dest='limit', type=int, required=False, default=None,\\n help='Specifies the maximum number of apks per category to download.')\\n return parser.parse_args()\",\n \"def parse_args():\\n from argparse import ArgumentParser\\n ap = ArgumentParser(prog=__exe__, description=__purpose__)\\n ap.add_argument('session', help='Session Label')\\n ap.add_argument('-sd', '--subjects_dir', help='Subjects Dir',\\n default='/tmp')\\n return ap.parse_args()\",\n \"def parse_args():\\n\\n\\t# Define the input parser\\n\\tdesc = \\\"computes long term temperature anomaly trend for the GHNC dataset\\\"\\n\\tepilog = \\\"\\\"\\\"\\ndatarange input argument is of the format:\\n\\t\\t YYYY[MM[DD]][:YYYY[MM[DD]]]\\nWhere the date before the optional ':'' represents the lower bound of\\nthe range and the optional date after the : represents the upper\\nbound. The optional elements of the date default to the lowest possible\\nvalue for the lower bound and to the maximum possible for the upper\\none. For example,\\n\\t2006 is equivalent to 2006/01/01:2006/12/31\\n\\t2006/02 is equivalent to 2006/02/01:2006/02/28\\n\\\"\\\"\\\"\\n\\n\\tparser = argparse.ArgumentParser(description=desc, epilog=epilog,\\n\\t\\t\\t\\t\\t\\tformatter_class=argparse.RawDescriptionHelpFormatter)\\n\\tparser.add_argument(\\\"daterange\\\",\\n\\t\\t\\t\\t\\t\\thelp=\\\"range of dates to make available locally\\\")\\n\\tparser.add_argument('-t',\\\"--timeseries\\\",nargs=2,metavar=('lon','lat'),type=float,\\n\\t\\t\\t\\t\\t\\thelp=\\\"plot timeseries for the lon lat pair of coordinates\\\")\\n\\tparser.add_argument('-r',\\\"--recompute\\\",default=False,action='store_true',\\n\\t\\t\\t\\t\\t\\thelp=\\\"force recompute trend\\\")\\n\\n\\treturn parser.parse_args()\",\n \"def parse_args():\\n parser = ArgumentParser()\\n parser.add_argument('-t', '--timer', action='store_true', \\\\\\n help='Time the first random generation')\\n parser.add_argument('-i', '--ibmq', default='', help='IBMQ token')\\n parser.add_argument('-b', '--backend', default='', help='IBMQ backend')\\n return parser.parse_args()\",\n \"def parseArguments():\\n # Create argument parser\\n parser = argparse.ArgumentParser()\\n\\n # Optional arguments\\n parser.add_argument(\\\"-t\\\", \\\"--test\\\", help=\\\"Optionally test algorithm on subsample of the data. Set to 1 for testing\\\", type=int, default=0)\\n\\n parser.add_argument(\\\"--cores\\\", help=\\\"Optimized code for a server with a lot of RAM, set to the number of available cores\\\", type=int, default=40)\\n\\n\\n # Print version\\n parser.add_argument(\\\"--version\\\", action=\\\"version\\\", version='%(prog)s - Version 2.0') #version 1.0 is for the observations in June 2018\\n #version 1.1 contains the optimizations made after the june observations (mainly the switch to stackmags)\\n #version 1.2 changed sim class to NOT include the list of failed candidates (not qsos)\\n #... copied changes made to crossval version\\n #version 1.5 added check for duplicate quasars and remove them\\n #version 1.6 new simulated quasars (december)\\n ##-------------------\\n #version 2.0: combined training of classifier and regressor, streamlined input\\n #version 2.1: Tryied to updates excluded area to a little more than stripe 82 but decided not to keep it, so no change\\n\\n # Parse arguments\\n args = parser.parse_args()\\n\\n return args\",\n \"def parse_args(args):\\n parser = argparse.ArgumentParser(\\n description=\\\"Lookup table generator for Image Comparison\\\")\\n parser.add_argument(\\n \\\"--version\\\",\\n action=\\\"version\\\",\\n version=\\\"lookuptable {ver}\\\".format(ver=__version__))\\n parser.add_argument(\\n \\\"-f\\\",\\n \\\"--folder\\\",\\n dest=\\\"imagefolder\\\",\\n help=\\\"path to image folder\\\",\\n type=str,\\n metavar=\\\"STRING\\\")\\n parser.add_argument(\\n \\\"-v\\\",\\n \\\"--verbose\\\",\\n dest=\\\"loglevel\\\",\\n help=\\\"set loglevel to INFO\\\",\\n action=\\\"store_const\\\",\\n const=logging.INFO)\\n parser.add_argument(\\n \\\"-vv\\\",\\n \\\"--very-verbose\\\",\\n dest=\\\"loglevel\\\",\\n help=\\\"set loglevel to DEBUG\\\",\\n action=\\\"store_const\\\",\\n const=logging.DEBUG)\\n return parser.parse_args(args)\",\n \"def parse_arguments(raw_args=sys.argv[1:]):\\n parser = optparse.OptionParser(\\n usage=\\\"usage: %prog [OPTIONS] DOMAIN_NAME DOMAIN_CONFIG_FILE\\\",\\n description=\\\"A tool for provisioning a Khan Academy CloudSearch \\\"\\n \\\"domain.\\\")\\n\\n parser.add_option(\\\"-v\\\", \\\"--verbose\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"If specified, DEBUG messages will be printed and more \\\"\\n \\\"information will be printed with each log message.\\\")\\n\\n parser.add_option(\\\"--leave-temp-dir\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"If specified, the created temporary directory will not be \\\"\\n \\\"deleted when the script exits.\\\")\\n\\n parser.add_option(\\\"-n\\\", \\\"--dry-run\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"If specified, no commands will actually be executed.\\\")\\n\\n parser.add_option(\\\"--no-reindex\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"If specified, will only update the config, without reindexing.\\\")\\n\\n options, args = parser.parse_args(raw_args)\\n\\n if len(args) != 2:\\n parser.error(\\\"You must specify the name of the domain and a file \\\"\\n \\\"containing the domain configuration.\\\")\\n\\n return (options, args[0], args[1])\",\n \"def parse_arguments():\\n p = argparse.ArgumentParser(description='Prepare the dataset for use by neural models.')\\n p.add_argument(\\\"json_file\\\", type=argparse.FileType('r'), help=\\\"json file with all the data\\\")\\n p.add_argument(\\\"prefix\\\", type=str, help=\\\"prefix for all the generated files\\\")\\n p.add_argument(\\\"data_type\\\", type=str, choices=[\\\"names\\\", \\\"comments\\\", \\\"nc\\\"],\\n default=\\\"nc\\\", help=\\\"type of the information recorded in the dataset\\\")\\n p.add_argument(\\\"labels\\\", type=str, choices=[\\\"PROG\\\", \\\"ALL\\\", \\\"TOP\\\"],\\n default=\\\"PROG\\\", help=\\\"method by which to choose the labels for the dataset\\\")\\n p.add_argument(\\\"-other_label\\\", type=str, required=False, default=\\\"\\\",\\n help=\\\"label to use instead of all infrequent labels. \\\"\\n \\\"This can be left blank to ignore infrequent labels altogether\\\")\\n p.add_argument(\\\"-label_num\\\", type=int, default=100, required=False,\\n help=\\\"Number of most frequent labels to keep. Works with label_choice=TOP\\\")\\n p.add_argument(\\\"-min_prog_labels\\\", type=int, default=5, required=False,\\n help=\\\"Minimal number of programs a label has to appear in for it to be included \\\"\\n \\\"in the dataset. Works with label_choice=PROG\\\")\\n p.add_argument(\\\"-test_prog_list\\\", type=argparse.FileType('r'), default=None, required=False,\\n help=\\\"file with the list of programs in the test set (optional)\\\")\\n\\n return p.parse_args(sys.argv[1:])\",\n \"def parseArgs(args):\\n parser = argparse.ArgumentParser(description = \\\"Scrapes baseball-reference.com for player statistics\\\")\\n\\n parser.add_argument(\\\"-d\\\", \\\"--domain\\\", help=\\\"domain to scrape for statistics. Default is baseball-reference.com\\\", nargs=1, default=[\\\"http://www.baseball-reference.com\\\"])\\n parser.add_argument(\\\"-f\\\", \\\"--filename\\\", help=\\\"database file to store data in\\\", required=True, nargs=1, type=argparse.FileType(\\\"r+\\\"))\\n parser.add_argument(\\\"-r\\\", \\\"--reset\\\", help=\\\"removes database before scraping all data from baseball-reference. Conflicts with -u. One of -r and -u must be specified\\\", action=\\\"store_true\\\")\\n parser.add_argument(\\\"-u\\\", \\\"--update\\\", help=\\\"scrapes baseball-reference and adds all new information to the database. Conflicts with -r. One of -r and -u must be specified\\\", action=\\\"store_true\\\")\\n parser.add_argument(\\\"--verbose\\\", help=\\\"enables verbose output\\\", action=\\\"store_true\\\")\\n parser.add_argument(\\\"--version\\\", help=\\\"prints out version and exits\\\", action=\\\"version\\\", version=\\\"%(prog)s ({version})\\\".format(version=__version__))\\n\\n parsedArgs = parser.parse_args()\\n\\n if parsedArgs.reset == parsedArgs.update:\\n parser.error(\\\"-r and -u are conflicting flags. Exactly one must be specified\\\")\\n parser.print_help()\\n\\n return parsedArgs\",\n \"def parse_cmdline():\\n\\tparser = ArgumentParser(prog=\\\"FastP_QC.py\\\", description=\\\"\\\"\\\"Script collects stats from fastp jsons.\\\"\\\"\\\")\\n\\tparser.add_argument(\\\"-r1\\\", \\\"--r1_stats\\\", dest=\\\"r1_stats\\\", action=\\\"store\\\", required=True, help=\\\"Text file with r1 stats, from q30.py script.\\\")\\n\\tparser.add_argument(\\\"-r2\\\", \\\"--r2_stats\\\", dest=\\\"r2_stats\\\", action=\\\"store\\\", required=True, help=\\\"Text file with r2 stats, from q30.py script.\\\")\\n\\tparser.add_argument(\\\"-n\\\", \\\"--name\\\", dest=\\\"name\\\", action=\\\"store\\\", required=True, help=\\\"Sample name\\\")\\n\\targs = parser.parse_args()\\n\\treturn args\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description='Run the destination IoT program (CTRL-C to exit)')\\n\\n parser.add_argument('-v',\\n '--verbose',\\n default=False,\\n action='store_true',\\n help='Print all debug logs')\\n\\n parser.add_argument('-p',\\n '--port',\\n metavar='<port number>',\\n default=7777,\\n type=int,\\n help='Default: 7777')\\n\\n parser.add_argument('-a',\\n '--address',\\n metavar='<email_address>',\\n nargs='*',\\n help='Email address(es) to receive notifications')\\n\\n args = parser.parse_args()\\n return args\",\n \"def _ParseArgs():\\n usage = \\\"usage: %prog [options]\\\"\\n parser = optparse.OptionParser(usage=usage)\\n\\n parser.add_option('--width', type='int',\\n default=352,\\n help=('Width of the YUV file\\\\'s frames. '\\n 'Default: %default'))\\n parser.add_option('--height', type='int', default=288,\\n help=('Height of the YUV file\\\\'s frames. '\\n 'Default: %default'))\\n parser.add_option('--crop_height', type='int', default=32,\\n help=('How much of the top of the YUV file to crop. '\\n 'Has to be module of 2. Default: %default'))\\n parser.add_option('--yuv_file', type='string',\\n help=('The YUV file to be cropped.'))\\n parser.add_option('--output_file', type='string', default='output.yuv',\\n help=('The output YUV file containing the cropped YUV. '\\n 'Default: %default'))\\n options = parser.parse_args()[0]\\n if not options.yuv_file:\\n parser.error('yuv_file argument missing. Please specify input YUV file!')\\n return options\",\n \"def parse_args(self, args):\\n raise Exception(\\\"Not implemented\\\")\",\n \"def parse_args():\\n from argparse import ArgumentParser\\n ap = ArgumentParser(prog=__exe__, description=__purpose__)\\n ap.add_argument(\\n '--host', dest='host', default=None,\\n help='Host for XNAT. Default: env XNAT_HOST.')\\n ap.add_argument(\\n '-u', '--username', dest='username', default=None,\\n help='Username for XNAT.')\\n ap.add_argument('project', help='Project Label')\\n ap.add_argument('session', help='Session Label')\\n ap.add_argument(\\n 'proc_suffix', help='Proc name suffix', nargs='?', default='')\\n ap.add_argument(\\n '-sd', '--subjects_dir', dest='subjects_dir',\\n help='Subjects Directory',\\n default=os.environ.get('SUBJECTS_DIR', '/tmp'))\\n return ap.parse_args()\",\n \"def parse_args():\\n help_text = \\\"\\\"\\\"\\n Analyzer of the frequency of use of nouns in the headings of posts on hubr.com\\n \\\"\\\"\\\"\\n parser = argparse.ArgumentParser(\\n description=help_text\\n )\\n parser.add_argument(\\n '-p',\\n '--pages',\\n type=int,\\n dest='page_count',\\n default=PAGE_COUNT,\\n help=f'Number of pages to parse, default is {PAGE_COUNT}.'\\n )\\n parser.add_argument(\\n '-s',\\n '--start',\\n type=int,\\n default=PAGE_START,\\n dest='start_page',\\n help=f'Start page number, default is {PAGE_START}.',\\n )\\n parser.add_argument(\\n '-t',\\n '--top',\\n type=int,\\n default=TOP_SIZE,\\n dest='top_size',\\n help=f'The size of the top noun, default is {TOP_SIZE}.',\\n )\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"-i\\\", \\\"--input_path\\\", required=True)\\n parser.add_argument(\\\"-c\\\", \\\"--config\\\", required=True)\\n return parser.parse_args()\",\n \"def parse_cmdline(argv):\\n if argv is None:\\n argv = sys.argv[1:]\\n\\n # initialize the parser object:\\n parser = argparse.ArgumentParser(description='Calculates A and Ea from Gaussian output files using GoodVibes. '\\n 'List files to be analyzed, reactant(s) first and ending with the '\\n 'transition structure. These can be listed on the command line or in '\\n 'a file (each line listing a set of reactant(s) and transition '\\n 'structure).')\\n parser.add_argument(\\\"-d\\\", \\\"--out_dir\\\", help=\\\"A directory where output files should be saved. The default location \\\"\\n \\\"is the current working directory.\\\", default=None)\\n parser.add_argument(\\\"-f\\\", dest=\\\"freq_cutoff\\\", help=\\\"Cut-off frequency for both entropy and enthalpy (wavenumbers) \\\"\\n \\\"(default = 0)\\\", default=\\\"0\\\")\\n parser.add_argument(\\\"-l\\\", \\\"--list\\\", help=\\\"The location of the list of Gaussian output files. \\\"\\n \\\"The default file name.\\\", default=None)\\n parser.add_argument(\\\"-q\\\", \\\"--quasiharmonic\\\", help=\\\"Use the '-q' option in GoodVibes, which turns on turns on \\\"\\n \\\"quasi-harmonic corrections to both entropy and enthalpy in the \\\"\\n \\\"Gibbs free energy (qh-G(T)) output from GoodVibes. \\\",\\n action='store_true')\\n parser.add_argument(\\\"--temp\\\", help=\\\"Temperature in K for calculating \\\\u0394G. The default is the first \\\"\\n \\\"temperature in 'temp_range' (if specified). If a value is given, the program \\\"\\n \\\"will use the temperature closest to it in the temp_range.\\\", default=None)\\n parser.add_argument(\\\"-ti\\\", \\\"--temp_range\\\", help=\\\"Initial temp, final temp, (and optionally) step size (K) for \\\"\\n \\\"thermochemistry calculations. The default range is 300,600,30\\\",\\n default=\\\"300,600,30\\\")\\n parser.add_argument(\\\"-v\\\", \\\"--vib_scale\\\", help=\\\"Scaling factor to be used for vibrational frequencies. If not \\\"\\n \\\"provided, the GoodVibes default value will be used.\\\",\\n default=None)\\n parser.add_argument(\\\"-p\\\", \\\"--plot\\\", help=\\\"Make a \\\\u0394G plot at the specified temp. The default is False.\\\",\\n action='store_true')\\n parser.add_argument(\\\"-pl\\\", \\\"--plot_labels\\\", help=\\\"Optional labels for \\\\u0394G plot. Enter as a list.\\\",\\n default=None)\\n parser.add_argument(\\\"-c\\\", \\\"--vibes_check\\\", help=\\\"In addition to standard checks always run (matching solvent, \\\"\\n \\\"level of theory, stoichiometry, charge, multiplicity, and \\\"\\n \\\"Gaussian versions), run files through GoodVibes '--check' before \\\"\\n \\\"performing calculations. The default is False.\\\",\\n action='store_true')\\n parser.add_argument(\\\"-o\\\", \\\"--output_fname\\\", help=\\\"The name of the output file to be created. The default is the \\\"\\n \\\"list name with the extension '.csv', or '{}' if no list name \\\"\\n \\\"provided.\\\".format(DEF_OUT_FILE_NAME), default=None)\\n\\n parser.add_argument(\\\"-s\\\", \\\"--save_vibes\\\", help=\\\"Save the output from running GoodVibes in separate files, \\\"\\n \\\"named with the Gaussian log file prefix and '.dat'. \\\"\\n \\\"The default is False.\\\",\\n action='store_true')\\n parser.add_argument(\\\"-t\\\", \\\"--tog_vibes\\\", help=\\\"Save the output from running GoodVibes in one file, \\\"\\n \\\"renamed with the output file prefix and '.dat'. \\\"\\n \\\"The default is False.\\\",\\n action='store_true')\\n\\n args = None\\n try:\\n args = parser.parse_known_args(argv)\\n options = args[0]\\n if not options.out_dir:\\n options.out_dir = os.getcwd()\\n # user can define a new directory as the output directory\\n if not os.path.exists(options.out_dir):\\n os.makedirs(options.out_dir)\\n\\n if options.output_fname:\\n options.output_fname = os.path.abspath(os.path.join(options.out_dir, options.output_fname))\\n elif options.list:\\n options.output_fname = create_out_fname(options.list, ext='.csv', base_dir=options.out_dir)\\n else:\\n options.output_fname = create_out_fname(DEF_OUT_FILE_NAME, ext='.csv', base_dir=options.out_dir)\\n\\n if options.plot_labels:\\n options.plot_labels = options.plot_labels.split(',')\\n else:\\n options.plot_labels = ['']\\n\\n if options.vib_scale:\\n options.vib_scale = float(options.vib_scale)\\n\\n except (SystemExit, ValueError) as e:\\n if hasattr(e, 'code') and e.code == 0:\\n return args, GOOD_RET\\n warning(e)\\n parser.print_help()\\n return args, INPUT_ERROR\\n\\n return args, GOOD_RET\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=__doc__)\\n # If user doesn't specify an input file, read from standard input. Since\\n # encodings are the worst thing, we're explicitly expecting std\\n parser.add_argument('-i', '--infile',\\n type=lambda x: open(x, encoding=ENCODE_IN),\\n default=io.TextIOWrapper(\\n sys.stdin.buffer, encoding=ENCODE_IN)\\n )\\n # Same thing goes with the output file.\\n parser.add_argument('-o', '--outfile',\\n type=lambda x: open(x, 'w', encoding=ENCODE_OUT),\\n default=io.TextIOWrapper(\\n sys.stdout.buffer, encoding=ENCODE_OUT)\\n )\\n # Set the verbosity level for the logger. The `-v` option will set it to\\n # the debug level, while the `-q` will set it to the warning level.\\n # Otherwise use the info level.\\n verbosity = parser.add_mutually_exclusive_group()\\n verbosity.add_argument('-v', '--verbose', action='store_const',\\n const=logging.DEBUG, default=logging.INFO)\\n verbosity.add_argument('-q', '--quiet', dest='verbose',\\n action='store_const', const=logging.WARNING)\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser('Reading Comprehension on BaiduRC dataset')\\n parser.add_argument('--prepare', action='store_true',\\n help='create the directories, prepare the vocabulary and embeddings')\\n parser.add_argument('--train', action='store_true',\\n help='train the model')\\n parser.add_argument('--generate', action='store_true',\\n help='predict the answers for test set with trained model')\\n parser.add_argument('--gentest', action='store_true',\\n help='predict the answers for test set with trained model')\\n parser.add_argument('--gpu', type=str, default='0',\\n help='specify gpu device')\\n\\n train_settings = parser.add_argument_group('train settings')\\n train_settings.add_argument('--optim', default='Adam',\\n help='optimizer type')\\n train_settings.add_argument('--learning_rate', type=float, default=0.001,\\n help='learning rate')\\n train_settings.add_argument('--weight_decay', type=float, default=0,\\n help='weight decay')\\n train_settings.add_argument('--dropout', type=float, default=0,\\n help='dropout keep rate')\\n train_settings.add_argument('--batch_size', type=int, default=128,\\n help='train batch size')\\n train_settings.add_argument('--epochs', type=int, default=10,\\n help='train epochs')\\n\\n model_settings = parser.add_argument_group('model settings')\\n model_settings.add_argument('--embed_size', type=int, default=128,\\n help='size of the embeddings')\\n model_settings.add_argument('--hidden_size', type=int, default=256,\\n help='size of LSTM hidden units')\\n model_settings.add_argument('--max_seq_len', type=int, default=50,\\n help='max passage num in one sample')\\n model_settings.add_argument('--max_gen_len', type=int, default=50,\\n help='max length of passage')\\n\\n path_settings = parser.add_argument_group('path settings')\\n path_settings.add_argument('--vocab_dir', default='../data/vocab/',\\n help='the dir to save vocabulary')\\n path_settings.add_argument('--model_dir', default='../data/models/',\\n help='the dir to store models')\\n path_settings.add_argument('--result_dir', default='../data/results/',\\n help='the dir to output the results')\\n path_settings.add_argument('--summary_dir', default='../data/summary/',\\n help='the dir to write tensorboard summary')\\n path_settings.add_argument('--log_path',\\n help='path of the log file. If not set, logs are printed to console')\\n return parser.parse_args()\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\n '--zarr_dir',\\n type=str,\\n help='path to directory of zarr files',\\n )\\n parser.add_argument(\\n '--tiff_dir',\\n type=str,\\n help='path to directory of tiff files',\\n )\\n parser.add_argument(\\n '--output_dir',\\n type=str,\\n help='path to directory for writing',\\n )\\n parser.add_argument(\\n '--config_path',\\n type=str,\\n default=None,\\n help='path to yaml preprocess config file',\\n )\\n \\n args = parser.parse_args()\\n return args\",\n \"def ParseArguments():\\n\\n parser = argparse.ArgumentParser(description=__doc__)\\n\\n parser.add_argument('-f', '--file', help='Text file to be used (e.g. mem/sample_mem.txt)')\\n parser.add_argument('--memsize', help='Memory size of generated memory')\\n parser.add_argument('--memrange', help='Max range of memory in generated memory')\\n parser.add_argument('--mempattern', help='Generated memory pattern focus (normal, loops, rep, random)')\\n parser.add_argument('--cachesize', help='Cache size to be used')\\n parser.add_argument('--linesize', help='Cache line size to be used')\\n parser.add_argument('--mult', help='Run an entered number of simulations back-to-back')\\n parser.add_argument('-t', '--test', help='Run tests to verify the simulator is functioning properly', action=\\\"store_true\\\")\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n p = argparse.ArgumentParser(\\n description='Parse system logs, for fun or something')\\n p.add_argument('-l', '--log', dest='log_file', help='The log file')\\n p.add_argument('-f', '--filter', dest='filter', help='filter by daemon')\\n return p.parse_args()\",\n \"def parse_args():\\r\\n desc = \\\"Check for the longest running requests in bookie\\\"\\r\\n parser = argparse.ArgumentParser(description=desc)\\r\\n\\r\\n parser.add_argument('-l', '--log', dest='log',\\r\\n action='store',\\r\\n default=None,\\r\\n required=True,\\r\\n help=\\\"log file we're reading requests from\\\")\\r\\n\\r\\n parser.add_argument('-n', '--number', dest='count',\\r\\n action='store',\\r\\n default=10,\\r\\n type=int,\\r\\n required=False,\\r\\n help=\\\"how many urls do we wish to see, default 10\\\")\\r\\n\\r\\n\\r\\n args = parser.parse_args()\\r\\n return args\",\n \"def parse_arguments():\\n parser = argparse.ArgumentParser(description=\\\"Parse Diff Exp output files\\\")\\n parser.add_argument(\\\"raw_file\\\", help=\\\"DE analysis output file (.tab).\\\")\\n parser.add_argument(\\\"output_json\\\", help=\\\"Output JSON\\\")\\n parser.add_argument(\\\"output_file\\\", help=\\\"Output file\\\")\\n parser.add_argument(\\\"--gene_id\\\", help=\\\"Gene_IDs column name\\\", type=str)\\n parser.add_argument(\\\"--fdr\\\", help=\\\"FDR column name\\\", type=str)\\n parser.add_argument(\\\"--pvalue\\\", help=\\\"Pvalue column name\\\", type=str)\\n parser.add_argument(\\\"--fwer\\\", help=\\\"FWER column name\\\", type=str)\\n parser.add_argument(\\\"--logodds\\\", help=\\\"Log Odds column name\\\", type=str)\\n parser.add_argument(\\\"--logfc\\\", help=\\\"logfc column name\\\", type=str)\\n parser.add_argument(\\\"--stat\\\", help=\\\"Statistics column name\\\", type=str)\\n return parser.parse_args()\",\n \"def arg_parse():\\n p = ap.ArgumentParser()\\n p.add_argument('infile',\\n help='path to file containing objects')\\n p.add_argument('n1',\\n help='night 1')\\n p.add_argument('n2',\\n help='night 2')\\n p.add_argument('observatory',\\n help='Astropy name of observatory')\\n return p.parse_args()\",\n \"def parse_arguments():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"-i\\\", \\\"--input\\\", dest=\\\"input_file\\\", help=\\\"input file or pattern\\\", default=\\\"\\\")\\n parser.add_argument(\\\"-o\\\", \\\"--output\\\", dest=\\\"output_file\\\", help=\\\"output file or pattern\\\", default=\\\"\\\")\\n parser.add_argument(\\\"-d\\\", \\\"--debug\\\", dest=\\\"debug\\\", action='store_true')\\n parser.add_argument(\\\"-v\\\", \\\"--verbose\\\", dest=\\\"verbose\\\", action='store_true')\\n parser.set_defaults(verbose=False)\\n parser.set_defaults(debug=False)\\n return parser.parse_args()\",\n \"def parse(self, command_line=sys.argv[1:]):\\n return self._parser.parse_args(command_line)\",\n \"def parse_arguments():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"-f\\\", \\\"--file\\\", help=\\\"file with the cohort you want to check / fix\\\", type=str, required=True)\\n parser.add_argument(\\\"-o\\\", \\\"--outdir\\\", help=\\\"where should the files and the result readme be stored?\\\", type=str, required=True)\\n return parser.parse_args()\",\n \"def parse_args():\\n\\n parser = argparse.ArgumentParser()\\n\\n parser.add_argument(\\n \\\"-i\\\", \\\"--input\\\", required=True, action=\\\"store\\\", dest=\\\"f_in\\\", help=\\\"input file\\\"\\n )\\n parser.add_argument(\\n \\\"-o\\\",\\n \\\"--output\\\",\\n required=True,\\n action=\\\"store\\\",\\n dest=\\\"f_out\\\",\\n help=\\\"stem of output file\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-d\\\",\\n \\\"--dir\\\",\\n required=True,\\n action=\\\"store\\\",\\n dest=\\\"dir\\\",\\n help=\\\"directory to save output files\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-t\\\",\\n \\\"--threshold\\\",\\n required=False,\\n action=\\\"store\\\",\\n dest=\\\"thres\\\",\\n default=0.85,\\n help=\\\"threshold for the scoring function\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-l\\\",\\n \\\"--language\\\",\\n required=True,\\n action=\\\"store\\\",\\n dest=\\\"lang\\\",\\n help=\\\"provide language in order to set stop words\\\",\\n )\\n\\n parser.add_argument(\\n \\\"-min\\\",\\n \\\"--minimum\\\",\\n required=False,\\n action=\\\"store\\\",\\n dest=\\\"min\\\",\\n default=100,\\n help=\\\"minimum number of occurrences to be considered as ngram\\\",\\n )\\n\\n parser.add_argument(\\n \\\"--trigram\\\",\\n required=False,\\n action=\\\"store_true\\\",\\n dest=\\\"trigram\\\",\\n help=\\\"extracting trigrams in addition to bigrams\\\",\\n )\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n global Args\\n parser = argparse.ArgumentParser()\\n subparsers = parser.add_subparsers()\\n pars_simulation(subparsers)\\n pars_analyze(subparsers)\\n Args = parser.parse_args()\",\n \"def parse_arguments():\\n\\n parser = argparse.ArgumentParser(\\n description=\\\"生成用户字符串识别的切分字符串\\\"\\n )\\n parser.add_argument(\\n \\\"-o\\\",\\n \\\"--output_dir\\\",\\n type=str,\\n nargs=\\\"?\\\",\\n help=\\\"The output directory\\\",\\n default=\\\"output/\\\"\\n )\\n parser.add_argument(\\n \\\"-i\\\",\\n \\\"--input_file\\\",\\n type=str,\\n nargs=\\\"?\\\",\\n help=\\\"When set, this argument uses a specified text file as source for the text\\\",\\n default=\\\"\\\",\\n required=True\\n )\\n parser.add_argument(\\n \\\"-mi\\\",\\n \\\"--min_char_count\\\",\\n type=int,\\n nargs=\\\"?\\\",\\n help=\\\"The minimum number of characters per line, Default is 3.\\\",\\n default=3,\\n\\n )\\n parser.add_argument(\\n \\\"-ma\\\",\\n \\\"--max_char_count\\\",\\n type=int,\\n nargs=\\\"?\\\",\\n help=\\\"The maximum number of characters per line, Default is 20.\\\",\\n default=20,\\n )\\n return parser.parse_args()\",\n \"def parse_args(args):\\n\\n parser = argparse.ArgumentParser(\\n description=\\\"\\\"\\\"Generates and runs an afni_proc.py script to preprocess resting state fMRI data\\\"\\\"\\\",\\n formatter_class=argparse.RawDescriptionHelpFormatter)\\n\\n # Optional Flags\\n parser.add_argument(\\\"-t\\\", \\\"--trs_remove\\\", action=\\\"store\\\", default=5, type=int, metavar='TRs',\\n help=\\\"\\\"\\\"number of trs to remove at the beginning of the epi data\\n (default = 5 trs)\\\"\\\"\\\")\\n parser.add_argument(\\\"-d\\\", \\\"--dim_voxel\\\", action=\\\"store\\\", default=2.0, type=float, metavar='MM',\\n help=\\\"voxel dimensions in mm that processed epi will be resampled to (default = 2.0 mm)\\\")\\n parser.add_argument(\\\"-b\\\", \\\"--bandpass\\\", action=\\\"store\\\", default=[0.01, 0.25], nargs=2, type=float, metavar=\\\"F\\\",\\n help=\\\"bandpass frequencies lower and upper limits (default = 0.01 0.25)\\\")\\n parser.add_argument(\\\"-v\\\", \\\"--volumes\\\", action=\\\"store\\\", default=0, type=int, metavar=\\\"V\\\",\\n help=\\\"\\\"\\\"truncate the epi data to the inputted number of volumes, useful if subjects have data \\n with different numbers of volumes (default = no truncation)\\\"\\\"\\\")\\n parser.add_argument(\\\"-f\\\", \\\"--fwhm\\\", action=\\\"store\\\", default=5.0, type=float, metavar=\\\"MM\\\",\\n help=\\\"the full width half maximum that is used when blurring (default = 5.0 mm)\\\")\\n parser.add_argument(\\\"-c\\\", \\\"--cores\\\", action=\\\"store\\\", default=cpu_count(), type=int, metavar=\\\"C\\\",\\n help=\\\"number of cores supplied to 3dDeconvolve (default = all cores)\\\")\\n parser.add_argument(\\\"-s\\\", \\\"--subj_id\\\", action=\\\"store\\\", default=\\\"sub\\\", metavar=\\\"SUB\\\",\\n help=\\\"text file of subject ids (default = sub)\\\")\\n parser.add_argument(\\\"-T\\\", \\\"--time_step\\\", action=\\\"store\\\", default=0, type=float, metavar=\\\"TS\\\",\\n help=\\\"set the time step for bandpassing (default = ts in header info\\\")\\n\\n parser.add_argument(\\\"-g\\\", \\\"--global_signal_regression\\\", action=\\\"store_false\\\", default=True,\\n help=\\\"do not perform global signal regression (default = perform gsr)\\\")\\n\\n parser.add_argument(\\\"-r\\\", \\\"--rerun\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"\\\"\\\"rerun preprocessing, override and delete previous results in \\n 'Processed' folder (default = don't override)\\\"\\\"\\\")\\n parser.add_argument(\\\"-m\\\", \\\"--motion_param\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"use 12 motion parameters for regression (default = 6 motion parameters)\\\")\\n parser.add_argument(\\\"-G\\\", \\\"--gm_blur\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"blur only in grey matter mask (default = blur in whole brain)\\\")\\n parser.add_argument(\\\"-n\\\", \\\"--nl_reg\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"use non-linear warp between anatomical and MNI template (default = linear warp)\\\")\\n\\n # Required Inputs\\n required = parser.add_argument_group(\\\"required arguments\\\")\\n required.add_argument(\\\"-e\\\", \\\"--epi\\\", action=\\\"store\\\", required=True,\\n help=\\\"text file of paths to raw epi data\\\")\\n required.add_argument(\\\"-a\\\", \\\"--anat\\\", action=\\\"store\\\", required=True,\\n help=\\\"text file of paths to raw anatomical data\\\")\\n required.add_argument(\\\"-o\\\", \\\"--out_dir\\\", action=\\\"store\\\", required=True, metavar=\\\"OUT\\\",\\n help=\\\"text file of paths to output directory\\\")\\n result = parser.parse_args(args)\\n\\n # Make sure inputted parameters are legal\\n assert (os.path.isfile(result.epi)), \\\"{} does not exist or is not a file\\\".format(result.epi)\\n assert (os.path.isfile(result.anat)), \\\"{} does not exist or is not a file\\\".format(result.ant)\\n assert (result.trs_remove >= 0), \\\"Cannot remove negative trs\\\"\\n assert (result.dim_voxel >= 0), \\\"Cannot have a negative voxel dimension\\\"\\n assert (np.all(np.array(result.bandpass) > 0)), \\\"Cannot have a negative frequency limit for bandpassing\\\"\\n assert (result.volumes > -1), \\\"Number of volumes must be greater than 0\\\"\\n assert (result.cores > 0), \\\"Number of cores used must be greater than 0\\\"\\n assert (result.time_step > -1), \\\"Time step must be greater than 0\\\"\\n\\n return result\",\n \"def _parseArgs():\\n # HINT: If you consider adding an option,\\n # please consider adding a config file option first.\\n parser = ArgumentParser(description=STRING_USAGE_DESCRIPTION,\\n epilog=STRING_USAGE_EPILOG)\\n parser.add_argument('--version', action='version',\\n version='%(prog)s (' + VERSIONSTRING + ')')\\n parser.add_argument('-c', '--configfile', action='store',\\n dest='configfile',\\n default=DEFAULT_CONFIGFILE,\\n help=STRING_USAGE_CONFIGFILE)\\n parser.add_argument('-e', '--editconfig', action='store_true',\\n dest='invoke_editconfig',\\n default=False,\\n help=STRING_USAGE_EDITCONFIG)\\n parser.add_argument('--defaultconfig', action='store_true',\\n dest='invoke_defaultconfig',\\n default=False,\\n help=STRING_USAGE_DEFAULTCONFIG)\\n parser.add_argument('--printconfig', action='store_true',\\n dest='invoke_printconfig',\\n default=False,\\n help=STRING_USAGE_PRINTCONFIG)\\n _addOverwriteBool(parser, 'gui', 'gui', 'enable')\\n parser.add_argument('-s', '--sources', section='wesen',\\n dest='sources',\\n action=_OverwriteConfigAction)\\n parser.add_argument('-r', '--resume',\\n dest='resume', action='store_true',\\n default=False, help=STRING_USAGE_RESUME)\\n return parser.parse_known_args()\",\n \"def parse_arguments():\\n #usage = \\\"usage: %(prog)s [options] <message file>\\\" + DESCRIPTION\\n parser = ArgumentParser()\\n parser.add_argument('-v', '--version', action='version', version=VERSION)\\n parser.add_argument('source', metavar='source', help='input logfile or directory with logfiles')\\n\\n \\\"\\\"\\\"\\n parser.add_argument('-m', '--mat-id', metavar='string', # or stare_false\\n dest=\\\"id_mat\\\", default='', # negative store value\\n help=\\\"material id to grep\\\")\\n parser.add_argument('-c', '--count', metavar='N', type=int, # or stare_false\\n dest=\\\"count\\\", default=0, # negative store value\\n help=\\\"count\\\")\\n parser.add_argument('-p', '--pattern', metavar='string', # or stare_false\\n dest=\\\"pattern\\\", default='xxx', # negative store value\\n help=\\\"search pattern within logfile\\\")\\n \\\"\\\"\\\"\\n return parser.parse_args()\",\n \"def parse_arguments():\\n parser = argparse.ArgumentParser(description='Helps analyze articles.')\\n parser.add_argument('--config', default='config.yaml',\\n help='Configuration file for the options of this script')\\n parser.add_argument('--search', default=None, type=str,\\n help='Search for text in the articles')\\n parser.add_argument('--case-sensitive', action='store_true',\\n help='Makes search case-senstive (only applicatble to --search)')\\n parser.add_argument('--list', default=None, type=str,\\n help='List [title|authors|date|word-count|author|excerpt|content] of the articles')\\n parser.add_argument('--sort', action='store_true',\\n help='Sorts output (only applicable to --list).')\\n parser.add_argument('--sort-by', default=None, type=str,\\n help='Sorts output by another attribute [title|author|date] (only applicable to --list)')\\n parser.add_argument('--statistics', action='store_true',\\n help='Gives basic statistics about the articles.')\\n parser.add_argument('--count-articles', action='store_true',\\n help='Counts the total number of articles')\\n parser.add_argument('--count-words', action='store_true',\\n help='Counts the total number of words')\\n parser.add_argument('--count-paragraphs', action='store_true',\\n help='Counts the total number of paragraphs')\\n parser.add_argument('--count-by-author', action='store_true',\\n help='Counts the number of articles by each author')\\n parser.add_argument('--count-by-year', action='store_true',\\n help='Counts the number of articles bucketed by year')\\n parser.add_argument('--count-by-months', default=None, type=int,\\n help='Counts the number of articles bucketed by number of months')\\n \\n return parser, parser.parse_args()\",\n \"def parse_command_line_arguments():\\n parser = argparse.ArgumentParser(\\n description=\\\"Convert dependency files into list of GitHub links.\\\",\\n epilog=\\\"For help with this program, contact John Speed at jmeyers@iqt.org.\\\",\\n )\\n parser.add_argument(\\n \\\"--python\\\",\\n default=False, # default value is False\\n help=\\\"Convert requirements.txt file into GitHub links.\\\",\\n )\\n return parser.parse_args()\",\n \"def parse_arguments():\\n parser = argparse.ArgumentParser(description=\\\"Parse library type information.\\\")\\n parser.add_argument(\\\"input_file\\\", help=\\\"Salmon library type information file.\\\")\\n return parser.parse_args()\",\n \"def _parse_args():\\n parser = argparse.ArgumentParser(description='Pure-python command-line calculator.')\\n\\n parser.add_argument('EXPRESSION', action=\\\"store\\\", type=str, help=\\\"expression string to evaluate\\\")\\n parser.add_argument('-m', '--use-modules', nargs='+', action=\\\"store\\\", dest=\\\"MODULE\\\", type=str,\\n help=\\\"additional modules to use\\\")\\n\\n return parser.parse_args()\",\n \"def parse_args():\\n if len(sys.argv) < REQUIRED_NUM_ARGS or len(sys.argv) > MAXIMUM_NUM_ARGS:\\n error_quit(\\\"Incorrect number of arguments!\\\", 400)\\n # Set port to DEFAULT if not specified as an arg. Otherwise, port = portarg.\\n port = sys.argv[PORT_ARG_NUM] if len(sys.argv) == MAXIMUM_NUM_ARGS else DEFAULT_FTP_PORT\\n port = validate_port(port)\\n # Get host address and logfile name from args.\\n host, log_file = sys.argv[HOST_ARG_NUM], sys.argv[LOG_ARG_NUM]\\n return host, log_file, port\",\n \"def parse_cmdline(argv):\\n if argv is None:\\n argv = sys.argv[1:]\\n\\n # initialize the parser object:\\n parser = argparse.ArgumentParser(description='For each timestep, gather the energy information output by LAMMPS '\\n 'in the log file.')\\n parser.add_argument(\\\"-f\\\", \\\"--file\\\", help=\\\"The log file to be processed.\\\",\\n default=None)\\n parser.add_argument(\\\"-l\\\", \\\"--list_file\\\", help=\\\"The a file with a list of log files to be processes.\\\",\\n default=None)\\n args = None\\n try:\\n args = parser.parse_args(argv)\\n if args.file is None:\\n args.file_list = []\\n else:\\n if os.path.isfile(args.file):\\n args.file_list = [args.file]\\n args.source_name = args.file\\n else:\\n raise IOError(\\\"Could not find specified log file: {}\\\".format(args.file))\\n if args.list_file is not None:\\n args.file_list += file_rows_to_list(args.list_file)\\n args.source_name = args.list_file\\n if len(args.file_list) < 1:\\n raise InvalidDataError(\\\"Found no log file names to process. Specify one or more files as specified in \\\"\\n \\\"the help documentation ('-h').\\\")\\n except IOError as e:\\n warning(\\\"Problems reading file:\\\", e)\\n parser.print_help()\\n return args, IO_ERROR\\n except (KeyError, InvalidDataError, SystemExit) as e:\\n if hasattr(e, 'code') and e.code == 0:\\n return args, GOOD_RET\\n warning(e)\\n parser.print_help()\\n return args, INPUT_ERROR\\n return args, GOOD_RET\",\n \"def parse_arguments():\\n \\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"postcode\\\", type=str, help=\\\"Postcode of current location\\\")\\n parser.add_argument(\\\"-d\\\", \\\"--debug\\\", \\n help=\\\"Turns on debug mode\\\", \\n action='store_true')\\n parser.add_argument(\\\"-fp\\\",\\\"--postcode-file\\\", \\n default=\\\"postcodes_swift_sample.csv\\\",\\n help=\\\"Location of Postcode CSV file (default postcodes_swift_sample.csv)\\\",\\n type=str)\\n parser.add_argument(\\\"-fb\\\",\\\"--pub-file\\\", \\n default=\\\"pubnames_swift_sample.csv\\\",\\n help=\\\"Location of Pub Postcode CSV file (default pubnames_swift_sample.csv)\\\",\\n type=str)\\n parser.add_argument(\\\"-l\\\",\\\"--limit\\\", \\n default=10, \\n help=\\\"Limit Number of Results (default 10)\\\",\\n type=int)\\n parser.add_argument(\\\"-m\\\",\\\"--max-distance\\\", \\n default=50, \\n help=\\\"Only return results less than this distance (default 50)\\\",\\n type=int)\\n return parser\",\n \"def parse_args():\\n\\n parser = argparse.ArgumentParser(description='CLI to store Actisense-NGT Gateway values to InfluxDB and publish via MQTT')\\n parser.add_argument('--config', '-c', type=str, required=True, help='JSON configuraton file with path')\\n return parser.parse_args()\",\n \"def parse_arguments():\\n parser = argparse.ArgumentParser(description=\\\"Note: Plot depth files.\\\")\\n parser.add_argument(\\\"-d\\\", \\\"--depth_dir\\\", help='depth file directory')\\n parser.add_argument(\\\"-r\\\", \\\"--result_dir\\\", help='output directory')\\n parser.add_argument(\\\"-f\\\", \\\"--ref\\\", help='one depth file as ref')\\n parser.add_argument(\\\"-w\\\", \\\"--window_size\\\", help='sliding window size')\\n\\n args = parser.parse_args()\\n return args\",\n \"def parse_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"-t\\\", \\\"--thoughtspot_host\\\", required=True,\\n help=\\\"domain or ip. E.g. http://1.1.1.1\\\")\\n parser.add_argument(\\\"-u\\\", \\\"--username\\\", required=True,\\n help=\\\"username - must have administrative privileges\\\")\\n parser.add_argument(\\\"-p\\\", \\\"--password\\\", required=True,\\n help=\\\"password - must have administrative privileges\\\")\\n parser.add_argument(\\\"-d\\\", \\\"--delimiter\\\", default=',',\\n help=\\\"character to seperate values by. Default to comma\\\")\\n parser.add_argument(\\\"-c\\\", \\\"--csv\\\", action=\\\"store_true\\\",\\n help=\\\"create csv file called permissions.csv\\\")\\n parser.add_argument(\\\"-s\\\", \\\"--share\\\", action=\\\"store_true\\\",\\n help=\\\"output usable format for share api\\\")\\n return parser.parse_args()\",\n \"def _parse_args():\\n parser = argparse.ArgumentParser(description=\\\"\\\")\\n #parser.add_argument(\\\"args\\\", metavar=\\\"N\\\", type=str, nargs=\\\"*\\\", help=\\\"Positional arguments.\\\")\\n #parser.add_argument(\\\"\\\", dest=\\\"\\\", type=\\\"\\\", default=, help=)\\n #parser.add_argument(\\\"--version\\\", action=\\\"version\\\", version=\\\"<the version>\\\")\\n\\n return parser.parse_args()\",\n \"def _parse_args():\\n usage = \\\"usage: %prog [options] arg1 arg2\\\"\\n parser = optparse.OptionParser()\\n parser.add_option(\\n '--platform', dest='platform', default=\\\"\\\", type = \\\"string\\\",\\n help='platform name: UC 360 baidu etc.')\\n parser.add_option(\\n '--workspace', dest='workspace', default=\\\"./\\\", type = \\\"string\\\",\\n help='project directory.')\\n parser.add_option(\\n '--project', dest='projectDir', default=\\\"./destProject\\\", type = \\\"string\\\",\\n help='project directory.')\\n # parser.add_option(\\n # \\\"-t\\\", dest=\\\"test\\\", action=\\\"store_const\\\", const=lambda:_test, default=_test2, help=\\\"////////////\\\"\\n # )\\n options, args = parser.parse_args()\\n # positional arguments are ignored\\n return options, args\",\n \"def parse_args():\\n parser = MyParser(description='Data processing and analytics library \\\\\\n for OpenStack Browbeat perf data')\\n\\n parser.add_argument('-s', '--summary', dest=\\\"days\\\", type=int, default=-1,\\n help='-s N summary of last N days of results')\\n\\n parser.add_argument('--summary-uuid', dest=\\\"summary_uuid\\\", type=str,\\n default=None,\\n help='--summary-uuid UUID summary of a specific uuid')\\n\\n parser.add_argument('--short-summary', dest=\\\"short_days\\\", type=int,\\n default=-1,\\n help='--short-summary N gives \\\\\\n summary of last N days of results but uses cockroach \\\\\\n db so only provides with basic summary')\\n\\n parser.add_argument('--upload-timesummary', dest=\\\"timeseries_uuid\\\",\\n type=str, default=None,\\n help='--upload-timesummary UUID \\\\\\n uploads the features computed from data obtained from\\\\\\n graphite. ')\\n\\n parser.add_argument('--upload-logsummary', dest=\\\"loggin_uuid\\\",\\n type=str, default=None,\\n help='--upload-logsummary UUID \\\\\\n uploads the log summary to crdb \\\\\\n currently just summarizes over entire timeperiod. ')\\n\\n parser.add_argument('-u', '--update-db', dest='update', type=bool,\\n default=False,\\n help='-u True pushes data to cockroach db')\\n\\n parser.add_argument('--update-clf', dest=\\\"clf_days\\\", type=int,\\n default=-1,\\n help='--update-clf 60 will update all classifiers \\\\\\n listed in config file under classifier_lists \\\\\\n using data from last 60 days')\\n\\n parser.add_argument('--test-clf', dest=\\\"test_days\\\", type=int,\\n default=-1,\\n help='--test-clf 60 will train all classifiers \\\\\\n listed in config file under classifier_lists \\\\\\n using data from last 60 days and then test it \\\\\\n and display metrics')\\n\\n parser.add_argument('-v', '--osp-version', dest='version', type=str,\\n default=None,\\n help='-v 11-tripleo only returns hits for that \\\\\\n OpenStack version, \\\\\\n only supported by summary right now')\\n\\n parser.add_argument('-c', '--config', dest='config', type=str,\\n default=pkg_resources.resource_filename('bml',\\n \\\"config.yml\\\"),\\n help='-c <config file path> use custom config file')\\n\\n args = parser.parse_args()\\n return args\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.807208","0.74767","0.73985106","0.73932225","0.73173845","0.72599804","0.7232453","0.7222555","0.713585","0.7102058","0.71020466","0.7096281","0.7093058","0.70890576","0.7080071","0.70745754","0.70641047","0.70633066","0.70568484","0.7051162","0.70484704","0.70392704","0.70360875","0.70318705","0.7027451","0.70252234","0.7022721","0.7022492","0.70170593","0.7014263","0.70100504","0.7007431","0.6994161","0.699383","0.6983955","0.6983752","0.69775766","0.69572973","0.69533485","0.6947874","0.6945031","0.69413644","0.6922684","0.69203645","0.6918339","0.6913712","0.69133645","0.69080514","0.690557","0.69051087","0.68935853","0.68917054","0.68904185","0.6890077","0.68900126","0.68862873","0.68861234","0.6881948","0.6877161","0.68741214","0.6872096","0.6868787","0.6868005","0.6862433","0.6861699","0.68557686","0.68520546","0.6849977","0.68487155","0.6848432","0.6847478","0.6847275","0.68372065","0.68345195","0.68323785","0.6829461","0.6828884","0.6828278","0.6821114","0.6820864","0.68143517","0.68131423","0.6812891","0.681097","0.6810629","0.68098515","0.68074393","0.6801786","0.67999804","0.6798342","0.6791417","0.67910695","0.6789611","0.67888737","0.67882013","0.67845696","0.6779286","0.67742145","0.67737764","0.6772532","0.6772439"],"string":"[\n \"0.807208\",\n \"0.74767\",\n \"0.73985106\",\n \"0.73932225\",\n \"0.73173845\",\n \"0.72599804\",\n \"0.7232453\",\n \"0.7222555\",\n \"0.713585\",\n \"0.7102058\",\n \"0.71020466\",\n \"0.7096281\",\n \"0.7093058\",\n \"0.70890576\",\n \"0.7080071\",\n \"0.70745754\",\n \"0.70641047\",\n \"0.70633066\",\n \"0.70568484\",\n \"0.7051162\",\n \"0.70484704\",\n \"0.70392704\",\n \"0.70360875\",\n \"0.70318705\",\n \"0.7027451\",\n \"0.70252234\",\n \"0.7022721\",\n \"0.7022492\",\n \"0.70170593\",\n \"0.7014263\",\n \"0.70100504\",\n \"0.7007431\",\n \"0.6994161\",\n \"0.699383\",\n \"0.6983955\",\n \"0.6983752\",\n \"0.69775766\",\n \"0.69572973\",\n \"0.69533485\",\n \"0.6947874\",\n \"0.6945031\",\n \"0.69413644\",\n \"0.6922684\",\n \"0.69203645\",\n \"0.6918339\",\n \"0.6913712\",\n \"0.69133645\",\n \"0.69080514\",\n \"0.690557\",\n \"0.69051087\",\n \"0.68935853\",\n \"0.68917054\",\n \"0.68904185\",\n \"0.6890077\",\n \"0.68900126\",\n \"0.68862873\",\n \"0.68861234\",\n \"0.6881948\",\n \"0.6877161\",\n \"0.68741214\",\n \"0.6872096\",\n \"0.6868787\",\n \"0.6868005\",\n \"0.6862433\",\n \"0.6861699\",\n \"0.68557686\",\n \"0.68520546\",\n \"0.6849977\",\n \"0.68487155\",\n \"0.6848432\",\n \"0.6847478\",\n \"0.6847275\",\n \"0.68372065\",\n \"0.68345195\",\n \"0.68323785\",\n \"0.6829461\",\n \"0.6828884\",\n \"0.6828278\",\n \"0.6821114\",\n \"0.6820864\",\n \"0.68143517\",\n \"0.68131423\",\n \"0.6812891\",\n \"0.681097\",\n \"0.6810629\",\n \"0.68098515\",\n \"0.68074393\",\n \"0.6801786\",\n \"0.67999804\",\n \"0.6798342\",\n \"0.6791417\",\n \"0.67910695\",\n \"0.6789611\",\n \"0.67888737\",\n \"0.67882013\",\n \"0.67845696\",\n \"0.6779286\",\n \"0.67742145\",\n \"0.67737764\",\n \"0.6772532\",\n \"0.6772439\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":212,"numItemsPerPage":100,"numTotalItems":95772,"offset":21200,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjQ1ODE2MiwianRpIjoiZjFhN2ViOWMtNjNiMy00NGZhLTk5MjgtZTVkZGFiNTUzNWNhIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODY0NjE3NjIsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.cYod_fEZn_G8MhuVdYPVP9fTSqaHfzmAag2p_9QPq9CYhcatmTiGwZNDX90EQcPNHXDSqXhZ87KphrPDo3DaBA","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Show embedding space along indicated axis | def show_embedding(lT_log, axis, labels, save_path = None):
dim = len(axis)
assert(dim == 2 or dim == 3), "Only data in 2 or 3 dimension space can be visualized."
if dim == 2:
fig = plt.figure(figsize = (6, 6))
plt.scatter(lT_log[:, axis[0]], lT_log[:, axis[1]], c = 'b', s = 5)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def embedding_plot(model,datapath,img_size=100,stride=10,sample_size=1,nrand=None,adjust=True,show_images=True):\n data = set_creation(datapath,img_size,stride,sample_size,nrand=nrand,adjust=adjust)\n model.eval()\n z = model(data[:nrand].float())[-1]\n z = z.data.cpu().numpy()\n plt.style.use('seab... | [
"0.6425836",
"0.63833433",
"0.62624204",
"0.6229844",
"0.59683007",
"0.59402996",
"0.59251606",
"0.5922352",
"0.59185165",
"0.58601743",
"0.58289194",
"0.5825275",
"0.58004504",
"0.57833993",
"0.57783335",
"0.5713599",
"0.57017976",
"0.5687421",
"0.56848377",
"0.5648106",
"0.... | 0.611317 | 4 |
Show a point cloud in 2d | def show_pair_points(points, pairs, title, save_path = None):
fig = plt.figure(figsize = (6, 6))
plt.title(title)
plt.scatter(points[:, 0], points[:, 1], c = 'b', s = 5, label = "point cloud")
for pair in pairs:
print(pair)
point_1 = points[pair[0]]
point_2 = points[pair[1]]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def visualize_point_cloud(points, colors=None, normals=None,\n show_frame=False, frame_size=1.0, frame_origin=(0, 0, 0)):\n pc = np2pcd(points, colors, normals)\n geometries = [pc]\n if show_frame:\n coord_frame = o3d.geometry.TriangleMesh.create_coordinate_frame(size=frame... | [
"0.72636724",
"0.72375584",
"0.71609396",
"0.7132317",
"0.6933942",
"0.6919783",
"0.6877211",
"0.68398106",
"0.65854543",
"0.6562634",
"0.65615726",
"0.6518098",
"0.64886963",
"0.64688116",
"0.64599943",
"0.64297676",
"0.64172477",
"0.6347307",
"0.6338426",
"0.6316377",
"0.62... | 0.6120385 | 28 |
Show a point cloud in 2d | def show_symmetry(points, nb_1, nb_2, title, save_path = None):
fig = plt.figure(figsize = (6, 6))
plt.title(title)
plt.scatter(points[:, 0], points[:, 1], c = 'b', s = 5, label = "point cloud")
plt.scatter(nb_1[:, 0], nb_1[:, 1], c = 'r', s = 5, label = "symmetry_1")
plt.scatter(nb_2[:, 0], nb_2[:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def visualize_point_cloud(points, colors=None, normals=None,\n show_frame=False, frame_size=1.0, frame_origin=(0, 0, 0)):\n pc = np2pcd(points, colors, normals)\n geometries = [pc]\n if show_frame:\n coord_frame = o3d.geometry.TriangleMesh.create_coordinate_frame(size=frame... | [
"0.72636724",
"0.72375584",
"0.71609396",
"0.7132317",
"0.6933942",
"0.6919783",
"0.6877211",
"0.68398106",
"0.65854543",
"0.6562634",
"0.65615726",
"0.6518098",
"0.64886963",
"0.64688116",
"0.64599943",
"0.64297676",
"0.64172477",
"0.6347307",
"0.6338426",
"0.6316377",
"0.62... | 0.0 | -1 |
Show a point cloud in 2d | def show_orbits(points, nb_pairs, title, save_path = None):
fig = plt.figure(figsize = (6, 6))
plt.title(title)
plt.scatter(points[:, 0], points[:, 1], c = 'b', s = 5, label = "point cloud")
for i in range(len(nb_pairs)):
plt.scatter(nb_pairs[i][0][:, 0], nb_pairs[i][0][:, 1], s = 5, label = "%... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def visualize_point_cloud(points, colors=None, normals=None,\n show_frame=False, frame_size=1.0, frame_origin=(0, 0, 0)):\n pc = np2pcd(points, colors, normals)\n geometries = [pc]\n if show_frame:\n coord_frame = o3d.geometry.TriangleMesh.create_coordinate_frame(size=frame... | [
"0.72636724",
"0.72375584",
"0.71609396",
"0.7132317",
"0.6933942",
"0.6919783",
"0.6877211",
"0.68398106",
"0.65854543",
"0.6562634",
"0.65615726",
"0.6518098",
"0.64886963",
"0.64688116",
"0.64599943",
"0.64297676",
"0.64172477",
"0.6347307",
"0.6338426",
"0.6316377",
"0.62... | 0.57572305 | 58 |
StandardizedTierTier a model defined in Swagger | def __init__(self, value=None, calculated_at=None, explanation=None): # noqa: E501 # noqa: E501
self._value = None
self._calculated_at = None
self._explanation = None
self.discriminator = None
self.value = value
if calculated_at is not None:
self.calculated_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tier(self) -> Optional[pulumi.Input['InstanceTier']]:\n return pulumi.get(self, \"tier\")",
"def tier(self):\n\n if not hasattr(self, \"_tier\"):\n self._tier = self.opts.get(\"tier\")\n return self._tier",
"def tier(self) -> str:\n return pulumi.get(self, \"tier\")",... | [
"0.6445188",
"0.64363265",
"0.6409928",
"0.6409928",
"0.6409928",
"0.6311461",
"0.62864465",
"0.62864465",
"0.62864465",
"0.62864465",
"0.62321186",
"0.6222428",
"0.6162602",
"0.6059804",
"0.6050189",
"0.6026945",
"0.6004567",
"0.60025877",
"0.5947694",
"0.59205824",
"0.58603... | 0.0 | -1 |
Sets the value of this StandardizedTierTier. | def value(self, value):
if value is None:
raise ValueError("Invalid value for `value`, must not be `None`") # noqa: E501
self._value = value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tier(self, tier):\n\n self._tier = tier",
"def set_tier(self, tier):\n self.single_selection_from_static_kendo_dropdown(self.tier_kendo_dropdown_locator, tier)",
"def tier_number(self, tier_number):\n\n self._tier_number = tier_number",
"def tier(self):\n\n if not hasattr(self... | [
"0.7639537",
"0.73581266",
"0.6899906",
"0.66168433",
"0.65216136",
"0.64917374",
"0.646807",
"0.64081466",
"0.62762964",
"0.6239686",
"0.6239686",
"0.6239686",
"0.61774784",
"0.6152759",
"0.6099056",
"0.60591483",
"0.6048403",
"0.6048403",
"0.6048403",
"0.6048403",
"0.597409... | 0.0 | -1 |
Sets the calculated_at of this StandardizedTierTier. | def calculated_at(self, calculated_at):
self._calculated_at = calculated_at | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tier(self, tier):\n\n self._tier = tier",
"def scheduled_at(self, scheduled_at):\n\n self._scheduled_at = scheduled_at",
"def set_tier(self, tier):\n self.single_selection_from_static_kendo_dropdown(self.tier_kendo_dropdown_locator, tier)",
"def created_at(self, created_at):\n\n ... | [
"0.58256483",
"0.5355169",
"0.5262881",
"0.51667094",
"0.51667094",
"0.51667094",
"0.51667094",
"0.51667094",
"0.51667094",
"0.51667094",
"0.51667094",
"0.51667094",
"0.51667094",
"0.51667094",
"0.51667094",
"0.51667094",
"0.51667094",
"0.51667094",
"0.51667094",
"0.51667094",
... | 0.7393106 | 0 |
Sets the explanation of this StandardizedTierTier. | def explanation(self, explanation):
self._explanation = explanation | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tier_explanation(self, tier_explanation):\n\n self._tier_explanation = tier_explanation",
"def tier(self, tier):\n\n self._tier = tier",
"def set_description(self, descr):\n self._current_test_descr = descr",
"def description(self, value):\n self.definition.description = value... | [
"0.79957366",
"0.5871474",
"0.5464915",
"0.54482603",
"0.5392081",
"0.53604364",
"0.52467775",
"0.52365154",
"0.5220184",
"0.5220184",
"0.5220184",
"0.5220184",
"0.52154154",
"0.5203799",
"0.51837766",
"0.5157714",
"0.51374966",
"0.5122163",
"0.5120805",
"0.51175475",
"0.5111... | 0.6389624 | 1 |
Returns the model properties as a dict | def to_dict(self):
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_dict(self):\n return self.properties",
"def to_dict(self):\n return self.properties",
"def get_properties(self):\n return self.properties",
"def asdict(self):\n return self._prop_dict",
"def json(self):\n rv = {\n prop: getattr(self, prop)\n f... | [
"0.7751993",
"0.7751993",
"0.73391134",
"0.7334895",
"0.7297356",
"0.727818",
"0.7159078",
"0.71578115",
"0.71494967",
"0.71494967",
"0.71283495",
"0.71275014",
"0.7122587",
"0.71079814",
"0.7060394",
"0.7043251",
"0.7034103",
"0.70233124",
"0.69635814",
"0.69586295",
"0.6900... | 0.0 | -1 |
Returns the string representation of the model | def to_str(self):
return pprint.pformat(self.to_dict()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n return super().__str__() + self.model.__str__()",
"def __str__(self) -> str:\n # noinspection PyUnresolvedReferences\n opts = self._meta\n if self.name_field:\n result = str(opts.get_field(self.name_field).value_from_object(self))\n else:\n ... | [
"0.85856134",
"0.7814518",
"0.77898884",
"0.7751367",
"0.7751367",
"0.7712228",
"0.76981676",
"0.76700574",
"0.7651133",
"0.7597206",
"0.75800353",
"0.7568254",
"0.7538184",
"0.75228703",
"0.7515832",
"0.7498764",
"0.74850684",
"0.74850684",
"0.7467648",
"0.74488163",
"0.7442... | 0.0 | -1 |
For `print` and `pprint` | def __repr__(self):
return self.to_str() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pprint(*args, **kwargs):\n if PRINTING:\n print(*args, **kwargs)",
"def print_out():\n pass",
"def custom_print(*objects):\n print(*objects, sep=OFS, end=ORS)",
"def _print(self, *args):\n return _ida_hexrays.vd_printer_t__print(self, *args)",
"def _printable(self):\n ... | [
"0.75577617",
"0.73375154",
"0.6986672",
"0.698475",
"0.6944995",
"0.692333",
"0.6899106",
"0.6898902",
"0.68146646",
"0.6806209",
"0.6753795",
"0.67497987",
"0.6744008",
"0.6700308",
"0.6691256",
"0.6674591",
"0.6658083",
"0.66091245",
"0.6606931",
"0.6601862",
"0.6563738",
... | 0.0 | -1 |
Returns true if both objects are equal | def __eq__(self, other):
if not isinstance(other, StandardizedTierTier):
return False
return self.__dict__ == other.__dict__ | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __eq__(self, other):\n return are_equal(self, other)",
"def __eq__(self, other):\n return are_equal(self, other)",
"def __eq__(self,other):\n try: return self.object==other.object and isinstance(self,type(other))\n except: return False",
"def __eq__(self, other):\n if i... | [
"0.8088132",
"0.8088132",
"0.8054589",
"0.7982687",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
... | 0.0 | -1 |
Returns true if both objects are not equal | def __ne__(self, other):
return not self == other | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __ne__(self, other: object) -> bool:\n if self.__eq__(other):\n return False\n return True",
"def __ne__(self, other: object) -> bool:\n return not self.__eq__(other)",
"def __ne__(self, other) -> bool:\n return not self.__eq__(other)",
"def __eq__(self, other):\n ... | [
"0.845611",
"0.8391477",
"0.8144138",
"0.81410587",
"0.8132492",
"0.8093973",
"0.80920255",
"0.80920255",
"0.80920255",
"0.8085325",
"0.8085325",
"0.8076365",
"0.8076365",
"0.8065748"
] | 0.0 | -1 |
This funtion return one list whits the path of ISOs in the folder path insired in parameter | def GetFolderISOFiles(Path):
ISOFiles = []
for file in os.listdir(Path):
if file[-3:] == 'iso' or file[-3:] == 'ISO':
ISOFiles.append(Path + '/' +file)
print(ISOFiles)
return ISOFiles | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_dir(self, path):",
"def scandir(path_):\n return os.listdir",
"def get_paths(input_folder):\n list_files = []\n conll_folder = glob.glob(input_folder + '/*.json')\n \n for filename in conll_folder:\n list_files.append(filename)\n\n return list_files",
"def listdir(self, path):... | [
"0.73667353",
"0.6840524",
"0.6687913",
"0.6571327",
"0.65693957",
"0.65582794",
"0.6470085",
"0.64291453",
"0.6407391",
"0.6406979",
"0.6390135",
"0.6389266",
"0.63871384",
"0.6367787",
"0.6366471",
"0.6361143",
"0.6350033",
"0.63489014",
"0.63378185",
"0.6336536",
"0.630323... | 0.6264688 | 25 |
This funtion return integer the number of files in ISO | def NumberOfFilesInISO(XISOPath, XSystemUpdateFolder):
command='./extract-xiso -l '
if XSystemUpdateFolder == True:
command = command + '-s '
command = command + '"' + XISOPath + '"'
print(command)
commandOut = commands.getstatusoutput(command)
commandOut = commandOut[1].split('\n')
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def n_file(self):\n self.assert_is_dir_and_exists()\n n = 0\n for _ in self.select_file(recursive=True):\n n += 1\n return n",
"def getFileCount(self) -> int:\n ...",
"def n_subfile(self):\n self.assert_is_dir_and_exists()\n n = 0\n for _ in se... | [
"0.7400887",
"0.7315209",
"0.72290283",
"0.7170745",
"0.701988",
"0.7000022",
"0.688257",
"0.68750906",
"0.681171",
"0.6706613",
"0.66990584",
"0.66621566",
"0.6575327",
"0.6553808",
"0.65233034",
"0.6516356",
"0.6504051",
"0.64615285",
"0.6457432",
"0.64490885",
"0.64460576"... | 0.76097965 | 0 |
This funtion extract the files in ISO | def ExtractFilesInISO(XISOPath, ExtractPath, XSystemUpdateFolder):
command=['./extract-xiso', '-x']
if XSystemUpdateFolder == True:
command.append('-s')
command.append(XISOPath)
command.append('-d')
command.append(ExtractPath)
print(command)
sp = subprocess
global extract_popen
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetFolderISOFiles(Path):\n ISOFiles = []\n for file in os.listdir(Path):\n if file[-3:] == 'iso' or file[-3:] == 'ISO':\n ISOFiles.append(Path + '/' +file)\n print(ISOFiles)\n return ISOFiles",
"def extract_files(self) -> list:\n pass",
"def extract_file(path):",
"def... | [
"0.6875039",
"0.6585387",
"0.639804",
"0.6164385",
"0.615887",
"0.60463774",
"0.60278195",
"0.5982999",
"0.5965153",
"0.58846104",
"0.5834605",
"0.5832406",
"0.5804196",
"0.57813597",
"0.56719345",
"0.5636692",
"0.56353647",
"0.5620858",
"0.5593477",
"0.5582736",
"0.5560074",... | 0.6522118 | 2 |
x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature | def __init__(self,*args):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs): # real signature unknown; restored from __doc__\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signature unknown\n pass",
"def __init__(self, *args, **kwargs): # real signa... | [
"0.72748435",
"0.72478586",
"0.72478586",
"0.72478586",
"0.7114322",
"0.7114322",
"0.7114322",
"0.7114322",
"0.7114322",
"0.7114322",
"0.7114322",
"0.7114322",
"0.7114322",
"0.7114322",
"0.7114322",
"0.7114322",
"0.7114322",
"0.7114322",
"0.7114322",
"0.7114322",
"0.7114322",... | 0.0 | -1 |
Reads a dataset from a URL. | def url(self, path=None, type_of="csv"):
if "https://" in str(path) or "http://" in str(path) or "file://" in str(path):
return self.data_loader(str(path), type_of)
else:
print("Unknown sample data identifier. Please choose an id from the list below") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_dataset(dataset_name):\n url = METADATA[dataset_name][\"url\"]\n f = urlopen(url)\n data = _read_rows(f)\n f.close()\n return data",
"def fetch_dataset(url, pandas_impl=pandas):\n\n print(f'fetching dataset at {url}')\n return pandas_impl.read_csv(url)",
"def download_dataset(url=... | [
"0.7019222",
"0.68966436",
"0.64686316",
"0.6397562",
"0.6298438",
"0.6295649",
"0.62236893",
"0.620894",
"0.61802775",
"0.6161452",
"0.61373895",
"0.61128914",
"0.6091466",
"0.6078371",
"0.60036445",
"0.5996286",
"0.59936446",
"0.5965552",
"0.5925381",
"0.5887669",
"0.588329... | 0.56938386 | 34 |
Load data in from a url | def data_loader(self, url, type_of):
data_loader = None
if type_of == "csv":
data_loader = self.csv
elif type_of == "json":
data_loader = self.json
elif type_of == "parquet":
data_loader = self.parquet
elif type_of == "avro":
data_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load(self, url):\n pass",
"def load(self, url):\n pass",
"def loadu(self, url, **kwargs):\n return self.load(self.open(url, **kwargs), **kwargs)",
"def load_data(url: str):\n\n page = requests.get(url=url)\n soup = BeautifulSoup(page.content, 'html.parser')\n return soup",
... | [
"0.7975374",
"0.7975374",
"0.71954376",
"0.7168951",
"0.7048649",
"0.67794764",
"0.67726195",
"0.67448",
"0.66270715",
"0.65927124",
"0.65730786",
"0.656582",
"0.65383065",
"0.6533763",
"0.6517917",
"0.6501635",
"0.645566",
"0.6428035",
"0.6413853",
"0.6394601",
"0.63764846",... | 0.66978467 | 8 |
Return a dataframe from a json file. | def json(path):
try:
# TODO: Check a better way to handle this Spark.instance.spark. Very verbose.
df = Spark.instance.spark.read.json(path)
except IOError as error:
logging.error(error)
raise
return df | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_file(filename):\n with open(filename, 'rt') as f:\n d = json.load(f)\n return pd.DataFrame.from_records(d['dataset'])",
"def load_data(filepath):\n \n return pd.read_json(filepath)",
"def load_data(self, filepath: str) -> pd.DataFrame:\n \n with open(filepath) as f:\n ... | [
"0.819254",
"0.7823375",
"0.78119093",
"0.77657497",
"0.75791085",
"0.75206435",
"0.7203945",
"0.7167869",
"0.71065944",
"0.7062188",
"0.6910279",
"0.6895788",
"0.6882497",
"0.68209225",
"0.67718965",
"0.67359996",
"0.6689824",
"0.666205",
"0.6643767",
"0.66075075",
"0.659852... | 0.7011017 | 10 |
Return a dataframe from a csv file.. It is the same read.csv Spark funciont with some predefined params | def csv(path, sep=',', header='true', infer_schema='true', *args, **kwargs):
try:
df = (Spark.instance.spark.read
.options(header=header)
.options(mode="DROPMALFORMED")
.options(delimiter=sep)
.options(inferSchema=infer_schema)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse_csv(csv_file: str) -> pd.DataFrame:\n return pd.read_csv(csv_file, header=0)",
"def creat_data_frame(spark, file_path):\n df = spark.read \\\n .format(\"csv\") \\\n .option(\"header\", \"true\") \\\n .option(\"inferSchema\", \"true\")\\\n .option(\"samplingRatio\"... | [
"0.76742333",
"0.7583322",
"0.7549034",
"0.74641407",
"0.7448721",
"0.7291787",
"0.7285959",
"0.724744",
"0.7237754",
"0.72303444",
"0.7169547",
"0.7167265",
"0.71414346",
"0.7114549",
"0.7114549",
"0.7114549",
"0.70971113",
"0.7084145",
"0.7058288",
"0.7057585",
"0.70570195"... | 0.7121996 | 13 |
Return a dataframe from a parquet file. | def parquet(path, *args, **kwargs):
try:
df = Spark.instance.spark.read.parquet(path, *args, **kwargs)
except IOError as error:
logging.error(error)
raise
return df | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _pq2df(data_file):\n df = pd.read_parquet(data_file)\n return df",
"def read_parquet(self, filename):\n if filename is None:\n raise ValueError(\"File name is None\")\n self.logger.info(\"# Reading a Parquet file \" + filename)\n sqlContext = SQLContext(self.spar... | [
"0.8080801",
"0.7680819",
"0.75473124",
"0.71808255",
"0.70952356",
"0.66877913",
"0.65009177",
"0.64348716",
"0.642109",
"0.64079404",
"0.63399845",
"0.63359207",
"0.62860304",
"0.624169",
"0.6233218",
"0.62246",
"0.6219255",
"0.61767995",
"0.61527157",
"0.6148135",
"0.61377... | 0.7916956 | 1 |
Load the data from the http request and save it to disk | def write(response, file, chunk_size=8192):
total_size = response.headers['Content-Length'].strip() if 'Content-Length' in response.headers else 100
total_size = int(total_size)
bytes_so_far = 0
while 1:
chunk = response.read(chunk_size)
bytes_so_far += len(chunk... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_data(self):\n # Command to get the download data\n pass",
"def fetch_save(url):\n\n name = url.split(\"/\")[-1]\n response = requests.get(url, stream=True)\n if response.status_code == 200:\n with open(f\"{DATA_PATH}/{name}\", \"wb\") as f:\n f.write(response.raw... | [
"0.6473304",
"0.6228162",
"0.6082731",
"0.60531247",
"0.60495657",
"0.58681047",
"0.58047765",
"0.5790845",
"0.57289547",
"0.57250524",
"0.56729966",
"0.56631887",
"0.5648555",
"0.55728006",
"0.5553491",
"0.5541447",
"0.5524647",
"0.5520609",
"0.5501267",
"0.5475646",
"0.5462... | 0.0 | -1 |
Preprocess takes an input text line an applies the same preprocessing used in AraBERT pretraining | def preprocess(self, text):
if self.model_name == "bert-base-arabert":
return self._old_preprocess(
text,
do_farasa_tokenization=True,
)
if self.model_name == "bert-base-arabertv01":
return self._old_preprocess(text, do_farasa_tokeniza... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _preprocess(self):\n self.data['sentences'] = self.data['text'].apply(self._tokenize_sent)\n self.data['nouns'] = self.data['sentences'].apply(self._get_nouns)\n # self._get_frequent_features()\n # self._compactness_pruning()\n # self._redundancy_pruning()\n # self._ge... | [
"0.702124",
"0.69629145",
"0.6902451",
"0.67785484",
"0.6768156",
"0.6608686",
"0.6521776",
"0.64922255",
"0.64709795",
"0.6442964",
"0.64070773",
"0.64030266",
"0.6400484",
"0.6388811",
"0.6304131",
"0.62909514",
"0.62859696",
"0.6259122",
"0.62560683",
"0.6245865",
"0.62340... | 0.6612534 | 5 |
Reformats the text to a classic format where punctuations, brackets, parenthesis are not seperated by whitespaces. The objective is to make the generated text of any model appear natural and not preprocessed. | def unpreprocess(self, text, desegment=True):
if self.model_name in SEGMENTED_MODELS and desegment:
text = self.desegment(text)
# removes the spaces around quotation marks ex: i " ate " an apple --> i "ate" an apple
# https://stackoverflow.com/a/53436792/5381220
text = re.s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocess(text):\n text = remove_space(text)\n text = clean_special_punctuations(text)\n text = handle_emojis(text)\n text = clean_number(text)\n text = spacing_punctuation(text)\n text = clean_repeat_words(text)\n text = remove_space(text)\n #text = stop(text)# if changing this, then ... | [
"0.75282043",
"0.7487975",
"0.7090226",
"0.7074452",
"0.7063821",
"0.70452",
"0.70105666",
"0.6962441",
"0.68735754",
"0.68567324",
"0.6851152",
"0.6823446",
"0.6807199",
"0.68018055",
"0.67301124",
"0.6724816",
"0.6709943",
"0.6704058",
"0.6702815",
"0.6690054",
"0.66852236"... | 0.6972378 | 7 |
Function to evaluate the log prior. This is a piecewise function returning either 0 or inf | def log_prior(self, x_scaled):
x = scale_inverse_transform(self.parameters_scaler, x_scaled)
ln_prior = {}
for key in self.param_names:
try:
ln_prior[key] = self.priors[key].log_prob(x[:, self.param_names.index(key)])
except TypeError:
x = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log_prior(x):\n logp = (-0.5 * x.pow(2) - torch.tensor(2 * math.pi).sqrt().log()).sum(dim=1)\n return logp",
"def _call(self, x):\n if self.prior is None:\n tmp = ((x - 1 - np.log(x)).inner(self.domain.one()))\n else:\n # This is the old line from odl version 0.6.0.\... | [
"0.7649668",
"0.73823214",
"0.7289497",
"0.725724",
"0.70369273",
"0.70355916",
"0.7010997",
"0.6862679",
"0.6834659",
"0.6778597",
"0.67636824",
"0.67523545",
"0.6744715",
"0.6699147",
"0.66762686",
"0.66680676",
"0.6666778",
"0.66549045",
"0.66526407",
"0.6646927",
"0.66401... | 0.6267439 | 70 |
Function to evaluate the log prob. This is the GP log mean + log prior. | def log_prob(self, x_scaled):
predictions = self.likelihood(x_scaled)
# this function transform the gp mean back to "real" space
mean_with_negatives = scale_inverse_transform(self.y_scaler, predictions[0])
# this function replaces negative numbers with zero
mean = tf.nn.relu(mean... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_log_prob(self,params: ndarray) -> float:\n return self.compute_log_prior(params) + self.compute_log_likelihood(params)",
"def log_prob(self):",
"def _logp(self, trace, **inputs):\n def calc_log(step):\n exp_pred = np.dot(inputs['gwas_gen'],\n st... | [
"0.7727266",
"0.77067864",
"0.72754896",
"0.7169533",
"0.71564955",
"0.71349055",
"0.7094473",
"0.70543903",
"0.70453304",
"0.69967514",
"0.69836086",
"0.6983456",
"0.6933256",
"0.69321316",
"0.69272345",
"0.69110745",
"0.6890131",
"0.68761575",
"0.68632084",
"0.68632084",
"0... | 0.69520956 | 12 |
Function to evaluate GP variance with priors | def mult_var_by_prior(self, x_scaled):
model_var = self.likelihood(x_scaled)[1]
tensor_log_prior = self.log_prior(x_scaled)
return tf.reshape(model_var, shape=tensor_log_prior.shape) * tf.math.exp(tensor_log_prior) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def conditional_variance(self, gp):\n raise NotImplementedError",
"def _variance(self,gp):\r\n return self.variance",
"def _variance(self,gp):\r\n p = self.gp_link.transf(gp)\r\n return p*(1.-p)",
"def _variance(self,gp):\r\n return self.gp_link.transf(gp)**2",
"def _vari... | [
"0.7001479",
"0.69190866",
"0.6851098",
"0.68463093",
"0.6823274",
"0.6555642",
"0.64821726",
"0.64297533",
"0.6186828",
"0.6145154",
"0.6105192",
"0.6069326",
"0.60412335",
"0.59106874",
"0.58750397",
"0.5839199",
"0.58274245",
"0.58097214",
"0.5796802",
"0.5782451",
"0.5769... | 0.0 | -1 |
Returns GP mean and variance in "scaled" space (same as gpflow model.predict_f with bounds applied) | def predict(self, x_scaled):
model_var_with_prior = self.mult_var_by_prior(x_scaled)
scaled_space_mean = self.y_scaler.transform(tf.reshape(tf.math.exp(self.log_prob(x_scaled)), [-1, 1]))
return scaled_space_mean, tf.reshape(model_var_with_prior, [-1, 1]).numpy() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fit_gp(self, inputs):\n x_context, y_context, x_data = inputs\n kernel = GP.kernels.RBF(length_scale=self._l_scale, length_scale_bounds=(1e-2, 1e3))\n gp = GP.GaussianProcessRegressor(kernel=kernel).fit(x_context[-1, :], y_context[-1, :])\n y_prediction, y_prediction_std = gp.predic... | [
"0.60946023",
"0.5923903",
"0.5884754",
"0.58357656",
"0.57872975",
"0.56988716",
"0.56963426",
"0.56526315",
"0.56245965",
"0.5610475",
"0.56104165",
"0.55741924",
"0.5556511",
"0.5541308",
"0.55345446",
"0.55169386",
"0.54802036",
"0.54369193",
"0.5432692",
"0.5422389",
"0.... | 0.62195873 | 0 |
Returns multiple GP samples | def predict_samples(self, x_scaled):
all_predictions = []
predictions = self.likelihood(x_scaled)
#Todo: this loop can easily be vectorised
# fix this when plots have been made
for i in range(predictions.shape[0]):
mean_with_negatives = scale_inverse_transform(self.y_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def samples(self, gp):\r\n raise NotImplementedError",
"def samples(self, gp):\r\n orig_shape = gp.shape\r\n gp = gp.flatten()\r\n Ysim = np.random.poisson(self.gp_link.transf(gp))\r\n return Ysim.reshape(orig_shape)",
"def samples(self, gp):\r\n orig_shape = gp.shape\... | [
"0.7857813",
"0.68662995",
"0.6837922",
"0.6826287",
"0.6791251",
"0.66837394",
"0.66450995",
"0.6641715",
"0.65879714",
"0.6524494",
"0.6492363",
"0.6492363",
"0.6454193",
"0.64254946",
"0.6308791",
"0.6303437",
"0.6291386",
"0.6185553",
"0.61466175",
"0.6123374",
"0.6100571... | 0.0 | -1 |
Run sampler over marginal posterior surface. This returns the posterior samples. | def sample_density(self, num_results, num_burnin_steps, initialise_chains, sampler):
assert initialise_chains.shape[0] > 1, 'number of chains is 1, at least two chains must be used when sampling'
p0 = tf.convert_to_tensor(initialise_chains, dtype=float_type)
if sampler == 'MCMC':
in... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def posterior_sample(self):\n pass",
"def sample_posterior(self):\n if(self.Bayesian):\n for i in range(self.num_layers):\n getattr(self, 'LSTMCell%i'%(i+1)).sample_posterior()",
"def _sample_posterior(self):\n\n latent_dim = self.network_architecture['latent_dim'... | [
"0.6507249",
"0.6463244",
"0.6384315",
"0.61163783",
"0.60296214",
"0.6013357",
"0.5988046",
"0.5971502",
"0.5960403",
"0.5866206",
"0.585658",
"0.57961535",
"0.57058126",
"0.5644703",
"0.56423026",
"0.55828935",
"0.5537393",
"0.5511536",
"0.55076844",
"0.54656184",
"0.545747... | 0.0 | -1 |
Wrapper around sklearn scaler (inverse) that doesn't involve numpy | def scale_inverse_transform(whatever_scaler, X):
x_new = tf.identity(X)
try:
x_new -= whatever_scaler.min_
x_new /= whatever_scaler.scale_
except AttributeError:
x_new *= whatever_scaler.scale_
x_new += whatever_scaler.mean_
return x_new | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def denorm_it(val, scaler):\n # # inverse transform a single value\n newval = scaler.inverse_transform(val.reshape(1, -1))\n return newval",
"def invert_scale(scaler, X, value):\n new_row = [x for x in X] + [value]\n array = np.array(new_row)\n array = array.reshape(1, len(array))\n inverted... | [
"0.7345006",
"0.7250114",
"0.6689134",
"0.6689134",
"0.6689134",
"0.6689134",
"0.6689134",
"0.661905",
"0.65860146",
"0.65598065",
"0.65575606",
"0.6500443",
"0.6460542",
"0.64214194",
"0.6390401",
"0.6373423",
"0.6335165",
"0.63232076",
"0.62935996",
"0.6272957",
"0.6263339"... | 0.7202794 | 2 |
all outputs have the unit of mW | def power_report(
file=None
):
for entry in file:
elems = entry.strip().split(' ')
elems = prune(elems)
if len(elems) >= 6:
if elems[0] == "Total" and elems[1] == "Dynamic" and elems[2] == "Power" and elems[3] == "=":
dynamic = float(elems[4])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def W(self):\n if not self.isVaild():\n pass\n return self.Wq() + 1.0/self.muy",
"def useUnits():",
"def uw(self):\n return sm.unitvec(self.w)",
"def get_mol_wt(self):\n return self.get_empirical_formula().get_molecular_weight()",
"def get_mol_wt(self):\n retur... | [
"0.6041866",
"0.59337413",
"0.59043",
"0.5867506",
"0.5867506",
"0.58634657",
"0.58505666",
"0.58334017",
"0.58291554",
"0.5828685",
"0.58197",
"0.5807507",
"0.58058566",
"0.5801746",
"0.579691",
"0.5763294",
"0.5752986",
"0.57422733",
"0.57375646",
"0.57270724",
"0.57161635"... | 0.0 | -1 |
output has the unit of mm^2 | def area_report(
file=None
):
for entry in file:
elems = entry.strip().split(' ')
elems = prune(elems)
if len(elems) >= 3:
if str(elems[0]) == "Total" and str(elems[1]) == "cell" and str(elems[2]) == "area:":
area = float(elems[3])
if str(elems[0]... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __convert_to_mm(self, value, in_devunit=True):\r\n if in_devunit:\r\n value /= self.DEVUNIT_RATIO\r\n return value",
"def m_to_mm(meters):\n return meters * 1000.0",
"def m_to_mm(): \n # Set blender unit in mm\n bpy.context.scene.unit_settings.scale_length = 0.001... | [
"0.68497676",
"0.6797037",
"0.67805916",
"0.67592186",
"0.67404824",
"0.6646447",
"0.6638052",
"0.6588755",
"0.6511798",
"0.6504115",
"0.64981365",
"0.63728786",
"0.6351094",
"0.62902117",
"0.62816006",
"0.62397957",
"0.6225386",
"0.6223449",
"0.6203363",
"0.6186232",
"0.6138... | 0.0 | -1 |
By now we allow all allowed types without constrain. | def getLocallyAllowedTypes(self):
portal_types = api.portal.get_tool('portal_types')
my_type = portal_types.getTypeInfo(self)
result = portal_types.listTypeInfo()
return [t for t in result if my_type.allowType(t.getId()) and
t.isConstructionAllowed(self)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _is_allows_valid(self):\n if not isinstance(self.allows_, list):\n raise TypeError(\n 'allows type is %s but expected type is list: %s' % (\n type(self.allows_), self.allows_))\n\n for i, allow in enumerate(self.allows_):\n if not isinstance... | [
"0.6289284",
"0.62070316",
"0.6151418",
"0.6090969",
"0.6066005",
"0.60621774",
"0.6060789",
"0.6038607",
"0.5915495",
"0.5901182",
"0.5901182",
"0.5845438",
"0.5804473",
"0.57753146",
"0.5764553",
"0.57635087",
"0.5748032",
"0.57470876",
"0.5707446",
"0.56632257",
"0.566026"... | 0.0 | -1 |
By now we allow all allowed types without constrain. | def getImmediatelyAddableTypes(self, context=None):
return self.getLocallyAllowedTypes() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _is_allows_valid(self):\n if not isinstance(self.allows_, list):\n raise TypeError(\n 'allows type is %s but expected type is list: %s' % (\n type(self.allows_), self.allows_))\n\n for i, allow in enumerate(self.allows_):\n if not isinstance... | [
"0.6289284",
"0.62070316",
"0.6151418",
"0.6090969",
"0.6066005",
"0.60621774",
"0.6060789",
"0.6038607",
"0.5915495",
"0.5901182",
"0.5901182",
"0.5845438",
"0.5804473",
"0.57753146",
"0.5764553",
"0.57635087",
"0.5748032",
"0.57470876",
"0.5707446",
"0.56632257",
"0.566026"... | 0.5549926 | 28 |
Call PyEz to install new JUNOS image to device | def install_device_software(self, path, image, target_version):
package = os.path.join(os.getcwd(), path)
if c.SERVICEPLUGIN_OSSH in self.sample_device.deviceServicePlugin:
try:
Tools.emit_log(task_name=self.task_name, sample_device=self.sample_device,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def install(self):\n PiService.install(self)\n self.sudo('svn co https://svn.code.sf.net/p/mjpg-streamer/code /etc/mjpg-streamer')\n self.run('cd /etc/mjpg-streamer/mjpg-streamer && sudo make USE_LIB4VL=true clean all && sudo make DESTDIR=/usr install')",
"def _install():\n download_file='http://www.i... | [
"0.6222078",
"0.6078283",
"0.59629583",
"0.5815941",
"0.57550997",
"0.5706842",
"0.56755555",
"0.5663717",
"0.56422436",
"0.5641112",
"0.56124735",
"0.55439395",
"0.552297",
"0.55203617",
"0.5495007",
"0.5493053",
"0.54912466",
"0.54787534",
"0.54780823",
"0.547773",
"0.54126... | 0.4962376 | 62 |
Connect social account to existing account, if existing email found | def pre_social_login(self, request, sociallogin):
if sociallogin.is_existing:
return
email_addresses = sociallogin.email_addresses
for email in email_addresses:
try:
user_email = EmailAddress.objects.get(email__iexact=email.email)
except Ema... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _external_login_or_signup(request,\r\n external_id,\r\n external_domain,\r\n credentials,\r\n email,\r\n fullname,\r\n retfun=None):\r\n ... | [
"0.6368004",
"0.60966545",
"0.6048381",
"0.59991693",
"0.59486884",
"0.5934243",
"0.5869946",
"0.58662754",
"0.5855204",
"0.5833579",
"0.5811763",
"0.57687676",
"0.57521755",
"0.56753784",
"0.5648578",
"0.5643133",
"0.5633166",
"0.56330556",
"0.56206214",
"0.5619708",
"0.5619... | 0.7319161 | 0 |
Calculates total loss containing cross entropy with padding ignored. | def loss_function(real, pred, loss_object, pad_token_id):
mask = tf.math.logical_not(tf.math.equal(real, pad_token_id))
loss_ = loss_object(real, pred)
mask = tf.cast(mask, dtype=loss_.dtype)
loss_ *= mask
return tf.reduce_sum(loss_) / tf.reduce_sum(mask) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_loss(self, train_x, train_y):\n self.log.info(\"Calculating average categorical crossentropy loss...\")\n\n num_words = np.sum([len(y) for y in train_y])\n return self.calculate_total_loss(train_x, train_y)/float(num_words)",
"def calculate_loss(self, pred, gold, smoothing=Fals... | [
"0.6906149",
"0.67943317",
"0.6712057",
"0.6665505",
"0.6519638",
"0.6517783",
"0.651644",
"0.64891195",
"0.6484199",
"0.6472904",
"0.6467562",
"0.6440021",
"0.63934696",
"0.63933444",
"0.63713855",
"0.6368063",
"0.63627523",
"0.6331519",
"0.629701",
"0.62892914",
"0.6222453"... | 0.0 | -1 |
Creates a new Database object. | def __init__(self, connect: str):
# create engine
self._engine = create_engine(connect)
self._engine.echo = False
event.listen(self._engine, 'checkout', Database._checkout_listener)
# and metadata
MetaData(self._engine)
# and session
self._session = ses... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_database(self, instance, **attrs):\n instance = self._get_resource(_instance.Instance, instance)\n return self._create(\n _database.Database, instance_id=instance.id, **attrs\n )",
"def _create_db(self):\n self.db = easydms.dbcore.Database(\":memory:\")\n ... | [
"0.81012857",
"0.7803342",
"0.7645763",
"0.76455563",
"0.7597918",
"0.7513874",
"0.7509577",
"0.7494454",
"0.748972",
"0.74859154",
"0.7480001",
"0.74596536",
"0.7434891",
"0.7428196",
"0.7428196",
"0.7428196",
"0.7428196",
"0.7428196",
"0.7428196",
"0.7428196",
"0.7428196",
... | 0.0 | -1 |
Provide a transactional scope around a series of operations. | def __call__(self):
session = self._session()
try:
yield session
session.commit()
except:
session.rollback()
raise
finally:
session.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def session_scope():\n session = Session()\n try:\n yield session\n session.commit()\n except:\n session.rollback()\n raise\n finally:\n session.close()",
"def session_scope():\n session = Session()\n try:\n yield session\n session.commit()\n ... | [
"0.6569059",
"0.6569059",
"0.6569059",
"0.6485288",
"0.64705354",
"0.6458157",
"0.645436",
"0.6433442",
"0.642318",
"0.63953996",
"0.63516915",
"0.62020296",
"0.61909795",
"0.61490947",
"0.6068438",
"0.6058901",
"0.6056808",
"0.6052401",
"0.60080963",
"0.59846854",
"0.5968762... | 0.5221372 | 61 |
Save the trained vectorizer for future use. | def pickle_vectorizer(self, path='models/TFIDFVectorizer.pkl'):
with open(path, 'wb') as f:
pickle.dump(self.vectorizer, f)
print("Pickled vectorizer at {}".format(path)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_vectorizer(self, vectorizer_filepath):\n with open(vectorizer_filepath, \"w\") as fp:\n json.dump(self._vectorizer.to_serializable(), fp)",
"def save(self, tfidf_vectorizer_path):\n with open(tfidf_vectorizer_path, \"wb\") as fw:\n pickle.dump(self, fw)",
"def save_... | [
"0.76096624",
"0.73109317",
"0.7164249",
"0.70169145",
"0.66974753",
"0.6566269",
"0.6522058",
"0.64056844",
"0.63931715",
"0.6316061",
"0.6313552",
"0.6313552",
"0.6276785",
"0.62720037",
"0.623774",
"0.62127876",
"0.62069654",
"0.6184085",
"0.6171327",
"0.61685747",
"0.6127... | 0.7430699 | 1 |
Saves the trained classifier for future use. | def pickle_clf(self, path='models/SentimentClassifier.pkl'):
with open(path, 'wb') as f:
pickle.dump(self.clf, f)
print("Pickled classifier at {}".format(path)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(self):\n joblib.dump(\n self.classifier, \"data/models/badlymappedfinder/badlymappedfinder.joblib\",\n )",
"def persist_classifier(clf, X_test, y_test, pickle_file):\n joblib.dump((clf, X_test, y_test), pickle_file)",
"def save(self):\n\n try:\n joblib.dum... | [
"0.7782483",
"0.7746073",
"0.77156997",
"0.7690395",
"0.7592898",
"0.7557048",
"0.74742705",
"0.7266321",
"0.703804",
"0.7024992",
"0.7018162",
"0.7015158",
"0.69418323",
"0.69284034",
"0.6915039",
"0.6910194",
"0.69033444",
"0.68918973",
"0.6879996",
"0.6866403",
"0.6863975"... | 0.70769143 | 8 |
Plot the ROC curve for X_test and y_test. | def plot_roc(self, X, y):
plot_roc(self.clf, X, y) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_roc(model, X_test, Y_test, verbose=False):\n\n y_true, y_pred = Y_test, model.predict(X_test)\n if verbose:\n print(\"CLASSIFICATION REPORT\")\n print(classification_report(y_true, y_pred))\n\n y_pred_prob = model.predict_proba(X_test)[:,1]\n\n fpr, tpr, _ = roc_curve(Y_test, y_p... | [
"0.81790066",
"0.80277777",
"0.7994181",
"0.7877366",
"0.7686142",
"0.7684883",
"0.7512397",
"0.7383684",
"0.73271465",
"0.7208472",
"0.71124506",
"0.70799464",
"0.7026591",
"0.7016241",
"0.70149523",
"0.6978569",
"0.6914532",
"0.69139344",
"0.6845855",
"0.6833893",
"0.683278... | 0.75754845 | 6 |
Constructor method. Receives the reference to the Blender object. The second parameter should be the name of the object's parent. | def __init__(self, obj, parent=None):
logger.info('%s initialization' % obj.name)
# Call the constructor of the parent class
super(self.__class__,self).__init__(obj, parent)
self.local_data['x'] = 0.0
self.local_data['y'] = 0.0
self.local_data['z'] = 0.0
self.loc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, parent):\n self._parent = parent",
"def __init__(self, parent):\n pass",
"def __init__(self, parent):\n pass",
"def __init__(self, parent):\n pass",
"def __init__(self, blend_src, blend_dest, program, parent=None):\n super().__init__(parent=parent)\n s... | [
"0.69186753",
"0.6701193",
"0.6701193",
"0.6701193",
"0.6657898",
"0.6657543",
"0.66375124",
"0.65814894",
"0.6467207",
"0.6345175",
"0.62218726",
"0.6141906",
"0.61244076",
"0.6069659",
"0.6056966",
"0.6054012",
"0.6052897",
"0.6051803",
"0.6018489",
"0.5998511",
"0.5991595"... | 0.60681015 | 14 |
Get the x, y, z, yaw, pitch and roll of the blender object. | def default_action(self):
x = self.position_3d.x
y = self.position_3d.y
z = self.position_3d.z
yaw = self.position_3d.yaw
pitch = self.position_3d.pitch
roll = self.position_3d.roll
# Gather information about all segments of the kuka-arm
self._segments = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getAngles(self) -> tuple:\n return self.getHeading(), self.getPitch(), self.getRoll()",
"def get_draw_data(self):\n x, y = self._coordinates\n return x, y, self.__heading",
"def get_pos_and_orientation(self):\n pos, rot = p.getBasePositionAndOrientation(self.pybullet_id)\n ... | [
"0.63418734",
"0.6309489",
"0.6254961",
"0.6254961",
"0.6254961",
"0.6217224",
"0.60536915",
"0.6044034",
"0.6017542",
"0.6001574",
"0.5949086",
"0.5943164",
"0.58633053",
"0.58633053",
"0.58574796",
"0.58550453",
"0.5844058",
"0.5816276",
"0.58038104",
"0.576194",
"0.5691996... | 0.0 | -1 |
Set up a log pointing at the specified path. | def setup_logging(log_dir: Optional[str] = None) -> None:
config: Dict[str, Any] = {
"version": 1,
"disable_existing_loggers": True,
"formatters": {"console": {"format": "%(asctime)s:\t%(message)s"}},
"handlers": {
"console": {
"level": "WARNING",
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setPath(logPath):\n GlobalLogger.logger.close()\n GlobalLogger.logger = FileLogger(logPath)",
"def init_log(path):\n file = open(path, 'w+')\n file.close()",
"def init_logger():\n logpath = Path(f\"logs/{time.strftime('%Y.%m.%d %H:%M')}.txt\")\n logpath.parent.mkdir(exist_ok=True)... | [
"0.72605616",
"0.72503996",
"0.7160252",
"0.7023683",
"0.697959",
"0.6869867",
"0.6845562",
"0.67412263",
"0.66890514",
"0.66244304",
"0.65874594",
"0.65680945",
"0.6566808",
"0.65642315",
"0.6563256",
"0.655342",
"0.65409786",
"0.6536974",
"0.6524947",
"0.6515317",
"0.651353... | 0.6125873 | 67 |
Initializes the object using the list of technology dictionaries that are copied and formatted. Takes an optional parameter for the datetime.date object of the last full BuiltWith scan. | def __init__(self, technologies_list, last_full_builtwith_scan_date=None):
self._technologies_by_name = {}
for technologies_dict in technologies_list:
copied_technologies_dict = copy.deepcopy(technologies_dict)
for name in DATETIME_INFORMATION_NAMES:
copied_te... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(\n self, datetime,\n provider, asset_license,\n ext_properties\n ):\n self.ext_properties = ext_properties\n self.license = asset_license\n self.provider = provider\n self.datetime = datetime",
"def __init__(self, *args):\n this = _libsbml.n... | [
"0.58997256",
"0.58272433",
"0.57844007",
"0.5710227",
"0.55624354",
"0.55044675",
"0.5499629",
"0.5475405",
"0.541306",
"0.5392969",
"0.53880745",
"0.53873634",
"0.5373261",
"0.53632164",
"0.53545606",
"0.5312174",
"0.5298981",
"0.52789253",
"0.52789253",
"0.52765673",
"0.52... | 0.7597779 | 0 |
Initialize the client. Requires a BuiltWith API key. Optionally takes in the API version. If no API version is specified, a default of `12` is used. | def __init__(self, key, api_version=12):
if api_version not in ENDPOINTS_BY_API_VERSION.keys():
raise UnsupportedApiVersion(VERSION_EXCEPTION_TEMPLATE % api_version)
self.key = key
self.api_version = api_version | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, client_id: str, client_secret: str,\n x_api_key: str, version: str):\n super().__init__(client_id, client_secret, x_api_key, version)",
"def __init__(self, app_key=None, app_sid=None, base_url=None,\n api_version=None, debug=False, proxy=None):\n c... | [
"0.7145586",
"0.70431364",
"0.6840511",
"0.6745353",
"0.6723974",
"0.67110234",
"0.66834116",
"0.6665458",
"0.661136",
"0.66090286",
"0.6545305",
"0.6392615",
"0.631137",
"0.62908876",
"0.62697035",
"0.6265824",
"0.6171141",
"0.61463577",
"0.61458045",
"0.61331064",
"0.611292... | 0.68917906 | 2 |
Lookup BuiltWith results for the given domain. If API version 2 is used and the get_last_full_query flag enabled, it also queries for the date of the last full BuiltWith scan. | def lookup(self, domain, get_last_full_query=True):
data = {}
try:
last_full_builtwith_scan_date = None
if self.api_version == 7 and isinstance(domain, list):
domain = ','.join(domain)
if self.api_version in [2, 7]:
last_updates_r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _query(self, mapping, from_date=None, to_date=None, max_count=None,\n offset=None, ascendingly=True, describe=False):\n group, key = mapping.data_var.split(self._data_var_separator)\n\n # build params\n params = 'describe={describe}&keys={key}'.format(describe=str(describe).l... | [
"0.5364037",
"0.5217802",
"0.5124252",
"0.5091811",
"0.50653636",
"0.5045531",
"0.50369877",
"0.49869594",
"0.49551797",
"0.48993677",
"0.48925823",
"0.4868528",
"0.48650628",
"0.48334965",
"0.48261112",
"0.4820986",
"0.47899625",
"0.47878402",
"0.4784079",
"0.47710827",
"0.4... | 0.80236036 | 0 |
Get link to next higher level. If a course has only on lesson directly linked, skip this single lesson. | def get_parent_link(lesson, course_id):
if lesson.is_root_node():
parent_link = "/gui/course/{}/".format(course_id)
else:
parent = lesson.get_ancestors(ascending=True, include_self=False)[0]
root_ids = get_root_lesson_ids(course_id)
if lesson.id in root_ids:
parent_li... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def next_link(self) -> Optional[str]:\n return pulumi.get(self, \"next_link\")",
"def next_link(self) -> str:\n return pulumi.get(self, \"next_link\")",
"def get_first_lesson(module):\n try:\n return get_all_lessons(module)[0]\n except IndexError:\n return None",
"def get_ne... | [
"0.6164992",
"0.5971488",
"0.5667383",
"0.56460345",
"0.56393325",
"0.558493",
"0.55271924",
"0.5500582",
"0.54652554",
"0.54140425",
"0.5357131",
"0.53281605",
"0.52977896",
"0.52976936",
"0.52245253",
"0.5188574",
"0.51845276",
"0.5183087",
"0.5172216",
"0.51708794",
"0.517... | 0.58739734 | 2 |
Does this lesson or any of its descendants need feedback? 0 = no feedback required 1 = feedback not yet provided 2 = feedback provided | def needs_feedback(lesson, course_id):
descendants = lesson.get_descendants(include_self=True)
provided = False
for descendant in descendants:
if descendant.feedback_required:
# If feedback is needed, check if already provided
try:
# pylint: disable=E1101
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def should_ask_if_examiner_want_to_give_another_chance(self):\n if self.assignment.is_electronic:\n return (self.delivery_status == \"corrected\" and not self.feedback.is_passing_grade) \\\n or self.delivery_status == 'closed-without-feedback'\n else:\n return Fal... | [
"0.6186025",
"0.61752695",
"0.61344266",
"0.5998169",
"0.59937",
"0.5966056",
"0.58796865",
"0.5829263",
"0.58252865",
"0.56954336",
"0.56225294",
"0.555234",
"0.55216324",
"0.5501553",
"0.54851127",
"0.5417297",
"0.5385953",
"0.5377694",
"0.5376452",
"0.53695625",
"0.5365726... | 0.7998184 | 0 |
Get plain list of root lessons for user. If there is only one root node, its children will be returned directly. | def get_root_lesson_ids(course_id):
# pylint: disable=E1101
lesson_id_list = (CourseLesson.objects.filter(course=course_id)
.values_list('lesson', flat=True))
if (len(lesson_id_list) == 1 and Lesson.objects
.get(id=lesson_id_list[0])
.get_children()):
# ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_lessons(module) -> list:\n from core.models import DetailPage, TopicPage\n\n return [\n lesson\n for lesson in DetailPage.objects.live().specific().descendant_of(module)\n if isinstance(lesson.get_parent().specific, TopicPage)\n ]",
"def get_rootnodes(self) -> List[RootN... | [
"0.58202595",
"0.56926495",
"0.54621065",
"0.5372502",
"0.52808326",
"0.5260657",
"0.5136428",
"0.5116993",
"0.50672156",
"0.503656",
"0.5033046",
"0.5016807",
"0.4999171",
"0.49898365",
"0.49669686",
"0.49460587",
"0.49320826",
"0.4929504",
"0.4919603",
"0.48899287",
"0.4887... | 0.567087 | 2 |
Get meta information about a lesson | def get_lesson_meta(lesson_id):
# pylint: disable=E1101
lesson_meta_list = (LessonMetaData.objects.filter(lesson=lesson_id)
.prefetch_related())
result = []
for item in lesson_meta_list:
result.append({
'description': item.description.description,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def showLesson(self):\n lesson = \"\"\n lesson += self.__title + \"\\n\\n\"\n lesson += self.__description + \"\\n\"\n lesson += self.__lesson_text + \"\\n\"\n lesson += self.getLink()\n return lesson",
"def meta(id):\n db = core.connect()\n return db[id][\"meta\"]... | [
"0.6347282",
"0.63374656",
"0.6238976",
"0.6156013",
"0.6148112",
"0.61196655",
"0.6065378",
"0.58501846",
"0.5849513",
"0.58236367",
"0.58219254",
"0.5817728",
"0.5810855",
"0.5797458",
"0.57406706",
"0.5716694",
"0.5701135",
"0.5665865",
"0.564084",
"0.56000566",
"0.5573098... | 0.6979437 | 0 |
Get attachments for a lesson | def get_lesson_attachments(lesson_id):
# pylint: disable=E1101
lesson_attachments = Attachment.objects.filter(lesson=lesson_id)
result = []
for attachment in lesson_attachments:
url = attachment.attached_file.url
result.append({'title': attachment.title,
'url': url... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_attachments(self, expense_id):\n return self._get_request({}, Expenses.GET_EXPENSE_ATTACHMENTS.format(expense_id))",
"def attachments(self):\n return self._attachments",
"def attachments(self):\n return self.properties.get('attachments',\n Attachme... | [
"0.6443785",
"0.62607515",
"0.6257542",
"0.61732197",
"0.613358",
"0.60169816",
"0.5984727",
"0.5975392",
"0.59665823",
"0.589185",
"0.58910084",
"0.582533",
"0.5795188",
"0.57261866",
"0.57246155",
"0.56012267",
"0.5595344",
"0.5585614",
"0.55696243",
"0.5561719",
"0.5546192... | 0.7814485 | 0 |
Get list of lessons. If lesson_id is provided, then sublessons will be returned. | def get_lessons(course_id, lesson=None):
lesson_list = []
if lesson is None:
lesson_list = Lesson.objects.filter(
id__in=get_root_lesson_ids(course_id))
else:
lesson_list = lesson.get_children()
result = []
for lesson_item in lesson_list:
result.append({
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_lessons(lesson_id):\n url = '{0}?cat={1}'.format(BASE_URL, lesson_id)\n page = requests.get(url, verify=False)\n soup = BeautifulSoup(page.content)\n output = []\n\n for item in soup.find(id='playlist').findAll('dd'):\n video_id = item.find('a')['href'].split('=')[-1]\n title =... | [
"0.7365375",
"0.62064546",
"0.61165404",
"0.6037979",
"0.5811342",
"0.5567336",
"0.53809226",
"0.52577466",
"0.52528167",
"0.5149042",
"0.5014981",
"0.49820638",
"0.4955708",
"0.4920301",
"0.48846543",
"0.48611218",
"0.4850564",
"0.4735443",
"0.4732919",
"0.4681646",
"0.46596... | 0.7905289 | 0 |
Get a CSRF token | def get_token(request: http.Request) -> str:
if hasattr(request, '_csrf_hook'):
return request._csrf_hook.get_token() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_csrf_token(self):\n return get_csrf_token(self.REQUEST)",
"def get_csrf(self):\n rv = self.app.get('/')\n soup = BeautifulSoup(rv.data, 'html.parser')\n tag = soup.body.find('input', attrs = { 'name' : '_csrf_token'})\n return tag['value']",
"def get_csrf_token():\n\t... | [
"0.82945985",
"0.79842544",
"0.7978851",
"0.7901868",
"0.7893529",
"0.7813759",
"0.7686076",
"0.76118195",
"0.7603423",
"0.7520915",
"0.7415232",
"0.73648924",
"0.73442954",
"0.7296101",
"0.72825855",
"0.72396684",
"0.7208785",
"0.71859497",
"0.71636873",
"0.7134267",
"0.7123... | 0.825222 | 1 |
Change the CSRF token in use for a request should be done on login for security purposes. | def rotate_token(request: http.Request):
if hasattr(request, '_csrf_hook'):
request._csrf_hook.rotate_token() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def retain_csrf_token(req):\n session = req.environ.get('rex.session', {})\n csrf_token = session.get('_csrf_token')\n if not csrf_token:\n csrf_token = session['_csrf_token'] = b2a(os.urandom(16))\n return csrf_token",
"def _request_csrf_token(self, params):\n if params.get(\"action\")... | [
"0.6995657",
"0.6735495",
"0.66707176",
"0.66646796",
"0.6627224",
"0.66243565",
"0.6588753",
"0.6564125",
"0.64893675",
"0.64175296",
"0.6354996",
"0.6351722",
"0.6298024",
"0.6286042",
"0.626467",
"0.62383574",
"0.62116677",
"0.61504555",
"0.6089741",
"0.6089741",
"0.606432... | 0.7636964 | 0 |
Nothing needed (no learnable weights). | def build(self, input_shape):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def learn(self):\n pass",
"def learn(self):\n pass",
"def weights(self):\r\n\t\treturn None",
"def train(self)->None:",
"def _initialize_weights(self):\n pass",
"def learn(self):\n raise NotImplementedError()",
"def learn(self):\n raise NotImplementedError",
"def __... | [
"0.7334947",
"0.7334947",
"0.714452",
"0.708103",
"0.7016172",
"0.6954542",
"0.6946821",
"0.69315475",
"0.6878738",
"0.6826828",
"0.6826828",
"0.6826828",
"0.6826828",
"0.6826828",
"0.6802039",
"0.67840093",
"0.6762436",
"0.67506826",
"0.6693124",
"0.6679761",
"0.6647613",
... | 0.0 | -1 |
Output tensor shape produced by this layer. | def get_output_shape_for(self, input_shape):
# Extract nodes and membership
atom_features_shape = input_shape[0]
# membership_shape = input_shape[2]
# assert (len(atom_features_shape) == 2,
# "GraphGather only takes 2 dimensional tensors")
n_feat = atom_features_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def output_shape(self) ->torch.Size:\n return self._computed_output_shape()",
"def get_output_shape(self):\n return self.shape",
"def output_shape(self):\n raise NotImplementedError",
"def get_output_shape(self):\n return self.output_shape",
"def get_output_shape(self):\n ... | [
"0.86315733",
"0.8435825",
"0.83928627",
"0.8357466",
"0.8357466",
"0.8357466",
"0.8357466",
"0.8357466",
"0.79433477",
"0.7875424",
"0.78421944",
"0.78421944",
"0.78421944",
"0.7797612",
"0.7794071",
"0.7794071",
"0.7794071",
"0.76682436",
"0.76367337",
"0.76367337",
"0.7632... | 0.0 | -1 |
decorator to coerce a generator to a list | def listify(gen: Callable[..., Union[Generator[T, None, None], AsyncGenerator[T, None]]]) -> Callable[..., List[T]]:
if inspect.isasyncgenfunction(gen):
@wraps(gen)
async def list_func(*args, **kwargs) -> List[Any]:
return [v async for v in gen(*args, **kwargs)]
elif inspect.isgene... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def as_list(gen):\n return list(gen())",
"def to_list():\n\n @sinks\n def _dagpype_internal_fn_act(target):\n l = []\n try:\n while True:\n l.append((yield))\n except GeneratorExit:\n target.send(l) \n target.close()\n\n return _... | [
"0.7745299",
"0.69110525",
"0.6902051",
"0.6683275",
"0.6664674",
"0.65476835",
"0.639381",
"0.63147944",
"0.6306718",
"0.6297463",
"0.628525",
"0.62602025",
"0.62131625",
"0.6202488",
"0.6202488",
"0.6105673",
"0.60810256",
"0.6071712",
"0.6050292",
"0.60284764",
"0.5994327"... | 0.70440924 | 1 |
Creates & initiliazes env var object along with path list | def __init__(self, name):
self.name = name
self.val = os.getenv(name)
if self.val != None:
self.path_list = self.val.split(':')
else:
os.environ[name] = name # create a new env variable
self.path_list = [] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_env_variables(self):\n raise NotImplementedError()",
"def _init_env_variables(self):\n raise NotImplementedError()",
"def _init_env_variables(self):\n raise NotImplementedError()",
"def _init_env_variables(self):\n raise NotImplementedError()",
"def _init_env_variables... | [
"0.7017334",
"0.7017334",
"0.7017334",
"0.7017334",
"0.7017334",
"0.7017334",
"0.69044834",
"0.6690147",
"0.6647359",
"0.65812254",
"0.6556931",
"0.6527983",
"0.64512664",
"0.64258677",
"0.64214504",
"0.64065105",
"0.6383125",
"0.63800716",
"0.63728327",
"0.6372154",
"0.63580... | 0.69927865 | 6 |
Inserts path into current variable into beginning(0) by default but could be at end (1) or any other position | def padd(self, path, pos=0):
path = os.path.normpath(path) # remove double slashes and stuff
if path in self.path_list:
print(path, "already exists. Not appending to ", self.name)
elif os.path.exists(path):
self.path_list.insert(pos, path)
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _path_insert(previous, value):\n prefix = (value,)\n suffix = filter(None, previous.split(os.pathsep))\n return os.pathsep.join(_unique(itertools.chain(prefix, suffix)))",
"def prepend_path(path, paths):\n\n if path in paths: paths.remove(path)\n paths.insert(0, path)",
"def insertIntoPath(origi... | [
"0.663621",
"0.6562241",
"0.6221099",
"0.59981805",
"0.59750736",
"0.58214045",
"0.57711285",
"0.57120967",
"0.5685242",
"0.5645641",
"0.5631411",
"0.5630229",
"0.56162155",
"0.55902374",
"0.556333",
"0.553749",
"0.551732",
"0.551529",
"0.55131227",
"0.54983574",
"0.5494282",... | 0.5247273 | 33 |
Just lists out paths in env variable, one per line | def plist(self):
if self.val == None:
print("No such env variable ", self.val, " exists!")
else:
print("Listing for ", self.name)
for p in self.path_list: print(" ", p) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def path_list():\n return (os.environ.get(\"PATH\", None) or os.defpath).split(os.pathsep)",
"def show_envs(path: Optional[Path] = None):\n path = path or WORKON_HOME or Path.cwd()\n for name, path in sorted(find_environment_folders(path=path, verbose=1)):\n terminal.echo(f'Found {terminal.ye... | [
"0.69197834",
"0.6629572",
"0.6248786",
"0.62064815",
"0.61731195",
"0.61621183",
"0.6069602",
"0.6014116",
"0.5922058",
"0.58610016",
"0.58253425",
"0.58037055",
"0.5796449",
"0.57708263",
"0.576808",
"0.5671742",
"0.56449497",
"0.5635968",
"0.5635968",
"0.5558531",
"0.55343... | 0.6816062 | 1 |
Cleans up path to remove dead directories, duplicates, etc. | def pclean(self):
path_list_pruned = []
for p in self.path_list:
if not os.path.exists(p):
print("Does not exist! ", p)
elif p in path_list_pruned:
print("Duplicate found ", p)
else:
p = os.path.normpath(p) # remov... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean_path(path):\n return resolved_path(path)",
"def _cleanup_path(path):\n return string.join(filter(None, string.split(path, '/')), '/')",
"def clean_path(file_path):\n\n pass",
"def clean(path=None):\n conf.load(path)\n logger.info('cleaning output...')\n helpers.rmdir(conf.get('build... | [
"0.76485467",
"0.74771315",
"0.74742633",
"0.7472538",
"0.73666084",
"0.7118773",
"0.70741445",
"0.69812334",
"0.6940394",
"0.6913102",
"0.6856391",
"0.6856364",
"0.684552",
"0.68346214",
"0.68136364",
"0.67961645",
"0.67751765",
"0.67751765",
"0.67677987",
"0.66886914",
"0.6... | 0.69657755 | 8 |
Removes all occurences of path from env variable | def premove(self, path):
path = os.path.normpath(path) # remove double slashes and stuff
if path not in self.path_list:
print("Not found in path list! ", path)
else:
print("Removing ", path, " from env var ", self.name)
while path in self.path_list: #... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def deletePathFromEnv(self, key):\n while self.envExists(key):\n path = self.envGet(key)\n self.prefab.core.dir_remove(path)\n self.envDelete(key)",
"def clean_env():\n for key in ['FOO', 'THOR', 'IRON', 'NAME', 'PERSONAL_DIR']:\n os.environ.pop(key, None)",
"d... | [
"0.7498703",
"0.7304751",
"0.69883406",
"0.66856515",
"0.6464137",
"0.6400526",
"0.63484174",
"0.63416725",
"0.6302538",
"0.628006",
"0.6257412",
"0.6185557",
"0.6181752",
"0.61598164",
"0.6138941",
"0.6136912",
"0.61135036",
"0.61036617",
"0.61017025",
"0.60534555",
"0.60534... | 0.6544437 | 4 |
Updates the internal env val to ensure path_list & val are insync | def pupdate(self):
try:
tmp = self.path_list[0]
except IndexError:
print("Empty value for env variable ", self.name)
return
for p in self.path_list[1:]:
tmp = tmp + ':' + p
self.val = tmp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, env_obj):\n if env_obj:\n if isinstance(env_obj, EnvValues):\n for package_name, env_vars in env_obj.data.items():\n for name, value in env_vars.items():\n if isinstance(value, list):\n value = co... | [
"0.62745166",
"0.59792364",
"0.5785462",
"0.5765213",
"0.5754156",
"0.56319785",
"0.5602906",
"0.55717754",
"0.5535034",
"0.5533392",
"0.5532169",
"0.55176127",
"0.5516329",
"0.549734",
"0.5485281",
"0.54776955",
"0.54740787",
"0.54621756",
"0.5461831",
"0.5431891",
"0.543187... | 0.7859146 | 0 |
Writes out sanitized or new path list to file for sourcing | def pwrite(self):
shell = os.getenv('SHELL')
if shell == None: # assume bash or ksh
shell = 'bash'
else:
shell = os.path.basename(shell)
fname = '/tmp/source_' + os.environ['USER'] # get login id of current user
try:
fid = open(fname, 'w'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sanitize_paths(self):\n\n for wadfile in self.files:\n if wadfile.path:\n path, filename = os.path.split(wadfile.path)\n if len(filename) < 255:\n continue\n\n basename, ext = os.path.splitext(filename)\n wadfile.p... | [
"0.6192476",
"0.61592525",
"0.6130787",
"0.604309",
"0.5877469",
"0.5852279",
"0.58451945",
"0.584018",
"0.5819745",
"0.5788973",
"0.5784694",
"0.57155025",
"0.57137495",
"0.5705489",
"0.56855375",
"0.5685184",
"0.56787026",
"0.5648103",
"0.5627648",
"0.5612862",
"0.5598941",... | 0.0 | -1 |
Process options based on legal operations & subcommands Return sanitized cmds and arguments | def process_options(args):
subcmds = dict() # each key(cmd) can take on a val of 0, or 1
subcmds_wo_arg = [ 'clean', 'list' ]
subcmds_with_args = [ 'add', 'remove' ]
for cmd in subcmds_wo_arg:
subcmds[cmd] = 0
for cmd in subcmds_with_args:
subcmds[cmd] = 1
if (len(args) == 0)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_run_options(self, cmdp, exec_engine=None):\n cmdp.declare_options(\"-v= -e= -w= -u= -p= -i -t -a -P\")\n cmd_options = {\n \"netcoop\": {\n \"fl\": (\"-P\", \"--publish-all\", \"--netcoop\",), \"act\": \"R\",\n \"p2\": \"CMD_OPT\", \"p3\": False\n ... | [
"0.68020016",
"0.6262761",
"0.6206423",
"0.6184919",
"0.6182061",
"0.6162515",
"0.6088291",
"0.6074992",
"0.6049868",
"0.60402685",
"0.60306376",
"0.6025602",
"0.60253805",
"0.6003726",
"0.59915304",
"0.59439254",
"0.5930587",
"0.5928856",
"0.59242874",
"0.59233814",
"0.59226... | 0.71814495 | 0 |
Tests out operation of utils with sample commands and strings | def test():
# usage()
path_obj = Env('PATH')
path_obj.pclean()
path_obj.padd('/home/mahmud/downloads///')
path_obj.padd('/home/mahmud/apps//', -1)
path_obj.premove('/abcd')
path_obj.premove('/cad/tools/platform/lsf/7.0/linux2.6-glibc2.3-x86_64/etc')
path_obj.premove('/cad/tools/platform/... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_multiple_commands_at_same_time(self):",
"def test_cli_string():\n cmd = get_cli_string()\n assert \"pytest\" in cmd",
"def helper_commands():\n # Test HELP\n try:\n check = check50.run(run_command).stdin(\"HELP\")\n for help in help_statement:\n check.stdout(help)\... | [
"0.7079813",
"0.70298725",
"0.6950176",
"0.67688835",
"0.671888",
"0.66877896",
"0.66844237",
"0.66413546",
"0.66393304",
"0.6611795",
"0.6599124",
"0.6524412",
"0.6513141",
"0.6493118",
"0.6476011",
"0.6475439",
"0.64677346",
"0.64521146",
"0.64225674",
"0.6415802",
"0.63882... | 0.0 | -1 |
Handle argument options, create env object, and perform operations | def main():
sys.argv.pop(0)
(cmd, var, args) = process_options(sys.argv[:])
execute(cmd, var, args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialise(self, args, environ):",
"def create_environment(args):\n env.username = args.user\n env.password = args.password\n env.service_url = args.service_url\n env.quiet = args.quiet\n env.verbose = args.verbose\n env.manifest = args.manifest\n env.debug = args.debug\n env.always_c... | [
"0.67690766",
"0.6507964",
"0.6471874",
"0.62918115",
"0.6101134",
"0.6062348",
"0.6043099",
"0.6033953",
"0.60332215",
"0.6025298",
"0.60152006",
"0.5989431",
"0.59839684",
"0.597561",
"0.5971104",
"0.59697014",
"0.5960937",
"0.5931457",
"0.5898263",
"0.5891475",
"0.5873876"... | 0.596053 | 17 |
Handle multiple requests each expected to be a 4byte length, followed by the LogRecord in pickle format. Logs the record according to whatever policy is configured locally. | def handle(self):
while True:
chunk = self.connection.recv(4)
if len(chunk) < 4:
break
slen = struct.unpack('>L', chunk)[0]
chunk = self.connection.recv(slen)
while len(chunk) < slen:
chunk = chunk + self.connection.recv... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handle(self):\n while True:\n try:\n chunk = self.connection.recv(4)\n if len(chunk) < 4:\n break\n slen = struct.unpack(\">L\", chunk)[0]\n chunk = self.connection.recv(slen)\n while len(chunk) < sl... | [
"0.642383",
"0.6383582",
"0.6285302",
"0.62784356",
"0.6121849",
"0.6010063",
"0.5838576",
"0.55765617",
"0.55357414",
"0.55147916",
"0.54627067",
"0.5431377",
"0.5374189",
"0.53549516",
"0.5341674",
"0.5333902",
"0.53018004",
"0.52858895",
"0.52804816",
"0.52658737",
"0.5244... | 0.6399498 | 1 |
The standard inorder traversal of a binary tree. | def __iter__(self):
if self:
if self.hasLeftChild():
for elem in self.leftChild:
yield elem
yield self.key
if self.hasRightChild():
for elem in self.rightChild:
yield elem | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inorder_traversal(root, inorder):\r\n if root is None:\r\n return\r\n\r\n inorder_traversal(root.left, inorder)\r\n inorder.append(root.val)\r\n inorder_traversal(root.right, inorder)\r\n return inorder",
"def in_order_traversal(self):\n root = self.root\n self.traverse = ... | [
"0.8041937",
"0.79388064",
"0.786354",
"0.7772449",
"0.7752841",
"0.7664082",
"0.7660861",
"0.7654784",
"0.7539193",
"0.74186796",
"0.73315924",
"0.7330442",
"0.73297083",
"0.7257317",
"0.71613365",
"0.716095",
"0.71396977",
"0.711913",
"0.7111722",
"0.71086997",
"0.7082096",... | 0.0 | -1 |
Parse command line arguments. | def build_argparser():
parser = ArgumentParser()
parser.add_argument("-m", "--model", required=True, type=str,
help="Path to an xml file with a trained model.")
parser.add_argument("-i", "--input", required=True, type=str,
help="Path to image or video file")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_arguments(args):",
"def parse_command_line(self, argv):\n from optparse import OptionParser\n usage = \"usage: %prog [options]\"\n parser = OptionParser(usage)\n\n (options, args) = parser.parse_args(argv)",
"def parseArguments(self):\n iterator = iter(sys.argv[1:])... | [
"0.807208",
"0.74767",
"0.73985106",
"0.73932225",
"0.73173845",
"0.72599804",
"0.7232453",
"0.7222555",
"0.713585",
"0.7102058",
"0.71020466",
"0.7096281",
"0.7093058",
"0.70890576",
"0.7080071",
"0.70745754",
"0.70641047",
"0.70633066",
"0.70568484",
"0.7051162",
"0.7048470... | 0.0 | -1 |
Initialize the inference network, stream video to network, and output stats and video. | def infer_on_stream(args, client):
count_current = 0
count_last = 0
count_last_last = 0
total_count = 0
duration = 0
avg_duration = 0
total_duration = 0
start_time = 0
active_person = 0
net_input_shape = []
frame_count = 0
# Initialise the class
infer_network = Netwo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def infer_on_stream(args, client):\n # Initialise the class\n infer_network = Network()\n # Set Probability threshold for detections\n prob_threshold = args.prob_threshold\n\n ### TODO: Load the model through `infer_network` ###\n infer_network.load_model(args.model,args.cpu_extension,args.device... | [
"0.6824933",
"0.66583",
"0.66199523",
"0.6584647",
"0.6472856",
"0.62965333",
"0.6275877",
"0.621905",
"0.61590046",
"0.59710425",
"0.59633476",
"0.5932169",
"0.5894218",
"0.5885044",
"0.5830741",
"0.5784014",
"0.57677317",
"0.5767166",
"0.57534164",
"0.5725565",
"0.5706836",... | 0.6654395 | 2 |
Load the network and parse the output. | def main():
# Grab command line args
args = build_argparser().parse_args()
#print("finished argparser")
# Connect to the MQTT server
client = connect_mqtt()
#print("finished mqtt connect")
# Perform inference on the input stream
infer_on_stream(args, client) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_network(self):\t\t\r\n\t\tself.dqn.load_network(self.path)",
"def __load_Model(self):\r\n PrintsForUser.printProcess(\"[INFO] Loading network...\")\r\n \r\n self.__model = load_model(self.__model_path)\r\n self.__lb = pickle.loads(open(self.__labels_path, \"rb\").read())",
... | [
"0.7355958",
"0.6594214",
"0.65300447",
"0.64435625",
"0.6269429",
"0.6132971",
"0.606932",
"0.5980821",
"0.5932085",
"0.5918037",
"0.591396",
"0.59083337",
"0.59021485",
"0.58683854",
"0.585857",
"0.5845249",
"0.5842063",
"0.5813572",
"0.57925004",
"0.5786059",
"0.5769666",
... | 0.0 | -1 |
Plot mesh triangles on a given surface | def plotMesh(verts,tris):
x = verts[:,0]
y = verts[:,1]
plt.figure()
plt.gca().set_aspect('equal')
plt.triplot(x, y, tris, 'k-')
plt.title('Unstructured Mesh')
plt.xlabel('distance (m)')
plt.ylabel('distance (m)') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def DisplayMesh():\r\n \r\n # Load Surface Mesh Data and generate normals\r\n VTKString = OpenData('C:/Users/Tim/Documents/University/Year 4/Final Project/FinalYearProjectCode/TEH_Code/InputFiles','muscle_surface.vtk')\r\n header, Vertices, Triangles = CreateMatrixVTK(VTKString)\r\n \r\n fig = pl... | [
"0.7586179",
"0.73376596",
"0.7131",
"0.68556476",
"0.67790115",
"0.670109",
"0.66954625",
"0.643024",
"0.63897085",
"0.6355384",
"0.6306112",
"0.62642723",
"0.62621355",
"0.62500685",
"0.6235236",
"0.62293386",
"0.6221899",
"0.62194383",
"0.6191307",
"0.6178185",
"0.6175373"... | 0.75149196 | 1 |
Scatter plot of displacements at nodes coords = 0=x,1=y,2=z | def plotScatter(verts, data, coords=(1,2), comp=2):
z = data[:,:,comp].flatten()
x = verts[:,coords[0]]
y = verts[:,coords[1]]
# NOTE: either scatter or pcolor should work
plt.figure()
compDict = {0:'X',1:'Y',2:'Z'}
#plt.gca().set_aspect('equal')
plt.scatter(x, y, c=z, s=80, cmap=plt.cm... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_nodes(self,x_shift,y_shift):\n\n if not self.nodes: return # Bounce if option not selected\n\n self.ax.scatter(self.node_crds[:,0]+x_shift*self.pbc[0],self.node_crds[:,1]+y_shift*self.pbc[1],\n marker=\"o\",s=self.ms,c=self.mc,zorder=1)\n\n # for i,c in enumerat... | [
"0.6807476",
"0.64142597",
"0.62334967",
"0.6168654",
"0.6158544",
"0.60907406",
"0.5997021",
"0.5973721",
"0.59665745",
"0.5944722",
"0.59345853",
"0.59274155",
"0.5919128",
"0.5873595",
"0.58628434",
"0.582913",
"0.5811393",
"0.57778704",
"0.5768547",
"0.5741387",
"0.573808... | 0.6318569 | 2 |
Contours of surface deformation Also see matplotlib tricontour and tricontourf functions! | def plotContour(verts, data, comp=2):
z = data[:,:,comp].flatten()
x = verts[:,0]
y = verts[:,1]
xi = np.linspace(x.min(), x.max(), x.size)
yi = np.linspace(y.min(), y.max(), y.size)
zi = griddata(x,y,z, xi,yi, interp='nn') #'nn' #NOTE: for irregularly spaced data
plt.figure()
#plt.gca... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_surf():\n def f(x, y):\n sin, cos = numpy.sin, numpy.cos\n return sin(x + y) + sin(2 * x - y) + cos(3 * x + 4 * y)\n\n x, y = numpy.mgrid[-7.:7.05:0.1, -5.:5.05:0.05]\n s = surf(x, y, f)\n mlab.show()\n #cs = contour_surf(x, y, f, contour_z=0)\n return",
"def fun_contours... | [
"0.6710656",
"0.64235824",
"0.6263534",
"0.62354016",
"0.6122986",
"0.6080296",
"0.6049337",
"0.6044242",
"0.60144144",
"0.6010357",
"0.5990036",
"0.5979571",
"0.59342635",
"0.5906877",
"0.5778896",
"0.57778335",
"0.5777319",
"0.57574177",
"0.5696239",
"0.5689536",
"0.5664899... | 0.52664924 | 59 |
Plot interpolated image of surface displacements, optionally show original points | def plotSurface(surfaceFile, comp=2, points=False, tris=False,
profile=False, ax=None, annotate=True, norm=None,xscale=1, yscale=1):
verts,data,tris = load_h5(surfaceFile)
if comp==3: #radial displacements
z = np.hypot(data[:,:,0], data[:,:,1]).flatten()
else:
z = data[:,:,c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def imshow_surface(self):\n plt.imshow(self.z)\n plt.colorbar()\n plt.show()",
"def plot(model, center, extent, outname):\n # define model grid\n xg = np.linspace(-extent, extent, model.shape[0])\n yg = xg.copy()\n interp_func = RectBivariateSpline(xg, yg, model)\n\n x = np.ar... | [
"0.6518163",
"0.6399373",
"0.62921655",
"0.6148502",
"0.6133245",
"0.6123275",
"0.60479116",
"0.60328573",
"0.6023449",
"0.59941006",
"0.59833103",
"0.5982813",
"0.5928283",
"0.5919153",
"0.5898158",
"0.5881833",
"0.58795625",
"0.5879294",
"0.58704317",
"0.5856613",
"0.585542... | 0.69940144 | 0 |
Convert axes coordinates in figure to image indicies eg. 15000, 0 in figure corresponds to print tr.transform_point((15000, 0)) zi[0,0] | def imshow2array(imx,imy):
# NOTE: would be more efficient to not reconstruct 'tr' transform object every time...
# NOTE: different order comp to 'extent' keyword in imshow
bbox_in = Bbox.from_extents([x1, y1, x2, y2])
# NOTE: lower left corner always -0.5,-0.5 by deafult with imshow
bbox_out = Bbox... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def image_coordinates(self, temp):\n iy = np.array((temp.y[:,None]-self.extent[2])/self.spacing[1],dtype=np.int64)\n ix = np.array((temp.x[None,:]-self.extent[0])/self.spacing[0],dtype=np.int64)\n return (iy,ix)",
"def pos2im_coordinates(x, z):\n # x_lim = [-0.85, 0.86]\n # z_lim = [-1... | [
"0.6230919",
"0.61599123",
"0.60299486",
"0.60299486",
"0.58066416",
"0.5777637",
"0.5747643",
"0.5688933",
"0.56749",
"0.5665224",
"0.56551784",
"0.55698895",
"0.5561942",
"0.5557027",
"0.55553687",
"0.55513406",
"0.55450445",
"0.5537824",
"0.5509617",
"0.54909354",
"0.54887... | 0.5634949 | 11 |
For timedependent runs plot maximum displacements versus time | def plot_maxdisp_time(pointsh5, xscale=1e3, yscale=1e-2, tscale=3.1536e7,
adjustRadial=False):
coords,data,number,times = pu.load_h5_visco(pointsh5)
x = coords[:,0]
ur = np.hypot(data[:,:,0], data[:,:,1])
uz = data[:,:,2]
# Convert units & extract maximums for each timestep
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_displacements(ds):\n # Se obtienen una matriz de datos con los desplazamientos promedios de cada imagen\n t = ds['t']\n t = t[:n_im-1]\n t = mplt.dates.date2num(t)\n d = ds['d_t']\n \n # Se grafica la curva Desplazamientos promedios vs Tiempo\n formatter = DateFormatter(\"%d/%m - %H... | [
"0.5977297",
"0.59203607",
"0.591389",
"0.5904414",
"0.58950406",
"0.5851301",
"0.583456",
"0.5795047",
"0.5763769",
"0.57332605",
"0.569345",
"0.567947",
"0.56562036",
"0.56409806",
"0.5510336",
"0.54855245",
"0.54765123",
"0.54744595",
"0.54681593",
"0.5465856",
"0.546511",... | 0.6763449 | 0 |
Profiles of surface displacement at each timestep | def plot_visco_profiles(pointsh5, skip=slice(None,None,1), xscale=1e3, yscale=1e-2, tscale=3.1536e7, adjustRadial=False, benchmark=[], title=None):
plt.figure()
coords,data,number,times = pu.load_h5_visco(pointsh5)
#x = 1e3*np.loadtxt(points,usecols=[0]) # output_points2.txt
#y = np.zeros_like(x)
x = coords[:,0]... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_averaged_properties(poly_data, bucket):\n\n locator = vtk.vtkPointLocator()\n locator.SetDataSet(poly_data)\n locator.BuildLocator()\n\n LENGTH = 0.03\n MODIFIER = 3e3\n\n volume = numpy.zeros(poly_data.GetNumberOfPoints())\n temperature = numpy.zeros(poly_data.GetNumberOfPoints(... | [
"0.56962234",
"0.54362315",
"0.5403966",
"0.5350075",
"0.53178805",
"0.5305838",
"0.5305637",
"0.5265301",
"0.525089",
"0.5243732",
"0.5207485",
"0.51850504",
"0.5176146",
"0.5137093",
"0.5131274",
"0.5127405",
"0.5126373",
"0.51173675",
"0.51032966",
"0.5049595",
"0.501489",... | 0.0 | -1 |
Plot vertical and radial surface displacement profile if x='r', calculate radial distance from x & y | def plot_profile(outdir, xval='x', xscale=1, yscale=1, comp2los=False, adjustRadial=False,
fig=True):
#Load data
path = os.path.join(outdir,'points.h5')
x,y,z,ux,uy,uz = pu.extract_points(path)
Y = uz / yscale
if xval == 'x':
X = x / xscale
Y1 = ux / yscale
elif... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_radial(data, name, fig, piH=1):\n det = data.detectors[name]\n r = np.array([line[0] for line in det.grids['R']])\n vdetector = np.roll(r, -1)**2-r**2\n vdetector[-1] = det.grids['R'][-1][1]**2 - det.grids['R'][-1][0]**2\n vdetector *= piH/2\n\n val = det.tallies\n val = val/vdetector... | [
"0.5935579",
"0.5809302",
"0.579844",
"0.5662632",
"0.56524694",
"0.55738705",
"0.55172443",
"0.5468815",
"0.543614",
"0.536995",
"0.53637147",
"0.5336989",
"0.5335789",
"0.5332538",
"0.53319854",
"0.53096735",
"0.52983105",
"0.5291765",
"0.5290207",
"0.5274528",
"0.52724695"... | 0.54496723 | 8 |
Compare FEM output to vertical and radial displacements from inversion of multiple LOS InSAR datasets | def comp2profile(output):
# Load components
data = '/home/scott/data/insar/cvz/los2xyz/components.txt_backup'
lon,lat,x,ur,uz = np.loadtxt(data,unpack=True)
# Load FEM output
points = '/home/scott/research/models/pylith/3d/fialko2012/model3_agu/output_points.txt'
pointsh5 = '/home/scott/resear... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compare_CII_w_models(**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n if not p.xlim: p.xlim = [-4,2]\n if not p.ylim: p.ylim = [4,10]\n\n fig,ax = plt.subplots(figsize=(8,6))\n ax.set_ylim(p.ylim)\n ax.set_xlim(p.xlim)\n\n # SIGAME Si... | [
"0.6051346",
"0.5975104",
"0.59319794",
"0.58609855",
"0.58517313",
"0.5824497",
"0.5738534",
"0.5730661",
"0.57001823",
"0.5671502",
"0.5662626",
"0.56435794",
"0.5638238",
"0.56128585",
"0.56081694",
"0.56056607",
"0.55639225",
"0.5549855",
"0.554532",
"0.55445826",
"0.5529... | 0.5733137 | 7 |
Convert Pylith output to InSAR LOS and plot data, model in map view | def data_model_residual(surface, dem, unw, incidence):
los,fem_los,residual = pu.los2pylith(surface,dem,unw,incidence)
# Using image_grid
fig = plt.figure()
grid = ImageGrid(fig, 111, # similar to subplot(111)
nrows_ncols = (1, 3),
direction="row",
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_LvsL(modeldata,line1='CIV1548',line2='CIII1908',plotname='./TESTPLOT.pdf',\n Zgas=False,logU=False,xid=0.3,nh=100,COratio=0.38,Mcutoff=100,\n logx=False,logy=False,logp1=False,logp2=False,fixxrange=False,fixyrange=False,\n showobs=None,noobserr=False,verbose=True):\n... | [
"0.57275915",
"0.5662032",
"0.55496144",
"0.5544452",
"0.55086404",
"0.54077375",
"0.5395589",
"0.5380696",
"0.5337075",
"0.53228354",
"0.53110796",
"0.52550274",
"0.52178866",
"0.51859766",
"0.51779294",
"0.5175796",
"0.51676625",
"0.51582605",
"0.514516",
"0.51354164",
"0.5... | 0.0 | -1 |
Defaults setup for pressurization history | def plot_timeDB(timeDB, xunits='yr', yunits='MPa', skip=8, P0=33.0):
time, pressure = np.loadtxt(timeDB, skiprows=skip, unpack=True)
pressure = pressure * P0
#if xunits == 'yr':
# time = time / 31536000.0
#elif xunits == 'day':
# time = time / 86400.0
plt.figure()
plt.plot(time,p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def history():",
"def initialize(self):\n PostProcessorInterfaceBase.initialize(self)\n self.inputFormat = 'HistorySet'\n self.outputFormat = 'HistorySet'",
"def Modifier_History(self):\n\t\tpass",
"def __init__(self, history=None):\n\n self.__history = history if history else []",
"def on... | [
"0.61749583",
"0.61044705",
"0.5923172",
"0.56847167",
"0.5676686",
"0.56484216",
"0.56409806",
"0.5607612",
"0.5604941",
"0.5588264",
"0.55781215",
"0.5554692",
"0.55457157",
"0.55457157",
"0.55457157",
"0.55185014",
"0.550989",
"0.5501374",
"0.5485809",
"0.5464516",
"0.5439... | 0.0 | -1 |
plot results for numerical experiment folder 1) surface profiles for each parameter 2) uz_max versus parameter values 3) residual versus parameter values | def plot_directory_numex(path, vals, param='density', outname=None, show=True,
xscale=1e-3,yscale=1e2):
#vals = arange(2300.0, 2800.0, 50.0)
outdirs = np.sort(os.listdir(path))
plt.figure()
# Plot surface profiles for each parameter
for val,outdir in zip(vals,outdirs):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_directory_profiles(path, outname=None, show=True, xscale=1, yscale=1,\n xval='x', adjustRadial=True):\n outdirs = np.sort(os.listdir(path))\n plt.figure()\n\n #labels=['homogeneous','1D layering', '3D tomography'] #xscale=1e-3, yscale=1e2\n for i,outdir in enumerate(... | [
"0.66833836",
"0.66289103",
"0.6578164",
"0.6558594",
"0.65089476",
"0.65080667",
"0.6504561",
"0.6472419",
"0.64677024",
"0.6441997",
"0.63957804",
"0.63513416",
"0.6350512",
"0.6309037",
"0.62910414",
"0.6289601",
"0.6281238",
"0.6271773",
"0.6265851",
"0.6262609",
"0.62506... | 0.6415346 | 10 |
plot RMSE versus parameter value for numerical experiment RMSE is calculated based on full fem output converted to LOS | def plot_directory_surface_rmse(path, vals, param='Vp'):
unw = '/home/scott/data/insar/cvz/t2282/geo/geo_stack282_8rlks.unw'
incidence = '/home/scott/data/insar/cvz/t2282/aux_files/geo_incidence_8rlks.unw'
dem = '/home/scott/data/dems/cgiar/uturuncu_1000_1000.tif'
#surface = '/home/scott/research/model... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _plot_rmse(self, val=False):\n _, ax = plt.subplots()\n ax.plot(self.global_rmse, linewidth=3, color='blue', label='Train RMSE')\n ax.set_title('RMSE vs. Number of Iterations')\n if val is not None:\n ax.plot(self.validation_rmse, linewidth=3, color='green', label='Valida... | [
"0.7626725",
"0.708637",
"0.6610557",
"0.6603707",
"0.65582985",
"0.654513",
"0.6439415",
"0.6360636",
"0.63175553",
"0.62971836",
"0.6282147",
"0.6249508",
"0.6227701",
"0.62119347",
"0.61805004",
"0.6114414",
"0.61127007",
"0.609514",
"0.6088742",
"0.6055546",
"0.6054864",
... | 0.6174114 | 15 |
Convert scale term to unit label | def get_unit(scale):
scale2unit = { 1e-9: 'nm',
1e-6: u'\N{MICRO SIGN}m', #or hex id (lookup): u'\u00B5'
1e-3: 'mm',
0.01: 'cm',
0.1:'dm',
1:'m',
1000:'km',
# time
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def point_scale_name(self):",
"def to_axis_units(self, label, vals):\n if label in ['Hmolar', 'Smolar', 'Umolar', 'Dmolar', 'P']:\n return vals / 1000\n elif label in ['T']:\n return vals\n else:\n raise ValueError(label)",
"def labels_x(x_unit, latex = Tru... | [
"0.66115385",
"0.64944685",
"0.6276687",
"0.62619853",
"0.6258747",
"0.6168202",
"0.6106348",
"0.6104452",
"0.6032182",
"0.59474814",
"0.59472513",
"0.593621",
"0.5931593",
"0.591483",
"0.59085834",
"0.5896219",
"0.58899754",
"0.588468",
"0.58570886",
"0.5837348",
"0.5832844"... | 0.7126686 | 0 |
Plot vertical and radial profiles for specified output directories. | def compare_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2013/output',
steps=['step01','step02'],
#labels='',
show=True,
xscale=1e3,
yscale=1e-2):
plt.figure()
#path = '/Users/scott/Desktop/elastic'
# Deep source
labels = ['no APMB', 'APMB']
deep = {}
uzmax = 0.824873455364
# NOT sure why... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_directory_profiles(path, outname=None, show=True, xscale=1, yscale=1,\n xval='x', adjustRadial=True):\n outdirs = np.sort(os.listdir(path))\n plt.figure()\n\n #labels=['homogeneous','1D layering', '3D tomography'] #xscale=1e-3, yscale=1e2\n for i,outdir in enumerate(... | [
"0.77768505",
"0.69358486",
"0.6893516",
"0.6873988",
"0.6526698",
"0.6287042",
"0.62730706",
"0.61070305",
"0.6070563",
"0.6070449",
"0.5956038",
"0.5923547",
"0.5919201",
"0.5887804",
"0.5874542",
"0.5859539",
"0.58339554",
"0.5830068",
"0.58292556",
"0.5784595",
"0.5765463... | 0.0 | -1 |
Plot vertical and radial profiles for specified output directories. | def plot_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2014/output',
steps=['step01','step02'],
#labels='',
show=True,
xscale=1e3,
yscale=1e-2):
plt.figure()
#path = '/Users/scott/Desktop/elastic'
# Deep source
#labels = ['no APMB', 'APMB']
#if labels == '':
labels = steps
deep = {}
#uzma... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_directory_profiles(path, outname=None, show=True, xscale=1, yscale=1,\n xval='x', adjustRadial=True):\n outdirs = np.sort(os.listdir(path))\n plt.figure()\n\n #labels=['homogeneous','1D layering', '3D tomography'] #xscale=1e-3, yscale=1e2\n for i,outdir in enumerate(... | [
"0.77768505",
"0.69358486",
"0.6893516",
"0.6873988",
"0.6526698",
"0.62730706",
"0.61070305",
"0.6070563",
"0.6070449",
"0.5956038",
"0.5923547",
"0.5919201",
"0.5887804",
"0.5874542",
"0.5859539",
"0.58339554",
"0.5830068",
"0.58292556",
"0.5784595",
"0.5765463",
"0.5737489... | 0.6287042 | 5 |
Plot profiles for each output/step0X folder on same figure | def plot_directory_profiles(path, outname=None, show=True, xscale=1, yscale=1,
xval='x', adjustRadial=True):
outdirs = np.sort(os.listdir(path))
plt.figure()
#labels=['homogeneous','1D layering', '3D tomography'] #xscale=1e-3, yscale=1e2
for i,outdir in enumerate(outdirs):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2014/output',\n\t\t\t\tsteps=['step01','step02'],\n\t\t\t\t#labels='',\n\t\t\t\tshow=True,\n\t\t\t\txscale=1e3,\n\t\t\t\tyscale=1e-2):\n\tplt.figure()\n\t#path = '/Users/scott/Desktop/elastic'\n\n\t# Deep source\n\t#labels = ['no APMB', 'APMB']\n\t#if labels... | [
"0.68558604",
"0.6830801",
"0.682716",
"0.6536897",
"0.6412557",
"0.6166356",
"0.61190796",
"0.60816085",
"0.6074869",
"0.60712504",
"0.598796",
"0.59763676",
"0.5945832",
"0.59333724",
"0.5919523",
"0.589908",
"0.58856714",
"0.58749056",
"0.5861554",
"0.5851671",
"0.58485967... | 0.7218871 | 0 |
Plot grid of surface displacement maps from each output/step folder if normalize=True, use step01 colorbar for all images | def plot_directory_surface(path,figsize=(17,11), comp=2, nrow=1, norm=None,
cbar='each', cloc='top', outname=None, labels='1', show=True):
outdirs = np.sort(os.listdir(path))
nplots = len(outdirs)
ncol = np.ceil(nplots/nrow).astype(np.int)
fig = plt.figure(figsize=figsize)
grid = ImageGrid(fig,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def debugplots(fig,data):\n grid = AxesGrid(fig, 111, # similar to subplot(142)\n nrows_ncols=(1, 6),\n axes_pad=0.0,\n share_all=True,\n label_mode=\"L\",\n cbar_location=\"right\",\n cbar_mode=\"... | [
"0.64044726",
"0.63224024",
"0.6253856",
"0.61958474",
"0.6189722",
"0.60908437",
"0.60695",
"0.606345",
"0.6026868",
"0.6024125",
"0.5955344",
"0.5922822",
"0.5906817",
"0.58775115",
"0.58641946",
"0.58604985",
"0.5835713",
"0.5813257",
"0.5810878",
"0.580833",
"0.57819027",... | 0.703744 | 0 |
Use gdal/osr to get latlon point location from georeferenced array indices | def ind2latlon(index, filePath):
# Load georeferencing
ds = gdal.Open(filePath)
proj = ds.GetProjection()
gt = ds.GetGeoTransform()
srs = osr.SpatialReference()
srs.ImportFromWkt(proj)
x0 = gt[0] #top left longitude
y0 = gt[3] #top left latitude
dx = gt[1] #pixel width
dy = gt[5... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_coord_indices(lon_array, lat_array, lon_points, lat_points, proj_str):\n\n proj = Proj(proj_str)\n proj_lon, proj_lat = np.array(proj(lon_array, lat_array)) # transform to distances using specified projection\n lonlat = np.column_stack(\n (proj_lon.ravel(), proj_lat.ravel())) # Stack all... | [
"0.64533174",
"0.62730485",
"0.6266516",
"0.6246362",
"0.6216341",
"0.6202899",
"0.6187555",
"0.6148967",
"0.6142526",
"0.6036951",
"0.5968435",
"0.59425825",
"0.59397787",
"0.5923113",
"0.5836684",
"0.5829554",
"0.58170235",
"0.58012676",
"0.5789401",
"0.5754598",
"0.5750754... | 0.72259116 | 0 |
Plot transparent fem result on highres srt hillshade with summit and stations, etc comp=0,1,2,3 > ux, uy, uz, ur | def uturuncu_map(surfaceFile,dem,comp=2):
fig = plt.figure()
ax = fig.add_subplot(111)
#print(datadir)
#print(dem)
geosurface = pu.surface2geotiff(dem,surfaceFile,outname=None,comp=comp,nanval=-9999)
#load georeferenced fem output from pu.surface2geotiff
#geosurface = '/home/scott/research... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_Ae_HDR10_exr_nl_out_vari_prj_white(graph_name=\"./img/out.png\"):\n width = 1920\n\n fname_list = [\n \"./AfterEffects/Comp 1/prj_w_W-none _00000.exr\",\n \"./AfterEffects/Comp 1/prj_w_W-100 _00000.exr\",\n \"./AfterEffects/Comp 1/prj_w_W-203 _00000.exr\",\n \"./AfterEffe... | [
"0.668535",
"0.60801226",
"0.6054332",
"0.59788936",
"0.5932414",
"0.5875222",
"0.5846639",
"0.57671297",
"0.5711864",
"0.57099444",
"0.5647215",
"0.5645391",
"0.5641379",
"0.5634341",
"0.5630049",
"0.56289643",
"0.5628059",
"0.562422",
"0.5621892",
"0.5609679",
"0.56076366",... | 0.5718604 | 8 |
Defaults setup for pressurization history | def plot_powerlawDB(timeDB, xunits='yr', yunits='MPa', skip=8, P0=33.0):
workdir = '/home/scott/research/models/pylith/powerlaws/iavcei_diorite'
# Plot geotherm
z, T = np.loadtxt('geotherm.txt', usecols=(2,3), unpack=True)
plt.figure()
plt.plot(time,pressure,'b.-',lw=3,label='pressure')
plt.xla... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def history():",
"def initialize(self):\n PostProcessorInterfaceBase.initialize(self)\n self.inputFormat = 'HistorySet'\n self.outputFormat = 'HistorySet'",
"def Modifier_History(self):\n\t\tpass",
"def __init__(self, history=None):\n\n self.__history = history if history else []",
"def on... | [
"0.61749583",
"0.61044705",
"0.5923172",
"0.56847167",
"0.5676686",
"0.56484216",
"0.56409806",
"0.5607612",
"0.5604941",
"0.5588264",
"0.55781215",
"0.5554692",
"0.55457157",
"0.55457157",
"0.55457157",
"0.55185014",
"0.550989",
"0.5501374",
"0.5485809",
"0.5464516",
"0.5439... | 0.0 | -1 |
Plot stress contours by extracting nearest stresses resolved on a point for 4 vertices per cell (tetrahedra) | def contour_stresses(matFile, infoFile, ax=0, esize=100):
# NOTE: some bug to work out here
vertices, cells, moduli, stress, strain = pu.load_h5_material(matFile, infoFile)
# NOTE: could get list of all elements that have a vertex on a particular surface
# or get list of all cells that have a centroid ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def highlight_cells_on_tsne(tsne, cells, fig=None, ax=None):\n fig, ax = get_fig(fig=fig, ax=ax)\n ax.scatter(tsne['x'], tsne['y'], s=3, color='lightgrey')\n ax.scatter(tsne.loc[cells, 'x'], tsne.loc[cells, 'y'], s=3, color='b')\n ax.set_axis_off()\n return fig, ax",
"def _uniform_refine_tetrahedr... | [
"0.54688436",
"0.54646534",
"0.53946656",
"0.5362895",
"0.5319889",
"0.52629554",
"0.52503395",
"0.52421236",
"0.52283096",
"0.52271646",
"0.52166325",
"0.5207605",
"0.52060854",
"0.5204232",
"0.51916236",
"0.51884454",
"0.5186699",
"0.5146042",
"0.5143565",
"0.51160043",
"0.... | 0.6441977 | 0 |
Read from powerlaw database input files | def plot_powerlaw_output(timeDB, xunits='yr', yunits='MPa', skip=8, P0=33.0): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_stock(db, openfile):\n pass",
"def read_locations(db, openfile):\n pass",
"def read_sql(self):\n pass",
"def read(self):\n file_path = os.path.join(self.query_path, self.filename + '.sql')\n with open(file_path, 'r') as f:\n self.raw_sql = f.read()",
"def buil... | [
"0.62682515",
"0.6117073",
"0.6082425",
"0.5962235",
"0.59511",
"0.59221077",
"0.5916219",
"0.5915477",
"0.5911701",
"0.58680457",
"0.58508563",
"0.5843291",
"0.5842207",
"0.58020455",
"0.57885134",
"0.5770027",
"0.5762379",
"0.5760551",
"0.5756577",
"0.5716415",
"0.5681463",... | 0.0 | -1 |
Parse command line arguments. | def build_argparser():
parser = ArgumentParser()
parser.add_argument("-m", "--model", required=True, type=str,
help="Path to an xml file with a trained model.")
parser.add_argument("-i", "--input", required=True, type=str,
help="Path to image or video file")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_arguments(args):",
"def parse_command_line(self, argv):\n from optparse import OptionParser\n usage = \"usage: %prog [options]\"\n parser = OptionParser(usage)\n\n (options, args) = parser.parse_args(argv)",
"def parseArguments(self):\n iterator = iter(sys.argv[1:])... | [
"0.807208",
"0.74767",
"0.73985106",
"0.73932225",
"0.73173845",
"0.72599804",
"0.7232453",
"0.7222555",
"0.713585",
"0.7102058",
"0.71020466",
"0.7096281",
"0.7093058",
"0.70890576",
"0.7080071",
"0.70745754",
"0.70641047",
"0.70633066",
"0.70568484",
"0.7051162",
"0.7048470... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.